From 935687168ad7ccb17a160beb722f9d7d7781cc24 Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Mon, 13 Jun 2022 20:03:47 -0400 Subject: [PATCH 01/22] Initial commit From c764de12b05cfa27774e2f597870b015b55114b3 Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Mon, 13 Jun 2022 20:12:14 -0400 Subject: [PATCH 02/22] Made core changes to `Reflect` --- crates/bevy_reflect/src/reflect.rs | 35 ++++++++++++++---------------- 1 file changed, 16 insertions(+), 19 deletions(-) diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs index a0da96c189e5f..ca49df07493cf 100644 --- a/crates/bevy_reflect/src/reflect.rs +++ b/crates/bevy_reflect/src/reflect.rs @@ -2,7 +2,10 @@ use crate::{ array_debug, list_debug, map_debug, serde::Serializable, struct_debug, tuple_debug, tuple_struct_debug, Array, List, Map, Struct, Tuple, TupleStruct, TypeInfo, Typed, ValueInfo, }; -use std::{any::Any, fmt::Debug}; +use std::{ + any::{Any, TypeId}, + fmt::Debug, +}; use crate::utility::NonGenericTypeInfoCell; pub use bevy_utils::AHasher as ReflectHasher; @@ -46,17 +49,13 @@ pub enum ReflectMut<'a> { /// /// When using `#[derive(Reflect)]` with a struct or tuple struct, the suitable subtrait for that /// type (`Struct` or `TupleStruct`) is derived automatically. -/// -/// # Safety -/// Implementors _must_ ensure that [`Reflect::any`] and [`Reflect::any_mut`] both return the `self` -/// value passed in. If this is not done, [`Reflect::downcast`](trait.Reflect.html#method.downcast) -/// will be UB (and also just logically broken). -pub unsafe trait Reflect: Any + Send + Sync { - /// Returns the [type name] of the underlying type. - /// - /// [type name]: std::any::type_name +pub trait Reflect: Any + Send + Sync { + /// Returns the [Type Name][std::any::type_name] of the underlying type. fn type_name(&self) -> &str; + /// Returns the [Type ID][std::any::TypeId] of the underlying type. + fn type_id(&self) -> TypeId; + /// Returns the [`TypeInfo`] of the underlying type. /// /// This method is great if you have an instance of a type or a `dyn Reflect`, @@ -67,8 +66,11 @@ pub unsafe trait Reflect: Any + Send + Sync { /// [`TypeRegistry::get_type_info`]: crate::TypeRegistry::get_type_info fn get_type_info(&self) -> &'static TypeInfo; + /// Returns the value as a [`Box`][std::any::Any]. + fn any(self: Box) -> Box; + /// Returns the value as a [`&dyn Any`][std::any::Any]. - fn any(&self) -> &dyn Any; + fn any_ref(&self) -> &dyn Any; /// Returns the value as a [`&mut dyn Any`][std::any::Any]. fn any_mut(&mut self) -> &mut dyn Any; @@ -215,13 +217,8 @@ impl dyn Reflect { /// /// If the underlying value is not of type `T`, returns `Err(self)`. pub fn downcast(self: Box) -> Result, Box> { - // SAFE?: Same approach used by std::any::Box::downcast. ReflectValue is always Any and type - // has been checked. if self.is::() { - unsafe { - let raw: *mut dyn Reflect = Box::into_raw(self); - Ok(Box::from_raw(raw as *mut T)) - } + Ok(self.any().downcast().unwrap()) } else { Err(self) } @@ -238,7 +235,7 @@ impl dyn Reflect { /// otherwise. #[inline] pub fn is(&self) -> bool { - self.any().is::() + Reflect::type_id(self) == TypeId::of::() } /// Downcasts the value to type `T` by reference. @@ -246,7 +243,7 @@ impl dyn Reflect { /// If the underlying value is not of type `T`, returns `None`. #[inline] pub fn downcast_ref(&self) -> Option<&T> { - self.any().downcast_ref::() + self.any_ref().downcast_ref::() } /// Downcasts the value to type `T` by mutable reference. From 9a71ebf6be33f14149e3fcae6b98403d7be877cd Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Mon, 13 Jun 2022 20:40:46 -0400 Subject: [PATCH 03/22] Updated impls until it compiles again --- .../src/container_attributes.rs | 2 +- .../bevy_reflect_derive/src/from_reflect.rs | 2 +- .../bevy_reflect_derive/src/impls.rs | 46 ++++++++++--- crates/bevy_reflect/src/array.rs | 15 ++++- crates/bevy_reflect/src/impls/smallvec.rs | 15 +++-- crates/bevy_reflect/src/impls/std.rs | 66 ++++++++++++++----- crates/bevy_reflect/src/list.rs | 15 ++++- crates/bevy_reflect/src/map.rs | 13 +++- crates/bevy_reflect/src/struct_trait.rs | 15 ++++- crates/bevy_reflect/src/tuple.rs | 28 ++++++-- crates/bevy_reflect/src/tuple_struct.rs | 15 ++++- 11 files changed, 182 insertions(+), 50 deletions(-) diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs b/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs index dea47069a112d..18a7762f8ffdb 100644 --- a/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs +++ b/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 { - let value = value.any(); + let value = value.any_ref(); if let Some(value) = value.downcast_ref::() { Some(std::cmp::PartialEq::eq(self, value)) } else { diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs index 1827424c93d40..a473d2311d21b 100644 --- a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs +++ b/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 { - Some(reflect.any().downcast_ref::<#type_name #ty_generics>()?.clone()) + Some(reflect.any_ref().downcast_ref::<#type_name #ty_generics>()?.clone()) } } }) diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs b/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs index 95b8d6f0ac751..ca5489f6510b7 100644 --- a/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs +++ b/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::() } + #[inline] + fn type_id(&self) -> std::any::TypeId { + std::any::TypeId::of::() + } + #[inline] fn get_type_info(&self) -> &'static #bevy_reflect_path::TypeInfo { ::type_info() } #[inline] - fn any(&self) -> &dyn std::any::Any { + fn any(self: Box) -> Box { self } + + #[inline] + fn any_ref(&self) -> &dyn std::any::Any { + self + } + #[inline] fn any_mut(&mut self) -> &mut dyn std::any::Any { self @@ -286,15 +296,26 @@ pub(crate) fn impl_tuple_struct(derive_data: &ReflectDeriveData) -> TokenStream std::any::type_name::() } + #[inline] + fn type_id(&self) -> std::any::TypeId { + std::any::TypeId::of::() + } + #[inline] fn get_type_info(&self) -> &'static #bevy_reflect_path::TypeInfo { ::type_info() } #[inline] - fn any(&self) -> &dyn std::any::Any { + fn any(self: Box) -> Box { 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 +400,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::() } + #[inline] + fn type_id(&self) -> std::any::TypeId { + std::any::TypeId::of::() + } + #[inline] fn get_type_info(&self) -> &'static #bevy_reflect_path::TypeInfo { ::type_info() } #[inline] - fn any(&self) -> &dyn std::any::Any { + fn any(self: Box) -> Box { + self + } + + #[inline] + fn any_ref(&self) -> &dyn std::any::Any { self } @@ -418,7 +448,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 = value.clone(); } else { diff --git a/crates/bevy_reflect/src/array.rs b/crates/bevy_reflect/src/array.rs index f94e0e6cceaa4..a90167af42c44 100644 --- a/crates/bevy_reflect/src/array.rs +++ b/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::() + } + #[inline] fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } #[inline] - fn any(&self) -> &dyn Any { + fn any(self: Box) -> Box { + self + } + + #[inline] + fn any_ref(&self) -> &dyn Any { self } diff --git a/crates/bevy_reflect/src/impls/smallvec.rs b/crates/bevy_reflect/src/impls/smallvec.rs index 2ab1f97869c1e..fb2fa7e5ced25 100644 --- a/crates/bevy_reflect/src/impls/smallvec.rs +++ b/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,8 +55,7 @@ where } } -// SAFE: any and any_mut both return self -unsafe impl Reflect for SmallVec +impl Reflect for SmallVec where T::Item: FromReflect + Clone, { @@ -64,11 +63,19 @@ where std::any::type_name::() } + fn type_id(&self) -> TypeId { + TypeId::of::() + } + fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } - fn any(&self) -> &dyn Any { + fn any(self: Box) -> Box { + self + } + + fn any_ref(&self) -> &dyn Any { self } diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs index c5fed20da26ec..a070804ec4824 100644 --- a/crates/bevy_reflect/src/impls/std.rs +++ b/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 List for Vec { } // SAFE: any and any_mut both return self -unsafe impl Reflect for Vec { +impl Reflect for Vec { fn type_name(&self) -> &str { std::any::type_name::() } + fn type_id(&self) -> TypeId { + TypeId::of::() + } + fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } - fn any(&self) -> &dyn Any { + fn any(self: Box) -> Box { + self + } + + fn any_ref(&self) -> &dyn Any { self } @@ -234,17 +242,24 @@ impl Map for HashMap { } } -// SAFE: any and any_mut both return self -unsafe impl Reflect for HashMap { +impl Reflect for HashMap { fn type_name(&self) -> &str { std::any::type_name::() } + fn type_id(&self) -> TypeId { + TypeId::of::() + } + fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } - fn any(&self) -> &dyn Any { + fn any(self: Box) -> Box { + self + } + + fn any_ref(&self) -> &dyn Any { self } @@ -354,19 +369,28 @@ impl Array for [T; N] { } } -// SAFE: any and any_mut both return self -unsafe impl Reflect for [T; N] { +impl Reflect for [T; N] { #[inline] fn type_name(&self) -> &str { std::any::type_name::() } + #[inline] + fn type_id(&self) -> TypeId { + TypeId::of::() + } + fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } #[inline] - fn any(&self) -> &dyn Any { + fn any(self: Box) -> Box { + 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::() } + fn type_id(&self) -> TypeId { + TypeId::of::() + } + fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } - fn any(&self) -> &dyn Any { + fn any(self: Box) -> Box { + 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 = value.clone(); } else { @@ -534,7 +565,7 @@ unsafe impl Reflect for Cow<'static, str> { } fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option { - let value = value.any(); + let value = value.any_ref(); if let Some(value) = value.downcast_ref::() { 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 { - Some(reflect.any().downcast_ref::>()?.clone()) + Some( + reflect + .any_ref() + .downcast_ref::>()? + .clone(), + ) } } diff --git a/crates/bevy_reflect/src/list.rs b/crates/bevy_reflect/src/list.rs index 66d3816707adb..7b34aa3eecda0 100644 --- a/crates/bevy_reflect/src/list.rs +++ b/crates/bevy_reflect/src/list.rs @@ -163,20 +163,29 @@ impl List for DynamicList { } } -// SAFE: any and any_mut both return self -unsafe impl Reflect for DynamicList { +impl Reflect for DynamicList { #[inline] fn type_name(&self) -> &str { self.name.as_str() } + #[inline] + fn type_id(&self) -> TypeId { + TypeId::of::() + } + #[inline] fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } #[inline] - fn any(&self) -> &dyn Any { + fn any(self: Box) -> Box { + self + } + + #[inline] + fn any_ref(&self) -> &dyn Any { self } diff --git a/crates/bevy_reflect/src/map.rs b/crates/bevy_reflect/src/map.rs index 88f0f63a1c85f..780a44697c8f4 100644 --- a/crates/bevy_reflect/src/map.rs +++ b/crates/bevy_reflect/src/map.rs @@ -212,18 +212,25 @@ impl Map for DynamicMap { } } -// SAFE: any and any_mut both return self -unsafe impl Reflect for DynamicMap { +impl Reflect for DynamicMap { fn type_name(&self) -> &str { &self.name } + fn type_id(&self) -> TypeId { + TypeId::of::() + } + #[inline] fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } - fn any(&self) -> &dyn Any { + fn any(self: Box) -> Box { + self + } + + fn any_ref(&self) -> &dyn Any { self } diff --git a/crates/bevy_reflect/src/struct_trait.rs b/crates/bevy_reflect/src/struct_trait.rs index ac06e4a5b0469..f74ef3acf08ee 100644 --- a/crates/bevy_reflect/src/struct_trait.rs +++ b/crates/bevy_reflect/src/struct_trait.rs @@ -337,20 +337,29 @@ impl Struct for DynamicStruct { } } -// SAFE: any and any_mut both return self -unsafe impl Reflect for DynamicStruct { +impl Reflect for DynamicStruct { #[inline] fn type_name(&self) -> &str { &self.name } + #[inline] + fn type_id(&self) -> TypeId { + TypeId::of::() + } + #[inline] fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } #[inline] - fn any(&self) -> &dyn Any { + fn any(self: Box) -> Box { + self + } + + #[inline] + fn any_ref(&self) -> &dyn Any { self } diff --git a/crates/bevy_reflect/src/tuple.rs b/crates/bevy_reflect/src/tuple.rs index bab117e5e5d6a..88c448c94c413 100644 --- a/crates/bevy_reflect/src/tuple.rs +++ b/crates/bevy_reflect/src/tuple.rs @@ -267,20 +267,29 @@ impl Tuple for DynamicTuple { } } -// SAFE: any and any_mut both return self -unsafe impl Reflect for DynamicTuple { +impl Reflect for DynamicTuple { #[inline] fn type_name(&self) -> &str { self.name() } + #[inline] + fn type_id(&self) -> TypeId { + TypeId::of::() + } + #[inline] fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } #[inline] - fn any(&self) -> &dyn Any { + fn any(self: Box) -> Box { + self + } + + #[inline] + fn any_ref(&self) -> &dyn Any { self } @@ -460,17 +469,24 @@ macro_rules! impl_reflect_tuple { } } - // SAFE: any and any_mut both return self - unsafe impl<$($name: Reflect),*> Reflect for ($($name,)*) { + impl<$($name: Reflect),*> Reflect for ($($name,)*) { fn type_name(&self) -> &str { std::any::type_name::() } + fn type_id(&self) -> TypeId { + TypeId::of::() + } + fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } - fn any(&self) -> &dyn Any { + fn any(self: Box) -> Box { + self + } + + fn any_ref(&self) -> &dyn Any { self } diff --git a/crates/bevy_reflect/src/tuple_struct.rs b/crates/bevy_reflect/src/tuple_struct.rs index e3a8afa8a8bb6..6e03e07400205 100644 --- a/crates/bevy_reflect/src/tuple_struct.rs +++ b/crates/bevy_reflect/src/tuple_struct.rs @@ -251,20 +251,29 @@ impl TupleStruct for DynamicTupleStruct { } } -// SAFE: any and any_mut both return self -unsafe impl Reflect for DynamicTupleStruct { +impl Reflect for DynamicTupleStruct { #[inline] fn type_name(&self) -> &str { self.name.as_str() } + #[inline] + fn type_id(&self) -> TypeId { + TypeId::of::() + } + #[inline] fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } #[inline] - fn any(&self) -> &dyn Any { + fn any(self: Box) -> Box { + self + } + + #[inline] + fn any_ref(&self) -> &dyn Any { self } From 47e68022f59e16ef18b6304e119330708a0dd4be Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Mon, 13 Jun 2022 20:48:58 -0400 Subject: [PATCH 04/22] Got tests compiling and passing --- .../bevy_reflect_derive/src/impls.rs | 3 +-- crates/bevy_reflect/src/type_info.rs | 8 +++++--- crates/bevy_reflect/src/utility.rs | 16 ++++++++++------ 3 files changed, 16 insertions(+), 11 deletions(-) diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs b/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs index ca5489f6510b7..24bd59fb2f214 100644 --- a/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs +++ b/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs @@ -289,8 +289,7 @@ 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::() diff --git a/crates/bevy_reflect/src/type_info.rs b/crates/bevy_reflect/src/type_info.rs index 2d1d1f5327525..579f9abda1655 100644 --- a/crates/bevy_reflect/src/type_info.rs +++ b/crates/bevy_reflect/src/type_info.rs @@ -20,7 +20,7 @@ use std::any::{Any, TypeId}; /// # Example /// /// ``` -/// # use std::any::Any; +/// # use std::any::{Any, TypeId}; /// # use bevy_reflect::{NamedField, Reflect, ReflectMut, ReflectRef, StructInfo, TypeInfo, ValueInfo}; /// # use bevy_reflect::utility::NonGenericTypeInfoCell; /// use bevy_reflect::Typed; @@ -45,10 +45,12 @@ use std::any::{Any, TypeId}; /// } /// /// # -/// # unsafe impl Reflect for MyStruct { +/// # impl Reflect for MyStruct { /// # fn type_name(&self) -> &str { todo!() } +/// # fn type_id(&self) -> TypeId { todo!() } /// # fn get_type_info(&self) -> &'static TypeInfo { todo!() } -/// # fn any(&self) -> &dyn Any { todo!() } +/// # fn any(self: Box) -> Box { todo!() } +/// # fn any_ref(&self) -> &dyn Any { todo!() } /// # fn any_mut(&mut self) -> &mut dyn Any { todo!() } /// # fn as_reflect(&self) -> &dyn Reflect { todo!() } /// # fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() } diff --git a/crates/bevy_reflect/src/utility.rs b/crates/bevy_reflect/src/utility.rs index a597539afdb02..f3056b09d1e8a 100644 --- a/crates/bevy_reflect/src/utility.rs +++ b/crates/bevy_reflect/src/utility.rs @@ -15,7 +15,7 @@ use std::any::{Any, TypeId}; /// ## Example /// /// ``` -/// # use std::any::Any; +/// # use std::any::{Any, TypeId}; /// # use bevy_reflect::{NamedField, Reflect, ReflectMut, ReflectRef, StructInfo, Typed, TypeInfo}; /// use bevy_reflect::utility::NonGenericTypeInfoCell; /// @@ -34,10 +34,12 @@ use std::any::{Any, TypeId}; /// } /// } /// # -/// # unsafe impl Reflect for Foo { +/// # impl Reflect for Foo { /// # fn type_name(&self) -> &str { todo!() } +/// # fn type_id(&self) -> TypeId { todo!() } /// # fn get_type_info(&self) -> &'static TypeInfo { todo!() } -/// # fn any(&self) -> &dyn Any { todo!() } +/// # fn any(self: Box) -> Box { todo!() } +/// # fn any_ref(&self) -> &dyn Any { todo!() } /// # fn any_mut(&mut self) -> &mut dyn Any { todo!() } /// # fn as_reflect(&self) -> &dyn Reflect { todo!() } /// # fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() } @@ -77,7 +79,7 @@ impl NonGenericTypeInfoCell { /// ## Example /// /// ``` -/// # use std::any::Any; +/// # use std::any::{Any, TypeId}; /// # use bevy_reflect::{Reflect, ReflectMut, ReflectRef, TupleStructInfo, Typed, TypeInfo, UnnamedField}; /// use bevy_reflect::utility::GenericTypeInfoCell; /// @@ -94,10 +96,12 @@ impl NonGenericTypeInfoCell { /// } /// } /// # -/// # unsafe impl Reflect for Foo { +/// # impl Reflect for Foo { /// # fn type_name(&self) -> &str { todo!() } +/// # fn type_id(&self) -> TypeId { todo!() } /// # fn get_type_info(&self) -> &'static TypeInfo { todo!() } -/// # fn any(&self) -> &dyn Any { todo!() } +/// # fn any(self: Box) -> Box { todo!() } +/// # fn any_ref(&self) -> &dyn Any { todo!() } /// # fn any_mut(&mut self) -> &mut dyn Any { todo!() } /// # fn as_reflect(&self) -> &dyn Reflect { todo!() } /// # fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() } From 479e63d4ba7540cf5f981631ef2545ff94665a36 Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Mon, 13 Jun 2022 20:56:29 -0400 Subject: [PATCH 05/22] Added downcast test --- crates/bevy_reflect/src/lib.rs | 36 ++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs index 5519b8031841c..dedd6937dddfc 100644 --- a/crates/bevy_reflect/src/lib.rs +++ b/crates/bevy_reflect/src/lib.rs @@ -485,6 +485,42 @@ mod tests { assert!(foo.reflect_partial_eq(&dynamic_struct).unwrap()); } + #[test] + fn reflect_downcast() { + #[derive(Reflect, Clone, Debug, PartialEq)] + struct Bar { + y: u8, + z: ::glam::Mat4, + } + + #[derive(Reflect, Clone, Debug, PartialEq)] + struct Foo { + x: i32, + s: String, + b: Bar, + u: usize, + t: (Vec3, String), + } + + let foo = Foo { + x: 123, + s: "String".to_string(), + b: Bar { + y: 255, + z: ::glam::Mat4::from_cols_array(&[ + 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, + 15.0, + ]), + }, + u: 1111111111111, + t: (Vec3::new(3.0, 2.0, 1.0), "Tuple String".to_string()), + }; + + let foo2: Box = Box::new(foo.clone()); + + assert_eq!(foo, *foo2.downcast::().unwrap()); + } + #[test] fn reflect_take() { #[derive(Reflect, Debug, PartialEq)] From ff804f790a2606e594efa781a866b51be44de8d4 Mon Sep 17 00:00:00 2001 From: PROMETHIA-27 <42193387+PROMETHIA-27@users.noreply.github.com> Date: Mon, 13 Jun 2022 21:19:43 -0400 Subject: [PATCH 06/22] Remove missed safety comment Co-authored-by: Gingeh <39150378+Gingeh@users.noreply.github.com> --- crates/bevy_reflect/src/impls/std.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs index a070804ec4824..84a75ac1c1c1e 100644 --- a/crates/bevy_reflect/src/impls/std.rs +++ b/crates/bevy_reflect/src/impls/std.rs @@ -105,7 +105,6 @@ impl List for Vec { } } -// SAFE: any and any_mut both return self impl Reflect for Vec { fn type_name(&self) -> &str { std::any::type_name::() From 4611cc9c8fb79d1358b17c557255f933592d7beb Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Mon, 13 Jun 2022 21:37:55 -0400 Subject: [PATCH 07/22] Updated example to use `Reflect::type_id()` Hopefully fix CI? --- examples/reflection/trait_reflection.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/reflection/trait_reflection.rs b/examples/reflection/trait_reflection.rs index 0c4c4eaf4004c..ebc1918123e77 100644 --- a/examples/reflection/trait_reflection.rs +++ b/examples/reflection/trait_reflection.rs @@ -45,7 +45,7 @@ fn setup(type_registry: Res) { // The #[reflect] attribute we put on our DoThing trait generated a new `ReflectDoThing` struct, // which implements TypeData. This was added to MyType's TypeRegistration. let reflect_do_thing = type_registry - .get_type_data::(reflect_value.type_id()) + .get_type_data::(Reflect::type_id(&*reflect_value)) .unwrap(); // We can use this generated type to convert our `&dyn Reflect` reference to a `&dyn DoThing` From 1916a2f1bb7cfcd108300a95cca4b2446bbb82fe Mon Sep 17 00:00:00 2001 From: PROMETHIA-27 <42193387+PROMETHIA-27@users.noreply.github.com> Date: Mon, 13 Jun 2022 22:53:33 -0400 Subject: [PATCH 08/22] Type ID -> `TypeId` Co-authored-by: Gino Valente <49806985+MrGVSV@users.noreply.github.com> --- crates/bevy_reflect/src/reflect.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs index ca49df07493cf..be3d66e7ab6e7 100644 --- a/crates/bevy_reflect/src/reflect.rs +++ b/crates/bevy_reflect/src/reflect.rs @@ -53,7 +53,7 @@ pub trait Reflect: Any + Send + Sync { /// Returns the [Type Name][std::any::type_name] of the underlying type. fn type_name(&self) -> &str; - /// Returns the [Type ID][std::any::TypeId] of the underlying type. + /// Returns the [`TypeId`] of the underlying type. fn type_id(&self) -> TypeId; /// Returns the [`TypeInfo`] of the underlying type. From 4bcfc1f36d47ebd8d4ccd0250f02ef022d8fe6b1 Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Mon, 13 Jun 2022 23:02:27 -0400 Subject: [PATCH 09/22] Made type_id() impl default --- .../bevy_reflect_derive/src/impls.rs | 15 --------------- crates/bevy_reflect/src/array.rs | 5 ----- crates/bevy_reflect/src/impls/smallvec.rs | 4 ---- crates/bevy_reflect/src/impls/std.rs | 17 ----------------- crates/bevy_reflect/src/list.rs | 5 ----- crates/bevy_reflect/src/map.rs | 4 ---- crates/bevy_reflect/src/reflect.rs | 4 +++- crates/bevy_reflect/src/struct_trait.rs | 5 ----- crates/bevy_reflect/src/tuple.rs | 9 --------- crates/bevy_reflect/src/tuple_struct.rs | 5 ----- crates/bevy_reflect/src/type_info.rs | 1 - crates/bevy_reflect/src/utility.rs | 2 -- 12 files changed, 3 insertions(+), 73 deletions(-) diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs b/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs index 24bd59fb2f214..6246c681740d8 100644 --- a/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs +++ b/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs @@ -132,11 +132,6 @@ pub(crate) fn impl_struct(derive_data: &ReflectDeriveData) -> TokenStream { std::any::type_name::() } - #[inline] - fn type_id(&self) -> std::any::TypeId { - std::any::TypeId::of::() - } - #[inline] fn get_type_info(&self) -> &'static #bevy_reflect_path::TypeInfo { ::type_info() @@ -295,11 +290,6 @@ pub(crate) fn impl_tuple_struct(derive_data: &ReflectDeriveData) -> TokenStream std::any::type_name::() } - #[inline] - fn type_id(&self) -> std::any::TypeId { - std::any::TypeId::of::() - } - #[inline] fn get_type_info(&self) -> &'static #bevy_reflect_path::TypeInfo { ::type_info() @@ -405,11 +395,6 @@ pub(crate) fn impl_value( std::any::type_name::() } - #[inline] - fn type_id(&self) -> std::any::TypeId { - std::any::TypeId::of::() - } - #[inline] fn get_type_info(&self) -> &'static #bevy_reflect_path::TypeInfo { ::type_info() diff --git a/crates/bevy_reflect/src/array.rs b/crates/bevy_reflect/src/array.rs index a90167af42c44..100f376c57980 100644 --- a/crates/bevy_reflect/src/array.rs +++ b/crates/bevy_reflect/src/array.rs @@ -158,11 +158,6 @@ impl Reflect for DynamicArray { self.name.as_str() } - #[inline] - fn type_id(&self) -> TypeId { - TypeId::of::() - } - #[inline] fn get_type_info(&self) -> &'static TypeInfo { ::type_info() diff --git a/crates/bevy_reflect/src/impls/smallvec.rs b/crates/bevy_reflect/src/impls/smallvec.rs index fb2fa7e5ced25..c7de6e7355395 100644 --- a/crates/bevy_reflect/src/impls/smallvec.rs +++ b/crates/bevy_reflect/src/impls/smallvec.rs @@ -63,10 +63,6 @@ where std::any::type_name::() } - fn type_id(&self) -> TypeId { - TypeId::of::() - } - fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs index 84a75ac1c1c1e..89f3c6a467514 100644 --- a/crates/bevy_reflect/src/impls/std.rs +++ b/crates/bevy_reflect/src/impls/std.rs @@ -110,10 +110,6 @@ impl Reflect for Vec { std::any::type_name::() } - fn type_id(&self) -> TypeId { - TypeId::of::() - } - fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } @@ -246,10 +242,6 @@ impl Reflect for HashMap { std::any::type_name::() } - fn type_id(&self) -> TypeId { - TypeId::of::() - } - fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } @@ -374,11 +366,6 @@ impl Reflect for [T; N] { std::any::type_name::() } - #[inline] - fn type_id(&self) -> TypeId { - TypeId::of::() - } - fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } @@ -502,10 +489,6 @@ impl Reflect for Cow<'static, str> { std::any::type_name::() } - fn type_id(&self) -> TypeId { - TypeId::of::() - } - fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } diff --git a/crates/bevy_reflect/src/list.rs b/crates/bevy_reflect/src/list.rs index 7b34aa3eecda0..7d26de92fc537 100644 --- a/crates/bevy_reflect/src/list.rs +++ b/crates/bevy_reflect/src/list.rs @@ -169,11 +169,6 @@ impl Reflect for DynamicList { self.name.as_str() } - #[inline] - fn type_id(&self) -> TypeId { - TypeId::of::() - } - #[inline] fn get_type_info(&self) -> &'static TypeInfo { ::type_info() diff --git a/crates/bevy_reflect/src/map.rs b/crates/bevy_reflect/src/map.rs index 780a44697c8f4..681605ccc37df 100644 --- a/crates/bevy_reflect/src/map.rs +++ b/crates/bevy_reflect/src/map.rs @@ -217,10 +217,6 @@ impl Reflect for DynamicMap { &self.name } - fn type_id(&self) -> TypeId { - TypeId::of::() - } - #[inline] fn get_type_info(&self) -> &'static TypeInfo { ::type_info() diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs index be3d66e7ab6e7..921a40ab29555 100644 --- a/crates/bevy_reflect/src/reflect.rs +++ b/crates/bevy_reflect/src/reflect.rs @@ -54,7 +54,9 @@ pub trait Reflect: Any + Send + Sync { fn type_name(&self) -> &str; /// Returns the [`TypeId`] of the underlying type. - fn type_id(&self) -> TypeId; + fn type_id(&self) -> TypeId { + TypeId::of::() + } /// Returns the [`TypeInfo`] of the underlying type. /// diff --git a/crates/bevy_reflect/src/struct_trait.rs b/crates/bevy_reflect/src/struct_trait.rs index f74ef3acf08ee..0a24225bc2241 100644 --- a/crates/bevy_reflect/src/struct_trait.rs +++ b/crates/bevy_reflect/src/struct_trait.rs @@ -343,11 +343,6 @@ impl Reflect for DynamicStruct { &self.name } - #[inline] - fn type_id(&self) -> TypeId { - TypeId::of::() - } - #[inline] fn get_type_info(&self) -> &'static TypeInfo { ::type_info() diff --git a/crates/bevy_reflect/src/tuple.rs b/crates/bevy_reflect/src/tuple.rs index 88c448c94c413..cacc2447e224c 100644 --- a/crates/bevy_reflect/src/tuple.rs +++ b/crates/bevy_reflect/src/tuple.rs @@ -273,11 +273,6 @@ impl Reflect for DynamicTuple { self.name() } - #[inline] - fn type_id(&self) -> TypeId { - TypeId::of::() - } - #[inline] fn get_type_info(&self) -> &'static TypeInfo { ::type_info() @@ -474,10 +469,6 @@ macro_rules! impl_reflect_tuple { std::any::type_name::() } - fn type_id(&self) -> TypeId { - TypeId::of::() - } - fn get_type_info(&self) -> &'static TypeInfo { ::type_info() } diff --git a/crates/bevy_reflect/src/tuple_struct.rs b/crates/bevy_reflect/src/tuple_struct.rs index 6e03e07400205..a6000a0ffb59b 100644 --- a/crates/bevy_reflect/src/tuple_struct.rs +++ b/crates/bevy_reflect/src/tuple_struct.rs @@ -257,11 +257,6 @@ impl Reflect for DynamicTupleStruct { self.name.as_str() } - #[inline] - fn type_id(&self) -> TypeId { - TypeId::of::() - } - #[inline] fn get_type_info(&self) -> &'static TypeInfo { ::type_info() diff --git a/crates/bevy_reflect/src/type_info.rs b/crates/bevy_reflect/src/type_info.rs index 579f9abda1655..fe80e307d859f 100644 --- a/crates/bevy_reflect/src/type_info.rs +++ b/crates/bevy_reflect/src/type_info.rs @@ -47,7 +47,6 @@ use std::any::{Any, TypeId}; /// # /// # impl Reflect for MyStruct { /// # fn type_name(&self) -> &str { todo!() } -/// # fn type_id(&self) -> TypeId { todo!() } /// # fn get_type_info(&self) -> &'static TypeInfo { todo!() } /// # fn any(self: Box) -> Box { todo!() } /// # fn any_ref(&self) -> &dyn Any { todo!() } diff --git a/crates/bevy_reflect/src/utility.rs b/crates/bevy_reflect/src/utility.rs index f3056b09d1e8a..e1190ab5fc5b5 100644 --- a/crates/bevy_reflect/src/utility.rs +++ b/crates/bevy_reflect/src/utility.rs @@ -36,7 +36,6 @@ use std::any::{Any, TypeId}; /// # /// # impl Reflect for Foo { /// # fn type_name(&self) -> &str { todo!() } -/// # fn type_id(&self) -> TypeId { todo!() } /// # fn get_type_info(&self) -> &'static TypeInfo { todo!() } /// # fn any(self: Box) -> Box { todo!() } /// # fn any_ref(&self) -> &dyn Any { todo!() } @@ -98,7 +97,6 @@ impl NonGenericTypeInfoCell { /// # /// # impl Reflect for Foo { /// # fn type_name(&self) -> &str { todo!() } -/// # fn type_id(&self) -> TypeId { todo!() } /// # fn get_type_info(&self) -> &'static TypeInfo { todo!() } /// # fn any(self: Box) -> Box { todo!() } /// # fn any_ref(&self) -> &dyn Any { todo!() } From 2a7d0f0bbd2cbbc742acacb612968918331adb46 Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Tue, 14 Jun 2022 10:05:21 -0400 Subject: [PATCH 10/22] Removed unused imports --- crates/bevy_reflect/src/impls/smallvec.rs | 2 +- crates/bevy_reflect/src/impls/std.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/crates/bevy_reflect/src/impls/smallvec.rs b/crates/bevy_reflect/src/impls/smallvec.rs index c7de6e7355395..70ef1fff9c1e1 100644 --- a/crates/bevy_reflect/src/impls/smallvec.rs +++ b/crates/bevy_reflect/src/impls/smallvec.rs @@ -1,5 +1,5 @@ use smallvec::SmallVec; -use std::any::{Any, TypeId}; +use std::any::Any; use crate::utility::GenericTypeInfoCell; use crate::{ diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs index 89f3c6a467514..0fc1dfc903b7e 100644 --- a/crates/bevy_reflect/src/impls/std.rs +++ b/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, TypeId}, + any::Any, borrow::Cow, hash::{Hash, Hasher}, ops::Range, From 6a04778f0dc9213c5353fb03cf7868e8ab510b9c Mon Sep 17 00:00:00 2001 From: PROMETHIA-27 <42193387+PROMETHIA-27@users.noreply.github.com> Date: Fri, 17 Jun 2022 12:15:33 -0400 Subject: [PATCH 11/22] Type Name -> type name Co-authored-by: Gino Valente <49806985+MrGVSV@users.noreply.github.com> --- crates/bevy_reflect/src/reflect.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs index 921a40ab29555..fa4eecdaa8808 100644 --- a/crates/bevy_reflect/src/reflect.rs +++ b/crates/bevy_reflect/src/reflect.rs @@ -50,7 +50,7 @@ pub enum ReflectMut<'a> { /// When using `#[derive(Reflect)]` with a struct or tuple struct, the suitable subtrait for that /// type (`Struct` or `TupleStruct`) is derived automatically. pub trait Reflect: Any + Send + Sync { - /// Returns the [Type Name][std::any::type_name] of the underlying type. + /// Returns the [type name][std::any::type_name] of the underlying type. fn type_name(&self) -> &str; /// Returns the [`TypeId`] of the underlying type. From 05d01f9f30cf0b44522667c2ff47c640941f7086 Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Mon, 20 Jun 2022 20:15:09 -0400 Subject: [PATCH 12/22] change to better naming scheme --- .../bevy_reflect_derive/src/impls.rs | 20 ++++++------- crates/bevy_reflect/src/array.rs | 6 ++-- crates/bevy_reflect/src/impls/smallvec.rs | 6 ++-- crates/bevy_reflect/src/impls/std.rs | 30 +++++++++---------- crates/bevy_reflect/src/list.rs | 6 ++-- crates/bevy_reflect/src/map.rs | 6 ++-- crates/bevy_reflect/src/reflect.rs | 12 ++++---- crates/bevy_reflect/src/struct_trait.rs | 6 ++-- crates/bevy_reflect/src/tuple.rs | 12 ++++---- crates/bevy_reflect/src/tuple_struct.rs | 6 ++-- 10 files changed, 55 insertions(+), 55 deletions(-) diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs b/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs index 6246c681740d8..0d42c3e69fe44 100644 --- a/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs +++ b/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs @@ -138,17 +138,17 @@ pub(crate) fn impl_struct(derive_data: &ReflectDeriveData) -> TokenStream { } #[inline] - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } #[inline] - fn any_ref(&self) -> &dyn std::any::Any { + fn as_any(&self) -> &dyn std::any::Any { self } #[inline] - fn any_mut(&mut self) -> &mut dyn std::any::Any { + fn as_mut_any(&mut self) -> &mut dyn std::any::Any { self } @@ -296,17 +296,17 @@ pub(crate) fn impl_tuple_struct(derive_data: &ReflectDeriveData) -> TokenStream } #[inline] - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } #[inline] - fn any_ref(&self) -> &dyn std::any::Any { + fn as_any(&self) -> &dyn std::any::Any { self } #[inline] - fn any_mut(&mut self) -> &mut dyn std::any::Any { + fn as_mut_any(&mut self) -> &mut dyn std::any::Any { self } @@ -401,17 +401,17 @@ pub(crate) fn impl_value( } #[inline] - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } #[inline] - fn any_ref(&self) -> &dyn std::any::Any { + fn as_any(&self) -> &dyn std::any::Any { self } #[inline] - fn any_mut(&mut self) -> &mut dyn std::any::Any { + fn as_mut_any(&mut self) -> &mut dyn std::any::Any { self } @@ -432,7 +432,7 @@ pub(crate) fn impl_value( #[inline] fn apply(&mut self, value: &dyn #bevy_reflect_path::Reflect) { - let value = value.any_ref(); + let value = value.as_any(); if let Some(value) = value.downcast_ref::() { *self = value.clone(); } else { diff --git a/crates/bevy_reflect/src/array.rs b/crates/bevy_reflect/src/array.rs index 100f376c57980..0e1820fb8bd07 100644 --- a/crates/bevy_reflect/src/array.rs +++ b/crates/bevy_reflect/src/array.rs @@ -164,17 +164,17 @@ impl Reflect for DynamicArray { } #[inline] - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } #[inline] - fn any_ref(&self) -> &dyn Any { + fn as_any(&self) -> &dyn Any { self } #[inline] - fn any_mut(&mut self) -> &mut dyn Any { + fn as_mut_any(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/impls/smallvec.rs b/crates/bevy_reflect/src/impls/smallvec.rs index 70ef1fff9c1e1..c3a7023ccb3db 100644 --- a/crates/bevy_reflect/src/impls/smallvec.rs +++ b/crates/bevy_reflect/src/impls/smallvec.rs @@ -67,15 +67,15 @@ where ::type_info() } - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } - fn any_ref(&self) -> &dyn Any { + fn as_any(&self) -> &dyn Any { self } - fn any_mut(&mut self) -> &mut dyn Any { + fn as_mut_any(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs index 0fc1dfc903b7e..24ba6b588dd4b 100644 --- a/crates/bevy_reflect/src/impls/std.rs +++ b/crates/bevy_reflect/src/impls/std.rs @@ -114,15 +114,15 @@ impl Reflect for Vec { ::type_info() } - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } - fn any_ref(&self) -> &dyn Any { + fn as_any(&self) -> &dyn Any { self } - fn any_mut(&mut self) -> &mut dyn Any { + fn as_mut_any(&mut self) -> &mut dyn Any { self } @@ -246,15 +246,15 @@ impl Reflect for HashMap { ::type_info() } - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } - fn any_ref(&self) -> &dyn Any { + fn as_any(&self) -> &dyn Any { self } - fn any_mut(&mut self) -> &mut dyn Any { + fn as_mut_any(&mut self) -> &mut dyn Any { self } @@ -371,17 +371,17 @@ impl Reflect for [T; N] { } #[inline] - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } #[inline] - fn any_ref(&self) -> &dyn Any { + fn as_any(&self) -> &dyn Any { self } #[inline] - fn any_mut(&mut self) -> &mut dyn Any { + fn as_mut_any(&mut self) -> &mut dyn Any { self } @@ -493,15 +493,15 @@ impl Reflect for Cow<'static, str> { ::type_info() } - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } - fn any_ref(&self) -> &dyn Any { + fn as_any(&self) -> &dyn Any { self } - fn any_mut(&mut self) -> &mut dyn Any { + fn as_mut_any(&mut self) -> &mut dyn Any { self } @@ -514,7 +514,7 @@ impl Reflect for Cow<'static, str> { } fn apply(&mut self, value: &dyn Reflect) { - let value = value.any_ref(); + let value = value.as_any(); if let Some(value) = value.downcast_ref::() { *self = value.clone(); } else { @@ -547,7 +547,7 @@ impl Reflect for Cow<'static, str> { } fn reflect_partial_eq(&self, value: &dyn Reflect) -> Option { - let value = value.any_ref(); + let value = value.as_any(); if let Some(value) = value.downcast_ref::() { Some(std::cmp::PartialEq::eq(self, value)) } else { @@ -579,7 +579,7 @@ impl FromReflect for Cow<'static, str> { fn from_reflect(reflect: &dyn crate::Reflect) -> Option { Some( reflect - .any_ref() + .as_any() .downcast_ref::>()? .clone(), ) diff --git a/crates/bevy_reflect/src/list.rs b/crates/bevy_reflect/src/list.rs index 7d26de92fc537..50d004c0d9121 100644 --- a/crates/bevy_reflect/src/list.rs +++ b/crates/bevy_reflect/src/list.rs @@ -175,17 +175,17 @@ impl Reflect for DynamicList { } #[inline] - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } #[inline] - fn any_ref(&self) -> &dyn Any { + fn as_any(&self) -> &dyn Any { self } #[inline] - fn any_mut(&mut self) -> &mut dyn Any { + fn as_mut_any(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/map.rs b/crates/bevy_reflect/src/map.rs index 681605ccc37df..2b65a1f31ecd5 100644 --- a/crates/bevy_reflect/src/map.rs +++ b/crates/bevy_reflect/src/map.rs @@ -222,15 +222,15 @@ impl Reflect for DynamicMap { ::type_info() } - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } - fn any_ref(&self) -> &dyn Any { + fn as_any(&self) -> &dyn Any { self } - fn any_mut(&mut self) -> &mut dyn Any { + fn as_mut_any(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs index 921a40ab29555..7babeefccacbf 100644 --- a/crates/bevy_reflect/src/reflect.rs +++ b/crates/bevy_reflect/src/reflect.rs @@ -69,13 +69,13 @@ pub trait Reflect: Any + Send + Sync { fn get_type_info(&self) -> &'static TypeInfo; /// Returns the value as a [`Box`][std::any::Any]. - fn any(self: Box) -> Box; + fn into_any(self: Box) -> Box; /// Returns the value as a [`&dyn Any`][std::any::Any]. - fn any_ref(&self) -> &dyn Any; + fn as_any(&self) -> &dyn Any; /// Returns the value as a [`&mut dyn Any`][std::any::Any]. - fn any_mut(&mut self) -> &mut dyn Any; + fn as_mut_any(&mut self) -> &mut dyn Any; /// Casts this type to a reflected value fn as_reflect(&self) -> &dyn Reflect; @@ -220,7 +220,7 @@ impl dyn Reflect { /// If the underlying value is not of type `T`, returns `Err(self)`. pub fn downcast(self: Box) -> Result, Box> { if self.is::() { - Ok(self.any().downcast().unwrap()) + Ok(self.into_any().downcast().unwrap()) } else { Err(self) } @@ -245,7 +245,7 @@ impl dyn Reflect { /// If the underlying value is not of type `T`, returns `None`. #[inline] pub fn downcast_ref(&self) -> Option<&T> { - self.any_ref().downcast_ref::() + self.as_any().downcast_ref::() } /// Downcasts the value to type `T` by mutable reference. @@ -253,6 +253,6 @@ impl dyn Reflect { /// If the underlying value is not of type `T`, returns `None`. #[inline] pub fn downcast_mut(&mut self) -> Option<&mut T> { - self.any_mut().downcast_mut::() + self.as_mut_any().downcast_mut::() } } diff --git a/crates/bevy_reflect/src/struct_trait.rs b/crates/bevy_reflect/src/struct_trait.rs index 0a24225bc2241..fdb72de7735dd 100644 --- a/crates/bevy_reflect/src/struct_trait.rs +++ b/crates/bevy_reflect/src/struct_trait.rs @@ -349,17 +349,17 @@ impl Reflect for DynamicStruct { } #[inline] - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } #[inline] - fn any_ref(&self) -> &dyn Any { + fn as_any(&self) -> &dyn Any { self } #[inline] - fn any_mut(&mut self) -> &mut dyn Any { + fn as_mut_any(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/tuple.rs b/crates/bevy_reflect/src/tuple.rs index cacc2447e224c..8b8920a962dfb 100644 --- a/crates/bevy_reflect/src/tuple.rs +++ b/crates/bevy_reflect/src/tuple.rs @@ -279,17 +279,17 @@ impl Reflect for DynamicTuple { } #[inline] - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } #[inline] - fn any_ref(&self) -> &dyn Any { + fn as_any(&self) -> &dyn Any { self } #[inline] - fn any_mut(&mut self) -> &mut dyn Any { + fn as_mut_any(&mut self) -> &mut dyn Any { self } @@ -473,15 +473,15 @@ macro_rules! impl_reflect_tuple { ::type_info() } - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } - fn any_ref(&self) -> &dyn Any { + fn as_any(&self) -> &dyn Any { self } - fn any_mut(&mut self) -> &mut dyn Any { + fn as_mut_any(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/tuple_struct.rs b/crates/bevy_reflect/src/tuple_struct.rs index a6000a0ffb59b..178cb0f1a4182 100644 --- a/crates/bevy_reflect/src/tuple_struct.rs +++ b/crates/bevy_reflect/src/tuple_struct.rs @@ -263,17 +263,17 @@ impl Reflect for DynamicTupleStruct { } #[inline] - fn any(self: Box) -> Box { + fn into_any(self: Box) -> Box { self } #[inline] - fn any_ref(&self) -> &dyn Any { + fn as_any(&self) -> &dyn Any { self } #[inline] - fn any_mut(&mut self) -> &mut dyn Any { + fn as_mut_any(&mut self) -> &mut dyn Any { self } From 48803b3b6fa8e7e815c5857b3de8bc5c978734df Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Mon, 20 Jun 2022 20:22:05 -0400 Subject: [PATCH 13/22] fixing ambiguities --- .../bevy_reflect_derive/src/container_attributes.rs | 2 +- .../bevy_reflect_derive/src/from_reflect.rs | 2 +- crates/bevy_reflect/src/reflect.rs | 4 ++-- crates/bevy_reflect/src/serde/ser.rs | 2 +- crates/bevy_reflect/src/type_info.rs | 6 +++--- crates/bevy_reflect/src/utility.rs | 12 ++++++------ examples/reflection/trait_reflection.rs | 2 +- 7 files changed, 15 insertions(+), 15 deletions(-) diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs b/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs index 298edc0131a5b..15f9f07759018 100644 --- a/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs +++ b/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs @@ -208,7 +208,7 @@ impl ReflectTraits { match &self.partial_eq { TraitImpl::Implemented => Some(quote! { fn reflect_partial_eq(&self, value: &dyn #bevy_reflect_path::Reflect) -> Option { - let value = value.any_ref(); + let value = value.as_any(); if let Some(value) = value.downcast_ref::() { Some(std::cmp::PartialEq::eq(self, value)) } else { diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs index a473d2311d21b..b4c9c345f26eb 100644 --- a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs +++ b/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 { - Some(reflect.any_ref().downcast_ref::<#type_name #ty_generics>()?.clone()) + Some(reflect.as_any().downcast_ref::<#type_name #ty_generics>()?.clone()) } } }) diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs index 62282be5e6de0..6b864b0be921e 100644 --- a/crates/bevy_reflect/src/reflect.rs +++ b/crates/bevy_reflect/src/reflect.rs @@ -54,7 +54,7 @@ pub trait Reflect: Any + Send + Sync { fn type_name(&self) -> &str; /// Returns the [`TypeId`] of the underlying type. - fn type_id(&self) -> TypeId { + fn underlying_type_id(&self) -> TypeId { TypeId::of::() } @@ -237,7 +237,7 @@ impl dyn Reflect { /// otherwise. #[inline] pub fn is(&self) -> bool { - Reflect::type_id(self) == TypeId::of::() + Reflect::underlying_type_id(self) == TypeId::of::() } /// Downcasts the value to type `T` by reference. diff --git a/crates/bevy_reflect/src/serde/ser.rs b/crates/bevy_reflect/src/serde/ser.rs index de0ad7760a6fa..73b1e33ef8866 100644 --- a/crates/bevy_reflect/src/serde/ser.rs +++ b/crates/bevy_reflect/src/serde/ser.rs @@ -27,7 +27,7 @@ fn get_serializable<'a, E: serde::ser::Error>( type_registry: &TypeRegistry, ) -> Result, E> { let reflect_serialize = type_registry - .get_type_data::(reflect_value.type_id()) + .get_type_data::(reflect_value.underlying_type_id()) .ok_or_else(|| { serde::ser::Error::custom(format_args!( "Type '{}' did not register ReflectSerialize", diff --git a/crates/bevy_reflect/src/type_info.rs b/crates/bevy_reflect/src/type_info.rs index fe80e307d859f..e983b65f0793b 100644 --- a/crates/bevy_reflect/src/type_info.rs +++ b/crates/bevy_reflect/src/type_info.rs @@ -48,9 +48,9 @@ use std::any::{Any, TypeId}; /// # impl Reflect for MyStruct { /// # fn type_name(&self) -> &str { todo!() } /// # fn get_type_info(&self) -> &'static TypeInfo { todo!() } -/// # fn any(self: Box) -> Box { todo!() } -/// # fn any_ref(&self) -> &dyn Any { todo!() } -/// # fn any_mut(&mut self) -> &mut dyn Any { todo!() } +/// # fn into_any(self: Box) -> Box { todo!() } +/// # fn as_any(&self) -> &dyn Any { todo!() } +/// # fn as_mut_any(&mut self) -> &mut dyn Any { todo!() } /// # fn as_reflect(&self) -> &dyn Reflect { todo!() } /// # fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() } /// # fn apply(&mut self, value: &dyn Reflect) { todo!() } diff --git a/crates/bevy_reflect/src/utility.rs b/crates/bevy_reflect/src/utility.rs index e1190ab5fc5b5..662e6649f0bde 100644 --- a/crates/bevy_reflect/src/utility.rs +++ b/crates/bevy_reflect/src/utility.rs @@ -37,9 +37,9 @@ use std::any::{Any, TypeId}; /// # impl Reflect for Foo { /// # fn type_name(&self) -> &str { todo!() } /// # fn get_type_info(&self) -> &'static TypeInfo { todo!() } -/// # fn any(self: Box) -> Box { todo!() } -/// # fn any_ref(&self) -> &dyn Any { todo!() } -/// # fn any_mut(&mut self) -> &mut dyn Any { todo!() } +/// # fn into_any(self: Box) -> Box { todo!() } +/// # fn as_any(&self) -> &dyn Any { todo!() } +/// # fn as_mut_any(&mut self) -> &mut dyn Any { todo!() } /// # fn as_reflect(&self) -> &dyn Reflect { todo!() } /// # fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() } /// # fn apply(&mut self, value: &dyn Reflect) { todo!() } @@ -98,9 +98,9 @@ impl NonGenericTypeInfoCell { /// # impl Reflect for Foo { /// # fn type_name(&self) -> &str { todo!() } /// # fn get_type_info(&self) -> &'static TypeInfo { todo!() } -/// # fn any(self: Box) -> Box { todo!() } -/// # fn any_ref(&self) -> &dyn Any { todo!() } -/// # fn any_mut(&mut self) -> &mut dyn Any { todo!() } +/// # fn into_any(self: Box) -> Box { todo!() } +/// # fn as_any(&self) -> &dyn Any { todo!() } +/// # fn as_mut_any(&mut self) -> &mut dyn Any { todo!() } /// # fn as_reflect(&self) -> &dyn Reflect { todo!() } /// # fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() } /// # fn apply(&mut self, value: &dyn Reflect) { todo!() } diff --git a/examples/reflection/trait_reflection.rs b/examples/reflection/trait_reflection.rs index ebc1918123e77..37b0a2f85688f 100644 --- a/examples/reflection/trait_reflection.rs +++ b/examples/reflection/trait_reflection.rs @@ -45,7 +45,7 @@ fn setup(type_registry: Res) { // The #[reflect] attribute we put on our DoThing trait generated a new `ReflectDoThing` struct, // which implements TypeData. This was added to MyType's TypeRegistration. let reflect_do_thing = type_registry - .get_type_data::(Reflect::type_id(&*reflect_value)) + .get_type_data::(Reflect::underlying_type_id(&*reflect_value)) .unwrap(); // We can use this generated type to convert our `&dyn Reflect` reference to a `&dyn DoThing` From e79a8c371f4c31c5888d03d45ebf81245a405616 Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Tue, 21 Jun 2022 08:14:51 -0400 Subject: [PATCH 14/22] Remove unnecessary TypeId imports --- crates/bevy_reflect/src/type_info.rs | 2 +- crates/bevy_reflect/src/utility.rs | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/crates/bevy_reflect/src/type_info.rs b/crates/bevy_reflect/src/type_info.rs index e983b65f0793b..cfc62f91a734a 100644 --- a/crates/bevy_reflect/src/type_info.rs +++ b/crates/bevy_reflect/src/type_info.rs @@ -20,7 +20,7 @@ use std::any::{Any, TypeId}; /// # Example /// /// ``` -/// # use std::any::{Any, TypeId}; +/// # use std::any::Any; /// # use bevy_reflect::{NamedField, Reflect, ReflectMut, ReflectRef, StructInfo, TypeInfo, ValueInfo}; /// # use bevy_reflect::utility::NonGenericTypeInfoCell; /// use bevy_reflect::Typed; diff --git a/crates/bevy_reflect/src/utility.rs b/crates/bevy_reflect/src/utility.rs index 662e6649f0bde..98154b053269a 100644 --- a/crates/bevy_reflect/src/utility.rs +++ b/crates/bevy_reflect/src/utility.rs @@ -15,7 +15,7 @@ use std::any::{Any, TypeId}; /// ## Example /// /// ``` -/// # use std::any::{Any, TypeId}; +/// # use std::any::Any; /// # use bevy_reflect::{NamedField, Reflect, ReflectMut, ReflectRef, StructInfo, Typed, TypeInfo}; /// use bevy_reflect::utility::NonGenericTypeInfoCell; /// @@ -78,7 +78,7 @@ impl NonGenericTypeInfoCell { /// ## Example /// /// ``` -/// # use std::any::{Any, TypeId}; +/// # use std::any::Any; /// # use bevy_reflect::{Reflect, ReflectMut, ReflectRef, TupleStructInfo, Typed, TypeInfo, UnnamedField}; /// use bevy_reflect::utility::GenericTypeInfoCell; /// From bde44f246ffe9a9fc3b39cf6005885f7b51eb23a Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Sun, 26 Jun 2022 13:42:34 -0400 Subject: [PATCH 15/22] Add `represents` method to `dyn Reflect` --- crates/bevy_reflect/src/reflect.rs | 24 +++++++++++++++++------- 1 file changed, 17 insertions(+), 7 deletions(-) diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs index 6b864b0be921e..b0b39c6aeb5f6 100644 --- a/crates/bevy_reflect/src/reflect.rs +++ b/crates/bevy_reflect/src/reflect.rs @@ -3,7 +3,7 @@ use crate::{ tuple_struct_debug, Array, List, Map, Struct, Tuple, TupleStruct, TypeInfo, Typed, ValueInfo, }; use std::{ - any::{Any, TypeId}, + any::{self, Any, TypeId}, fmt::Debug, }; @@ -53,11 +53,6 @@ pub trait Reflect: Any + Send + Sync { /// Returns the [type name][std::any::type_name] of the underlying type. fn type_name(&self) -> &str; - /// Returns the [`TypeId`] of the underlying type. - fn underlying_type_id(&self) -> TypeId { - TypeId::of::() - } - /// Returns the [`TypeInfo`] of the underlying type. /// /// This method is great if you have an instance of a type or a `dyn Reflect`, @@ -233,11 +228,26 @@ impl dyn Reflect { self.downcast::().map(|value| *value) } + /// Returns `true` if the underlying value represents a value of type `T`, or `false` + /// otherwise. + /// + /// Read `is` for more information on underlying values and represented types. + #[inline] + pub fn represents(&self) -> bool { + self.type_name() == any::type_name::() + } + /// Returns `true` if the underlying value is of type `T`, or `false` /// otherwise. + /// + /// The underlying value is the concrete type that is stored in this `dyn` object; + /// it can be downcasted to. In the case that this underlying value "represents" + /// a different type, like the Dynamic\*\*\* types do, you can call `represents` + /// to determine what type they represent. Represented types cannot be downcasted + /// to, but you can use `FromReflect` to create a value of the represented type from them. #[inline] pub fn is(&self) -> bool { - Reflect::underlying_type_id(self) == TypeId::of::() + self.type_id() == TypeId::of::() } /// Downcasts the value to type `T` by reference. From ced94c7dba841bf02ce5865009896b8f7876173a Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Sun, 26 Jun 2022 13:43:22 -0400 Subject: [PATCH 16/22] underlying_type_id -> type_id --- crates/bevy_reflect/src/serde/ser.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/bevy_reflect/src/serde/ser.rs b/crates/bevy_reflect/src/serde/ser.rs index 73b1e33ef8866..de0ad7760a6fa 100644 --- a/crates/bevy_reflect/src/serde/ser.rs +++ b/crates/bevy_reflect/src/serde/ser.rs @@ -27,7 +27,7 @@ fn get_serializable<'a, E: serde::ser::Error>( type_registry: &TypeRegistry, ) -> Result, E> { let reflect_serialize = type_registry - .get_type_data::(reflect_value.underlying_type_id()) + .get_type_data::(reflect_value.type_id()) .ok_or_else(|| { serde::ser::Error::custom(format_args!( "Type '{}' did not register ReflectSerialize", From cec23c062809ff5ee245e662d923c83fd3cfaabe Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Sun, 26 Jun 2022 13:46:39 -0400 Subject: [PATCH 17/22] Fix slightly broken test --- crates/bevy_reflect/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs index 8c2927d8f359d..cd949ec4c63d2 100644 --- a/crates/bevy_reflect/src/lib.rs +++ b/crates/bevy_reflect/src/lib.rs @@ -922,7 +922,7 @@ bevy_reflect::tests::should_reflect_debug::Test { assert_eq!( result, - r#"{"type":"glam::vec3::Vec3","struct":{"x":{"type":"f32","value":12.0},"y":{"type":"f32","value":3.0},"z":{"type":"f32","value":-6.9}}}"# + r#"{"type":"glam::vec3::Vec3","struct":{"x":{"type":"f32","value":12},"y":{"type":"f32","value":3},"z":{"type":"f32","value":-6.9}}}"# ); } From 2ae01fb54abf86f9a87fa17d562f8120ee8be84f Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Sun, 26 Jun 2022 13:52:37 -0400 Subject: [PATCH 18/22] Un-fixing broken test --- crates/bevy_reflect/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs index cd949ec4c63d2..8c2927d8f359d 100644 --- a/crates/bevy_reflect/src/lib.rs +++ b/crates/bevy_reflect/src/lib.rs @@ -922,7 +922,7 @@ bevy_reflect::tests::should_reflect_debug::Test { assert_eq!( result, - r#"{"type":"glam::vec3::Vec3","struct":{"x":{"type":"f32","value":12},"y":{"type":"f32","value":3},"z":{"type":"f32","value":-6.9}}}"# + r#"{"type":"glam::vec3::Vec3","struct":{"x":{"type":"f32","value":12.0},"y":{"type":"f32","value":3.0},"z":{"type":"f32","value":-6.9}}}"# ); } From 481823f604fb0cc0c68a8beacbe66f4cf86a1bbd Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Sun, 26 Jun 2022 14:01:02 -0400 Subject: [PATCH 19/22] underlying_type_id -> type_id --- examples/reflection/trait_reflection.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/reflection/trait_reflection.rs b/examples/reflection/trait_reflection.rs index 37b0a2f85688f..0c4c4eaf4004c 100644 --- a/examples/reflection/trait_reflection.rs +++ b/examples/reflection/trait_reflection.rs @@ -45,7 +45,7 @@ fn setup(type_registry: Res) { // The #[reflect] attribute we put on our DoThing trait generated a new `ReflectDoThing` struct, // which implements TypeData. This was added to MyType's TypeRegistration. let reflect_do_thing = type_registry - .get_type_data::(Reflect::underlying_type_id(&*reflect_value)) + .get_type_data::(reflect_value.type_id()) .unwrap(); // We can use this generated type to convert our `&dyn Reflect` reference to a `&dyn DoThing` From 29a9379e463b5d7ba95b90524f82d07809b22cc2 Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Sun, 26 Jun 2022 21:34:33 -0400 Subject: [PATCH 20/22] Doc links --- crates/bevy_reflect/src/reflect.rs | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs index b0b39c6aeb5f6..8b84e2caf1131 100644 --- a/crates/bevy_reflect/src/reflect.rs +++ b/crates/bevy_reflect/src/reflect.rs @@ -231,7 +231,9 @@ impl dyn Reflect { /// Returns `true` if the underlying value represents a value of type `T`, or `false` /// otherwise. /// - /// Read `is` for more information on underlying values and represented types. + /// Read [`is`] for more information on underlying values and represented types. + /// + /// [`is`]: Self::is #[inline] pub fn represents(&self) -> bool { self.type_name() == any::type_name::() @@ -242,9 +244,11 @@ impl dyn Reflect { /// /// The underlying value is the concrete type that is stored in this `dyn` object; /// it can be downcasted to. In the case that this underlying value "represents" - /// a different type, like the Dynamic\*\*\* types do, you can call `represents` + /// a different type, like the Dynamic\*\*\* types do, you can call [`represents`] /// to determine what type they represent. Represented types cannot be downcasted - /// to, but you can use `FromReflect` to create a value of the represented type from them. + /// to, but you can use [`FromReflect`] to create a value of the represented type from them. + /// + /// [`represents`]: Self::represents #[inline] pub fn is(&self) -> bool { self.type_id() == TypeId::of::() From 7b66ee8ce930ba611c55cce9ef2fad661db4c86a Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Sun, 26 Jun 2022 21:35:33 -0400 Subject: [PATCH 21/22] as_mut_any -> as_any_mut --- crates/bevy_reflect/bevy_reflect_derive/src/impls.rs | 6 +++--- crates/bevy_reflect/src/array.rs | 2 +- crates/bevy_reflect/src/impls/smallvec.rs | 2 +- crates/bevy_reflect/src/impls/std.rs | 8 ++++---- crates/bevy_reflect/src/list.rs | 2 +- crates/bevy_reflect/src/map.rs | 2 +- crates/bevy_reflect/src/reflect.rs | 4 ++-- crates/bevy_reflect/src/struct_trait.rs | 2 +- crates/bevy_reflect/src/tuple.rs | 4 ++-- crates/bevy_reflect/src/tuple_struct.rs | 2 +- crates/bevy_reflect/src/type_info.rs | 2 +- crates/bevy_reflect/src/utility.rs | 4 ++-- 12 files changed, 20 insertions(+), 20 deletions(-) diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs b/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs index 6bd950c5c63ad..38680a35adf38 100644 --- a/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs +++ b/crates/bevy_reflect/bevy_reflect_derive/src/impls.rs @@ -147,7 +147,7 @@ pub(crate) fn impl_struct(derive_data: &ReflectDeriveData) -> TokenStream { } #[inline] - fn as_mut_any(&mut self) -> &mut dyn std::any::Any { + fn as_any_mut(&mut self) -> &mut dyn std::any::Any { self } @@ -302,7 +302,7 @@ pub(crate) fn impl_tuple_struct(derive_data: &ReflectDeriveData) -> TokenStream } #[inline] - fn as_mut_any(&mut self) -> &mut dyn std::any::Any { + fn as_any_mut(&mut self) -> &mut dyn std::any::Any { self } @@ -404,7 +404,7 @@ pub(crate) fn impl_value( } #[inline] - fn as_mut_any(&mut self) -> &mut dyn std::any::Any { + fn as_any_mut(&mut self) -> &mut dyn std::any::Any { self } diff --git a/crates/bevy_reflect/src/array.rs b/crates/bevy_reflect/src/array.rs index aef00050ebe36..486966813dd65 100644 --- a/crates/bevy_reflect/src/array.rs +++ b/crates/bevy_reflect/src/array.rs @@ -173,7 +173,7 @@ impl Reflect for DynamicArray { } #[inline] - fn as_mut_any(&mut self) -> &mut dyn Any { + fn as_any_mut(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/impls/smallvec.rs b/crates/bevy_reflect/src/impls/smallvec.rs index c3a7023ccb3db..61d507986b15a 100644 --- a/crates/bevy_reflect/src/impls/smallvec.rs +++ b/crates/bevy_reflect/src/impls/smallvec.rs @@ -75,7 +75,7 @@ where self } - fn as_mut_any(&mut self) -> &mut dyn Any { + fn as_any_mut(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs index f8500cc7ca213..6e94741f638b9 100644 --- a/crates/bevy_reflect/src/impls/std.rs +++ b/crates/bevy_reflect/src/impls/std.rs @@ -122,7 +122,7 @@ impl Reflect for Vec { self } - fn as_mut_any(&mut self) -> &mut dyn Any { + fn as_any_mut(&mut self) -> &mut dyn Any { self } @@ -250,7 +250,7 @@ impl Reflect for HashMap { self } - fn as_mut_any(&mut self) -> &mut dyn Any { + fn as_any_mut(&mut self) -> &mut dyn Any { self } @@ -377,7 +377,7 @@ impl Reflect for [T; N] { } #[inline] - fn as_mut_any(&mut self) -> &mut dyn Any { + fn as_any_mut(&mut self) -> &mut dyn Any { self } @@ -492,7 +492,7 @@ impl Reflect for Cow<'static, str> { self } - fn as_mut_any(&mut self) -> &mut dyn Any { + fn as_any_mut(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/list.rs b/crates/bevy_reflect/src/list.rs index 4eeb5b6e2cef9..25d2f179b4b79 100644 --- a/crates/bevy_reflect/src/list.rs +++ b/crates/bevy_reflect/src/list.rs @@ -185,7 +185,7 @@ impl Reflect for DynamicList { } #[inline] - fn as_mut_any(&mut self) -> &mut dyn Any { + fn as_any_mut(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/map.rs b/crates/bevy_reflect/src/map.rs index 2b65a1f31ecd5..89f499731f50b 100644 --- a/crates/bevy_reflect/src/map.rs +++ b/crates/bevy_reflect/src/map.rs @@ -230,7 +230,7 @@ impl Reflect for DynamicMap { self } - fn as_mut_any(&mut self) -> &mut dyn Any { + fn as_any_mut(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs index 8b84e2caf1131..3fe3ef8f8989a 100644 --- a/crates/bevy_reflect/src/reflect.rs +++ b/crates/bevy_reflect/src/reflect.rs @@ -70,7 +70,7 @@ pub trait Reflect: Any + Send + Sync { fn as_any(&self) -> &dyn Any; /// Returns the value as a [`&mut dyn Any`][std::any::Any]. - fn as_mut_any(&mut self) -> &mut dyn Any; + fn as_any_mut(&mut self) -> &mut dyn Any; /// Casts this type to a reflected value fn as_reflect(&self) -> &dyn Reflect; @@ -267,6 +267,6 @@ impl dyn Reflect { /// If the underlying value is not of type `T`, returns `None`. #[inline] pub fn downcast_mut(&mut self) -> Option<&mut T> { - self.as_mut_any().downcast_mut::() + self.as_any_mut().downcast_mut::() } } diff --git a/crates/bevy_reflect/src/struct_trait.rs b/crates/bevy_reflect/src/struct_trait.rs index fdb72de7735dd..6f5075d990081 100644 --- a/crates/bevy_reflect/src/struct_trait.rs +++ b/crates/bevy_reflect/src/struct_trait.rs @@ -359,7 +359,7 @@ impl Reflect for DynamicStruct { } #[inline] - fn as_mut_any(&mut self) -> &mut dyn Any { + fn as_any_mut(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/tuple.rs b/crates/bevy_reflect/src/tuple.rs index 8b8920a962dfb..c01f798c8920e 100644 --- a/crates/bevy_reflect/src/tuple.rs +++ b/crates/bevy_reflect/src/tuple.rs @@ -289,7 +289,7 @@ impl Reflect for DynamicTuple { } #[inline] - fn as_mut_any(&mut self) -> &mut dyn Any { + fn as_any_mut(&mut self) -> &mut dyn Any { self } @@ -481,7 +481,7 @@ macro_rules! impl_reflect_tuple { self } - fn as_mut_any(&mut self) -> &mut dyn Any { + fn as_any_mut(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/tuple_struct.rs b/crates/bevy_reflect/src/tuple_struct.rs index 178cb0f1a4182..27ded3e919984 100644 --- a/crates/bevy_reflect/src/tuple_struct.rs +++ b/crates/bevy_reflect/src/tuple_struct.rs @@ -273,7 +273,7 @@ impl Reflect for DynamicTupleStruct { } #[inline] - fn as_mut_any(&mut self) -> &mut dyn Any { + fn as_any_mut(&mut self) -> &mut dyn Any { self } diff --git a/crates/bevy_reflect/src/type_info.rs b/crates/bevy_reflect/src/type_info.rs index cfc62f91a734a..942ba84fdf6e3 100644 --- a/crates/bevy_reflect/src/type_info.rs +++ b/crates/bevy_reflect/src/type_info.rs @@ -50,7 +50,7 @@ use std::any::{Any, TypeId}; /// # fn get_type_info(&self) -> &'static TypeInfo { todo!() } /// # fn into_any(self: Box) -> Box { todo!() } /// # fn as_any(&self) -> &dyn Any { todo!() } -/// # fn as_mut_any(&mut self) -> &mut dyn Any { todo!() } +/// # fn as_any_mut(&mut self) -> &mut dyn Any { todo!() } /// # fn as_reflect(&self) -> &dyn Reflect { todo!() } /// # fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() } /// # fn apply(&mut self, value: &dyn Reflect) { todo!() } diff --git a/crates/bevy_reflect/src/utility.rs b/crates/bevy_reflect/src/utility.rs index 98154b053269a..3e38c6dc35932 100644 --- a/crates/bevy_reflect/src/utility.rs +++ b/crates/bevy_reflect/src/utility.rs @@ -39,7 +39,7 @@ use std::any::{Any, TypeId}; /// # fn get_type_info(&self) -> &'static TypeInfo { todo!() } /// # fn into_any(self: Box) -> Box { todo!() } /// # fn as_any(&self) -> &dyn Any { todo!() } -/// # fn as_mut_any(&mut self) -> &mut dyn Any { todo!() } +/// # fn as_any_mut(&mut self) -> &mut dyn Any { todo!() } /// # fn as_reflect(&self) -> &dyn Reflect { todo!() } /// # fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() } /// # fn apply(&mut self, value: &dyn Reflect) { todo!() } @@ -100,7 +100,7 @@ impl NonGenericTypeInfoCell { /// # fn get_type_info(&self) -> &'static TypeInfo { todo!() } /// # fn into_any(self: Box) -> Box { todo!() } /// # fn as_any(&self) -> &dyn Any { todo!() } -/// # fn as_mut_any(&mut self) -> &mut dyn Any { todo!() } +/// # fn as_any_mut(&mut self) -> &mut dyn Any { todo!() } /// # fn as_reflect(&self) -> &dyn Reflect { todo!() } /// # fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() } /// # fn apply(&mut self, value: &dyn Reflect) { todo!() } From 2f557c127bed345a8182ae73587c1093d3e889eb Mon Sep 17 00:00:00 2001 From: PROMETHIA Date: Mon, 27 Jun 2022 08:54:39 -0400 Subject: [PATCH 22/22] Removed invalid doc links --- crates/bevy_reflect/src/reflect.rs | 9 +++------ 1 file changed, 3 insertions(+), 6 deletions(-) diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs index 3fe3ef8f8989a..1e4d31449b2c8 100644 --- a/crates/bevy_reflect/src/reflect.rs +++ b/crates/bevy_reflect/src/reflect.rs @@ -209,6 +209,7 @@ impl Typed for dyn Reflect { } } +#[deny(rustdoc::broken_intra_doc_links)] impl dyn Reflect { /// Downcasts the value to type `T`, consuming the trait object. /// @@ -231,9 +232,7 @@ impl dyn Reflect { /// Returns `true` if the underlying value represents a value of type `T`, or `false` /// otherwise. /// - /// Read [`is`] for more information on underlying values and represented types. - /// - /// [`is`]: Self::is + /// Read `is` for more information on underlying values and represented types. #[inline] pub fn represents(&self) -> bool { self.type_name() == any::type_name::() @@ -244,11 +243,9 @@ impl dyn Reflect { /// /// The underlying value is the concrete type that is stored in this `dyn` object; /// it can be downcasted to. In the case that this underlying value "represents" - /// a different type, like the Dynamic\*\*\* types do, you can call [`represents`] + /// a different type, like the Dynamic\*\*\* types do, you can call `represents` /// to determine what type they represent. Represented types cannot be downcasted /// to, but you can use [`FromReflect`] to create a value of the represented type from them. - /// - /// [`represents`]: Self::represents #[inline] pub fn is(&self) -> bool { self.type_id() == TypeId::of::()