Automatically derive FromReflect with Reflect

Author: MrGVSV

crates/bevy_animation/src/lib.rs

@@ -12,7 +12,7 @@ use bevy_core::Name;
 use bevy_ecs::prelude::*;
 use bevy_hierarchy::{Children, Parent};
 use bevy_math::{Quat, Vec3};
-use bevy_reflect::{FromReflect, Reflect, TypeUuid};
+use bevy_reflect::{Reflect, TypeUuid};
 use bevy_time::Time;
 use bevy_transform::{prelude::Transform, TransformSystem};
 use bevy_utils::{tracing::warn, HashMap};
@@ -26,7 +26,7 @@ pub mod prelude {
 }
 
 /// List of keyframes for one of the attribute of a [`Transform`].
-#[derive(Reflect, FromReflect, Clone, Debug)]
+#[derive(Reflect, Clone, Debug)]
 pub enum Keyframes {
     /// Keyframes for rotation.
     Rotation(Vec<Quat>),
@@ -39,7 +39,7 @@ pub enum Keyframes {
 /// Describes how an attribute of a [`Transform`] should be animated.
 ///
 /// `keyframe_timestamps` and `keyframes` should have the same length.
-#[derive(Reflect, FromReflect, Clone, Debug)]
+#[derive(Reflect, Clone, Debug)]
 pub struct VariableCurve {
     /// Timestamp for each of the keyframes.
     pub keyframe_timestamps: Vec<f32>,
@@ -48,14 +48,14 @@ pub struct VariableCurve {
 }
 
 /// Path to an entity, with [`Name`]s. Each entity in a path must have a name.
-#[derive(Reflect, FromReflect, Clone, Debug, Hash, PartialEq, Eq, Default)]
+#[derive(Reflect, Clone, Debug, Hash, PartialEq, Eq, Default)]
 pub struct EntityPath {
     /// Parts of the path
     pub parts: Vec<Name>,
 }
 
 /// A list of [`VariableCurve`], and the [`EntityPath`] to which they apply.
-#[derive(Reflect, FromReflect, Clone, TypeUuid, Debug, Default)]
+#[derive(Reflect, Clone, TypeUuid, Debug, Default)]
 #[uuid = "d81b7179-0448-4eb0-89fe-c067222725bf"]
 pub struct AnimationClip {
     curves: Vec<Vec<VariableCurve>>,

crates/bevy_asset/src/handle.rs

@@ -10,27 +10,14 @@ use crate::{
     Asset, Assets,
 };
 use bevy_ecs::{component::Component, reflect::ReflectComponent};
-use bevy_reflect::{
-    std_traits::ReflectDefault, FromReflect, Reflect, ReflectDeserialize, ReflectSerialize,
-};
+use bevy_reflect::{std_traits::ReflectDefault, Reflect, ReflectDeserialize, ReflectSerialize};
 use bevy_utils::Uuid;
 use crossbeam_channel::{Receiver, Sender};
 use serde::{Deserialize, Serialize};
 
 /// A unique, stable asset id.
 #[derive(
-    Debug,
-    Clone,
-    Copy,
-    Eq,
-    PartialEq,
-    Hash,
-    Ord,
-    PartialOrd,
-    Serialize,
-    Deserialize,
-    Reflect,
-    FromReflect,
+    Debug, Clone, Copy, Eq, PartialEq, Hash, Ord, PartialOrd, Serialize, Deserialize, Reflect,
 )]
 #[reflect_value(Serialize, Deserialize, PartialEq, Hash)]
 pub enum HandleId {
@@ -102,7 +89,7 @@ impl HandleId {
 /// handle to the unloaded asset, but it will not be able to retrieve the image data, resulting in
 /// collisions no longer being detected for that entity.
 ///
-#[derive(Component, Reflect, FromReflect)]
+#[derive(Component, Reflect)]
 #[reflect(Component, Default)]
 pub struct Handle<T>
 where

crates/bevy_asset/src/path.rs

@@ -1,6 +1,4 @@
-use bevy_reflect::{
-    FromReflect, Reflect, ReflectDeserialize, ReflectFromReflect, ReflectSerialize,
-};
+use bevy_reflect::{Reflect, ReflectDeserialize, ReflectSerialize};
 use bevy_utils::{AHasher, RandomState};
 use serde::{Deserialize, Serialize};
 use std::{
@@ -10,8 +8,8 @@ use std::{
 };
 
 /// Represents a path to an asset in the file system.
-#[derive(Debug, Eq, PartialEq, Hash, Clone, Serialize, Deserialize, Reflect, FromReflect)]
-#[reflect(Debug, PartialEq, Hash, Serialize, Deserialize, FromReflect)]
+#[derive(Debug, Eq, PartialEq, Hash, Clone, Serialize, Deserialize, Reflect)]
+#[reflect(Debug, PartialEq, Hash, Serialize, Deserialize)]
 pub struct AssetPath<'a> {
     path: Cow<'a, Path>,
     label: Option<Cow<'a, str>>,

crates/bevy_asset/src/reflect.rs

@@ -254,11 +254,11 @@ mod tests {
     use std::any::TypeId;
 
     use bevy_app::{App, AppTypeRegistry};
-    use bevy_reflect::{FromReflect, Reflect, ReflectMut, TypeUuid};
+    use bevy_reflect::{Reflect, ReflectMut, TypeUuid};
 
     use crate::{AddAsset, AssetPlugin, HandleUntyped, ReflectAsset};
 
-    #[derive(Reflect, FromReflect, TypeUuid)]
+    #[derive(Reflect, TypeUuid)]
     #[uuid = "09191350-1238-4736-9a89-46f04bda6966"]
     struct AssetType {
         field: String,

crates/bevy_core/src/name.rs

@@ -1,8 +1,8 @@
 use bevy_ecs::{
     component::Component, entity::Entity, query::WorldQuery, reflect::ReflectComponent,
 };
+use bevy_reflect::std_traits::ReflectDefault;
 use bevy_reflect::Reflect;
-use bevy_reflect::{std_traits::ReflectDefault, FromReflect};
 use bevy_utils::AHasher;
 use std::{
     borrow::Cow,
@@ -17,7 +17,7 @@ use std::{
 /// [`Name`] should not be treated as a globally unique identifier for entities,
 /// as multiple entities can have the same name.  [`bevy_ecs::entity::Entity`] should be
 /// used instead as the default unique identifier.
-#[derive(Reflect, FromReflect, Component, Clone)]
+#[derive(Reflect, Component, Clone)]
 #[reflect(Component, Default, Debug)]
 pub struct Name {
     hash: u64, // TODO: Shouldn't be serialized

crates/bevy_core_pipeline/src/fxaa/mod.rs

@@ -7,9 +7,7 @@ use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, HandleUntyped};
 use bevy_derive::Deref;
 use bevy_ecs::prelude::*;
-use bevy_reflect::{
-    std_traits::ReflectDefault, FromReflect, Reflect, ReflectFromReflect, TypeUuid,
-};
+use bevy_reflect::{std_traits::ReflectDefault, Reflect, TypeUuid};
 use bevy_render::{
     extract_component::{ExtractComponent, ExtractComponentPlugin},
     prelude::Camera,
@@ -26,8 +24,8 @@ mod node;
 
 pub use node::FxaaNode;
 
-#[derive(Reflect, FromReflect, Eq, PartialEq, Hash, Clone, Copy)]
-#[reflect(FromReflect, PartialEq, Hash)]
+#[derive(Reflect, Eq, PartialEq, Hash, Clone, Copy)]
+#[reflect(PartialEq, Hash)]
 pub enum Sensitivity {
     Low,
     Medium,
@@ -48,8 +46,8 @@ impl Sensitivity {
     }
 }
 
-#[derive(Reflect, FromReflect, Component, Clone, ExtractComponent)]
-#[reflect(Component, FromReflect, Default)]
+#[derive(Reflect, Component, Clone, ExtractComponent)]
+#[reflect(Component, Default)]
 #[extract_component_filter(With<Camera>)]
 pub struct Fxaa {
     /// Enable render passes for FXAA.

crates/bevy_core_pipeline/src/tonemapping/mod.rs

@@ -2,7 +2,7 @@ use crate::fullscreen_vertex_shader::fullscreen_shader_vertex_state;
 use bevy_app::prelude::*;
 use bevy_asset::{load_internal_asset, Assets, Handle, HandleUntyped};
 use bevy_ecs::prelude::*;
-use bevy_reflect::{FromReflect, Reflect, TypeUuid};
+use bevy_reflect::{Reflect, TypeUuid};
 use bevy_render::camera::Camera;
 use bevy_render::extract_component::{ExtractComponent, ExtractComponentPlugin};
 use bevy_render::extract_resource::{ExtractResource, ExtractResourcePlugin};
@@ -114,17 +114,7 @@ pub struct TonemappingPipeline {
 
 /// Optionally enables a tonemapping shader that attempts to map linear input stimulus into a perceptually uniform image for a given [`Camera`] entity.
 #[derive(
-    Component,
-    Debug,
-    Hash,
-    Clone,
-    Copy,
-    Reflect,
-    Default,
-    ExtractComponent,
-    PartialEq,
-    Eq,
-    FromReflect,
+    Component, Debug, Hash, Clone, Copy, Reflect, Default, ExtractComponent, PartialEq, Eq,
 )]
 #[extract_component_filter(With<Camera>)]
 #[reflect(Component)]
@@ -301,17 +291,7 @@ pub fn queue_view_tonemapping_pipelines(
 }
 /// Enables a debanding shader that applies dithering to mitigate color banding in the final image for a given [`Camera`] entity.
 #[derive(
-    Component,
-    Debug,
-    Hash,
-    Clone,
-    Copy,
-    Reflect,
-    Default,
-    ExtractComponent,
-    PartialEq,
-    Eq,
-    FromReflect,
+    Component, Debug, Hash, Clone, Copy, Reflect, Default, ExtractComponent, PartialEq, Eq,
 )]
 #[extract_component_filter(With<Camera>)]
 #[reflect(Component)]

crates/bevy_ecs/src/reflect.rs

@@ -10,10 +10,7 @@ use crate::{
         EntityMut, EntityRef, FromWorld, World,
     },
 };
-use bevy_reflect::{
-    impl_from_reflect_value, impl_reflect_value, FromType, Reflect, ReflectDeserialize,
-    ReflectSerialize,
-};
+use bevy_reflect::{impl_reflect_value, FromType, Reflect, ReflectDeserialize, ReflectSerialize};
 
 /// A struct used to operate on reflected [`Component`] of a type.
 ///
@@ -408,7 +405,6 @@ impl<C: Resource + Reflect + FromWorld> FromType<C> for ReflectResource {
 }
 
 impl_reflect_value!((in bevy_ecs) Entity(Hash, PartialEq, Serialize, Deserialize));
-impl_from_reflect_value!(Entity);
 
 /// For a specific type of component, this maps any fields with values of type [`Entity`] to a new world.
 /// Since a given `Entity` ID is only valid for the world it came frome, when performing deserialization

crates/bevy_gizmos/src/lib.rs

@@ -33,9 +33,7 @@ use bevy_ecs::{
         Commands, Query, Res, ResMut, Resource, SystemParamItem,
     },
 };
-use bevy_reflect::{
-    std_traits::ReflectDefault, FromReflect, Reflect, ReflectFromReflect, TypePath, TypeUuid,
-};
+use bevy_reflect::{std_traits::ReflectDefault, Reflect, TypePath, TypeUuid};
 use bevy_render::{
     color::Color,
     extract_component::{ComponentUniforms, DynamicUniformIndex, UniformComponentPlugin},
@@ -191,8 +189,8 @@ pub struct AabbGizmoConfig {
 }
 
 /// Add this [`Component`] to an entity to draw its [`Aabb`] component.
-#[derive(Component, Reflect, FromReflect, Default, Debug)]
-#[reflect(Component, FromReflect, Default)]
+#[derive(Component, Reflect, Default, Debug)]
+#[reflect(Component, Default)]
 pub struct AabbGizmo {
     /// The color of the box.
     ///