Add #[reflect(from_reflect = false)] attribute

Author: MrGVSV

crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs

@@ -13,7 +13,7 @@ use syn::parse::{Parse, ParseStream};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
 use syn::token::Comma;
-use syn::{Meta, Path};
+use syn::{LitBool, Meta, Path};
 
 // The "special" trait idents that are used internally for reflection.
 // Received via attributes like `#[reflect(PartialEq, Hash, ...)]`
@@ -25,6 +25,9 @@ const HASH_ATTR: &str = "Hash";
 // but useful to know exist nonetheless
 pub(crate) const REFLECT_DEFAULT: &str = "ReflectDefault";
 
+// Attributes for `FromReflect` implementation
+const FROM_REFLECT_ATTR: &str = "from_reflect";
+
 // The error message to show when a trait/type is specified multiple times
 const CONFLICTING_TYPE_DATA_MESSAGE: &str = "conflicting type data registration";
 
@@ -62,6 +65,40 @@ impl TraitImpl {
     }
 }
 
+/// A collection of attributes used for deriving `FromReflect`.
+#[derive(Clone, Default)]
+pub(crate) struct FromReflectAttrs {
+    auto_derive: Option<LitBool>,
+}
+
+impl FromReflectAttrs {
+    /// Returns true if `FromReflect` should be automatically derived as part of the `Reflect` derive.
+    pub fn should_auto_derive(&self) -> bool {
+        self.auto_derive
+            .as_ref()
+            .map(|lit| lit.value())
+            .unwrap_or(true)
+    }
+
+    /// Merges this [`FromReflectAttrs`] with another.
+    pub fn merge(&mut self, other: FromReflectAttrs) -> Result<(), syn::Error> {
+        if let Some(new) = other.auto_derive {
+            if let Some(existing) = &self.auto_derive {
+                if existing.value() != new.value() {
+                    return Err(syn::Error::new(
+                        new.span(),
+                        format!("`from_reflect` already set to {}", existing.value()),
+                    ));
+                }
+            } else {
+                self.auto_derive = Some(new);
+            }
+        }
+
+        Ok(())
+    }
+}
+
 /// A collection of traits that have been registered for a reflected type.
 ///
 /// This keeps track of a few traits that are utilized internally for reflection
@@ -128,6 +165,7 @@ pub(crate) struct ReflectTraits {
     debug: TraitImpl,
     hash: TraitImpl,
     partial_eq: TraitImpl,
+    from_reflect: FromReflectAttrs,
     idents: Vec<Ident>,
 }
 
@@ -201,7 +239,24 @@ impl ReflectTraits {
                         Ok(())
                     })?;
                 }
-                _ => {}
+                Meta::NameValue(pair) => {
+                    if pair.path.is_ident(FROM_REFLECT_ATTR) {
+                        traits.from_reflect.auto_derive = match &pair.value {
+                            syn::Expr::Lit(syn::ExprLit {
+                                lit: syn::Lit::Bool(lit),
+                                ..
+                            }) => Some(lit.clone()),
+                            _ => {
+                                return Err(syn::Error::new(
+                                    pair.value.span(),
+                                    "Expected a boolean value",
+                                ))
+                            }
+                        };
+                    } else {
+                        return Err(syn::Error::new(pair.path.span(), "Unknown attribute"));
+                    }
+                }
             }
         }
 
@@ -219,6 +274,12 @@ impl ReflectTraits {
         &self.idents
     }
 
+    /// The `FromReflect` attributes on this type.
+    #[allow(clippy::wrong_self_convention)]
+    pub fn from_reflect(&self) -> &FromReflectAttrs {
+        &self.from_reflect
+    }
+
     /// Returns the implementation of `Reflect::reflect_hash` as a `TokenStream`.
     ///
     /// If `Hash` was not registered, returns `None`.
@@ -295,6 +356,7 @@ impl ReflectTraits {
         self.debug.merge(other.debug)?;
         self.hash.merge(other.hash)?;
         self.partial_eq.merge(other.partial_eq)?;
+        self.from_reflect.merge(other.from_reflect)?;
         for ident in other.idents {
             add_unique_ident(&mut self.idents, ident)?;
         }

crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs

@@ -1,4 +1,4 @@
-use crate::container_attributes::ReflectTraits;
+use crate::container_attributes::{FromReflectAttrs, ReflectTraits};
 use crate::field_attributes::{parse_field_attrs, ReflectFieldAttr};
 use crate::fq_std::{FQAny, FQDefault, FQSend, FQSync};
 use crate::type_path::parse_path_no_leading_colon;
@@ -376,6 +376,12 @@ impl<'a> ReflectMeta<'a> {
         &self.traits
     }
 
+    /// The `FromReflect` attributes on this type.
+    #[allow(clippy::wrong_self_convention)]
+    pub fn from_reflect(&self) -> &FromReflectAttrs {
+        self.traits.from_reflect()
+    }
+
     /// The name of this struct.
     pub fn type_path(&self) -> &ReflectTypePath<'a> {
         &self.type_path

crates/bevy_reflect/bevy_reflect_derive/src/lib.rs

@@ -111,6 +111,13 @@ pub(crate) static TYPE_NAME_ATTRIBUTE_NAME: &str = "type_name";
 /// If planning to serialize this type using the reflection serializers,
 /// then the `Serialize` and `Deserialize` traits will need to be implemented and registered as well.
 ///
+/// ## `#[reflect(from_reflect = false)]`
+///
+/// This attribute will opt-out of the default `FromReflect` implementation.
+///
+/// This is useful for when a type can't or shouldn't implement `FromReflect`,
+/// or if a manual implementation is desired.
+///
 /// # Field Attributes
 ///
 /// Along with the container attributes, this macro comes with some attributes that may be applied
@@ -147,17 +154,36 @@ pub fn derive_reflect(input: TokenStream) -> TokenStream {
     let (reflect_impls, from_reflect_impl) = match derive_data {
         ReflectDerive::Struct(struct_data) | ReflectDerive::UnitStruct(struct_data) => (
             impls::impl_struct(&struct_data),
-            from_reflect::impl_struct(&struct_data),
+            if struct_data.meta().from_reflect().should_auto_derive() {
+                Some(from_reflect::impl_struct(&struct_data))
+            } else {
+                None
+            },
         ),
         ReflectDerive::TupleStruct(struct_data) => (
             impls::impl_tuple_struct(&struct_data),
-            from_reflect::impl_tuple_struct(&struct_data),
+            if struct_data.meta().from_reflect().should_auto_derive() {
+                Some(from_reflect::impl_tuple_struct(&struct_data))
+            } else {
+                None
+            },
         ),
         ReflectDerive::Enum(enum_data) => (
             impls::impl_enum(&enum_data),
-            from_reflect::impl_enum(&enum_data),
+            if enum_data.meta().from_reflect().should_auto_derive() {
+                Some(from_reflect::impl_enum(&enum_data))
+            } else {
+                None
+            },
+        ),
+        ReflectDerive::Value(meta) => (
+            impls::impl_value(&meta),
+            if meta.from_reflect().should_auto_derive() {
+                Some(from_reflect::impl_value(&meta))
+            } else {
+                None
+            },
         ),
-        ReflectDerive::Value(meta) => (impls::impl_value(&meta), from_reflect::impl_value(&meta)),
     };
 
     TokenStream::from(quote! {
@@ -418,7 +444,6 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
 
             TokenStream::from(quote! {
                 #impl_struct
-
                 #impl_from_struct
             })
         }

crates/bevy_reflect/src/lib.rs

@@ -202,7 +202,8 @@
 //! And since the [`FromReflect::from_reflect`] method takes the data by reference,
 //! this can be used to effectively clone data (to an extent).
 //!
-//! It is automatically implemented when [deriving `Reflect`] on a type.
+//! It is automatically implemented when [deriving `Reflect`] on a type unless opted out of
+//! using `#[reflect(from_reflect = false)]` on the item.
 //!
 //! ```
 //! # use bevy_reflect::{Reflect, FromReflect};

crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/from_reflect.fail.rs

@@ -0,0 +1,19 @@
+use bevy_reflect::Reflect;
+
+// Reason: Cannot have conflicting `from_reflect` attributes
+#[derive(Reflect)]
+#[reflect(from_reflect = false)]
+#[reflect(from_reflect = true)]
+struct Foo {
+    value: String,
+}
+
+// Reason: Cannot have conflicting `from_reflect` attributes
+#[derive(Reflect)]
+#[reflect(from_reflect = true)]
+#[reflect(from_reflect = false)]
+struct Bar {
+    value: String,
+}
+
+fn main() {}

crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/from_reflect.fail.stderr

@@ -0,0 +1,11 @@
+error: `from_reflect` already set to false
+ --> tests/reflect_derive/from_reflect.fail.rs:6:26
+  |
+6 | #[reflect(from_reflect = true)]
+  |                          ^^^^
+
+error: `from_reflect` already set to true
+  --> tests/reflect_derive/from_reflect.fail.rs:14:26
+   |
+14 | #[reflect(from_reflect = false)]
+   |                          ^^^^^

crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/from_reflect.pass.rs

@@ -0,0 +1,17 @@
+use bevy_reflect::Reflect;
+
+#[derive(Reflect)]
+#[reflect(from_reflect = false)]
+#[reflect(from_reflect = false)]
+struct Foo {
+    value: String,
+}
+
+#[derive(Reflect)]
+#[reflect(from_reflect = true)]
+#[reflect(from_reflect = true)]
+struct Bar {
+    value: String,
+}
+
+fn main() {}

examples/reflection/reflection.rs

@@ -25,7 +25,15 @@ fn main() {
 /// Deriving `Reflect` implements the relevant reflection traits. In this case, it implements the
 /// `Reflect` trait and the `Struct` trait `derive(Reflect)` assumes that all fields also implement
 /// Reflect.
+///
+/// All fields in a reflected item will need to be `Reflect` as well. You can opt a field out of
+/// reflection by using the `#[reflect(ignore)]` attribute.
+/// If you choose to ignore a field, you need to let the automatically-derived `FromReflect` implementation
+/// how to handle the field.
+/// To do this, you can either define a `#[reflect(default = "...")]` attribute on the ignored field, or
+/// opt-out of `FromReflect`'s auto-derive using the `#[reflect(from_reflect = false)]` attribute.
 #[derive(Reflect)]
+#[reflect(from_reflect = false)]
 pub struct Foo {
     a: usize,
     nested: Bar,