From ad3a1bdeebaebfe3a4f1196cada7ce7e1ead1164 Mon Sep 17 00:00:00 2001 From: MrGVSV Date: Mon, 25 Apr 2022 13:54:48 +0000 Subject: [PATCH] bevy_reflect: Add `as_reflect` and `as_reflect_mut` (#4350) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit # Objective Trait objects that have `Reflect` as a supertrait cannot be upcast to a `dyn Reflect`. Attempting something like: ```rust trait MyTrait: Reflect { // ... } fn foo(value: &dyn MyTrait) { let reflected = value as &dyn Reflect; // Error! // ... } ``` Results in `error[E0658]: trait upcasting coercion is experimental`. The reason this is important is that a lot of `bevy_reflect` methods require a `&dyn Reflect`. This is trivial with concrete types, but if we don't know the concrete type (we only have the trait object), we can't use these methods. For example, we couldn't create a `ReflectSerializer` for the type since it expects a `&dyn Reflect` value— even though we should be able to. ## Solution Add `as_reflect` and `as_reflect_mut` to `Reflect` to allow upcasting to a `dyn Reflect`: ```rust trait MyTrait: Reflect { // ... } fn foo(value: &dyn MyTrait) { let reflected = value.as_reflect(); // ... } ``` ## Alternatives We could defer this type of logic to the crate/user. They can add these methods to their trait in the same exact way we do here. The main benefit of doing it ourselves is it makes things convenient for them (especially when using the derive macro). We could also create an `AsReflect` trait with a blanket impl over all reflected types, however, I could not get that to work for trait objects since they aren't sized. --- ## Changelog - Added trait method `Reflect::as_reflect(&self)` - Added trait method `Reflect::as_reflect_mut(&mut self)` ## Migration Guide - Manual implementors of `Reflect` will need to add implementations for the methods above (this should be pretty easy as most cases just need to return `self`) --- .../bevy_reflect_derive/src/lib.rs | 32 +++++++++++++++++++ crates/bevy_reflect/src/impls/smallvec.rs | 8 +++++ crates/bevy_reflect/src/impls/std.rs | 24 ++++++++++++++ crates/bevy_reflect/src/lib.rs | 15 +++++++++ crates/bevy_reflect/src/list.rs | 10 ++++++ crates/bevy_reflect/src/map.rs | 10 ++++++ crates/bevy_reflect/src/reflect.rs | 6 ++++ crates/bevy_reflect/src/struct_trait.rs | 10 ++++++ crates/bevy_reflect/src/tuple.rs | 18 +++++++++++ crates/bevy_reflect/src/tuple_struct.rs | 10 ++++++ 10 files changed, 143 insertions(+) diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs index 8128b292b8559..29cc406099345 100644 --- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs +++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs @@ -274,6 +274,17 @@ fn impl_struct( fn any_mut(&mut self) -> &mut dyn std::any::Any { self } + + #[inline] + fn as_reflect(&self) -> &dyn #bevy_reflect_path::Reflect { + self + } + + #[inline] + fn as_reflect_mut(&mut self) -> &mut dyn #bevy_reflect_path::Reflect { + self + } + #[inline] fn clone_value(&self) -> Box { use #bevy_reflect_path::Struct; @@ -396,6 +407,17 @@ fn impl_tuple_struct( fn any_mut(&mut self) -> &mut dyn std::any::Any { self } + + #[inline] + fn as_reflect(&self) -> &dyn #bevy_reflect_path::Reflect { + self + } + + #[inline] + fn as_reflect_mut(&mut self) -> &mut dyn #bevy_reflect_path::Reflect { + self + } + #[inline] fn clone_value(&self) -> Box { use #bevy_reflect_path::TupleStruct; @@ -474,6 +496,16 @@ fn impl_value( self } + #[inline] + fn as_reflect(&self) -> &dyn #bevy_reflect_path::Reflect { + self + } + + #[inline] + fn as_reflect_mut(&mut self) -> &mut dyn #bevy_reflect_path::Reflect { + self + } + #[inline] fn clone_value(&self) -> Box { Box::new(self.clone()) diff --git a/crates/bevy_reflect/src/impls/smallvec.rs b/crates/bevy_reflect/src/impls/smallvec.rs index 4d6417c6df068..a38fb67459068 100644 --- a/crates/bevy_reflect/src/impls/smallvec.rs +++ b/crates/bevy_reflect/src/impls/smallvec.rs @@ -64,6 +64,14 @@ where self } + fn as_reflect(&self) -> &dyn Reflect { + self + } + + fn as_reflect_mut(&mut self) -> &mut dyn Reflect { + self + } + fn apply(&mut self, value: &dyn Reflect) { crate::list_apply(self, value); } diff --git a/crates/bevy_reflect/src/impls/std.rs b/crates/bevy_reflect/src/impls/std.rs index 0b1d4097e1e11..4a60096b7fcd2 100644 --- a/crates/bevy_reflect/src/impls/std.rs +++ b/crates/bevy_reflect/src/impls/std.rs @@ -110,6 +110,14 @@ unsafe impl Reflect for Vec { self } + fn as_reflect(&self) -> &dyn Reflect { + self + } + + fn as_reflect_mut(&mut self) -> &mut dyn Reflect { + self + } + fn apply(&mut self, value: &dyn Reflect) { crate::list_apply(self, value); } @@ -220,6 +228,14 @@ unsafe impl Reflect for HashMap { self } + fn as_reflect(&self) -> &dyn Reflect { + self + } + + fn as_reflect_mut(&mut self) -> &mut dyn Reflect { + self + } + fn apply(&mut self, value: &dyn Reflect) { if let ReflectRef::Map(map_value) = value.reflect_ref() { for (key, value) in map_value.iter() { @@ -304,6 +320,14 @@ unsafe impl Reflect for Cow<'static, str> { self } + fn as_reflect(&self) -> &dyn Reflect { + self + } + + fn as_reflect_mut(&mut self) -> &mut dyn Reflect { + self + } + fn apply(&mut self, value: &dyn Reflect) { let value = value.any(); if let Some(value) = value.downcast_ref::() { diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs index cd479d1e07dec..e935c042a53e1 100644 --- a/crates/bevy_reflect/src/lib.rs +++ b/crates/bevy_reflect/src/lib.rs @@ -423,4 +423,19 @@ mod tests { std::any::type_name::() ); } + + #[test] + fn as_reflect() { + trait TestTrait: Reflect {} + + #[derive(Reflect)] + struct TestStruct; + + impl TestTrait for TestStruct {} + + let trait_object: Box = Box::new(TestStruct); + + // Should compile: + let _ = trait_object.as_reflect(); + } } diff --git a/crates/bevy_reflect/src/list.rs b/crates/bevy_reflect/src/list.rs index d9572cd1b42db..ce434c8c3701f 100644 --- a/crates/bevy_reflect/src/list.rs +++ b/crates/bevy_reflect/src/list.rs @@ -121,6 +121,16 @@ unsafe impl Reflect for DynamicList { self } + #[inline] + fn as_reflect(&self) -> &dyn Reflect { + self + } + + #[inline] + fn as_reflect_mut(&mut self) -> &mut dyn Reflect { + self + } + fn apply(&mut self, value: &dyn Reflect) { list_apply(self, value); } diff --git a/crates/bevy_reflect/src/map.rs b/crates/bevy_reflect/src/map.rs index 4fdba328c6714..02d1ae37a242f 100644 --- a/crates/bevy_reflect/src/map.rs +++ b/crates/bevy_reflect/src/map.rs @@ -147,6 +147,16 @@ unsafe impl Reflect for DynamicMap { self } + #[inline] + fn as_reflect(&self) -> &dyn Reflect { + self + } + + #[inline] + fn as_reflect_mut(&mut self) -> &mut dyn Reflect { + self + } + fn apply(&mut self, value: &dyn Reflect) { if let ReflectRef::Map(map_value) = value.reflect_ref() { for (key, value) in map_value.iter() { diff --git a/crates/bevy_reflect/src/reflect.rs b/crates/bevy_reflect/src/reflect.rs index 4362068df918e..0168a0d797c9f 100644 --- a/crates/bevy_reflect/src/reflect.rs +++ b/crates/bevy_reflect/src/reflect.rs @@ -57,6 +57,12 @@ pub unsafe trait Reflect: Any + Send + Sync { /// Returns the value as a [`&mut dyn Any`][std::any::Any]. fn any_mut(&mut self) -> &mut dyn Any; + /// Casts this type to a reflected value + fn as_reflect(&self) -> &dyn Reflect; + + /// Casts this type to a mutable reflected value + fn as_reflect_mut(&mut self) -> &mut dyn Reflect; + /// Applies a reflected value to this value. /// /// If a type implements a subtrait of `Reflect`, then the semantics of this diff --git a/crates/bevy_reflect/src/struct_trait.rs b/crates/bevy_reflect/src/struct_trait.rs index f8a413e6f6030..f1941ce1bbac2 100644 --- a/crates/bevy_reflect/src/struct_trait.rs +++ b/crates/bevy_reflect/src/struct_trait.rs @@ -269,6 +269,16 @@ unsafe impl Reflect for DynamicStruct { self } + #[inline] + fn as_reflect(&self) -> &dyn Reflect { + self + } + + #[inline] + fn as_reflect_mut(&mut self) -> &mut dyn Reflect { + self + } + #[inline] fn clone_value(&self) -> Box { Box::new(self.clone_dynamic()) diff --git a/crates/bevy_reflect/src/tuple.rs b/crates/bevy_reflect/src/tuple.rs index 1ebec67fdb032..05d8322f54784 100644 --- a/crates/bevy_reflect/src/tuple.rs +++ b/crates/bevy_reflect/src/tuple.rs @@ -222,6 +222,16 @@ unsafe impl Reflect for DynamicTuple { self } + #[inline] + fn as_reflect(&self) -> &dyn Reflect { + self + } + + #[inline] + fn as_reflect_mut(&mut self) -> &mut dyn Reflect { + self + } + #[inline] fn clone_value(&self) -> Box { Box::new(self.clone_dynamic()) @@ -366,6 +376,14 @@ macro_rules! impl_reflect_tuple { self } + fn as_reflect(&self) -> &dyn Reflect { + self + } + + fn as_reflect_mut(&mut self) -> &mut dyn Reflect { + self + } + fn apply(&mut self, value: &dyn Reflect) { crate::tuple_apply(self, value); } diff --git a/crates/bevy_reflect/src/tuple_struct.rs b/crates/bevy_reflect/src/tuple_struct.rs index 00e478f5f38e8..09f484ca15644 100644 --- a/crates/bevy_reflect/src/tuple_struct.rs +++ b/crates/bevy_reflect/src/tuple_struct.rs @@ -209,6 +209,16 @@ unsafe impl Reflect for DynamicTupleStruct { self } + #[inline] + fn as_reflect(&self) -> &dyn Reflect { + self + } + + #[inline] + fn as_reflect_mut(&mut self) -> &mut dyn Reflect { + self + } + #[inline] fn clone_value(&self) -> Box { Box::new(self.clone_dynamic())