Add #[from_reflect(auto_derive = false)] attribute

Author: MrGVSV

crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs

@@ -10,8 +10,9 @@ use proc_macro2::Ident;
 use quote::quote;
 use syn::parse::{Parse, ParseStream};
 use syn::punctuated::Punctuated;
+use syn::spanned::Spanned;
 use syn::token::Comma;
-use syn::{Meta, NestedMeta, Path};
+use syn::{Lit, Meta, NestedMeta, Path};
 
 // The "special" trait idents that are used internally for reflection.
 // Received via attributes like `#[reflect(PartialEq, Hash, ...)]`
@@ -23,6 +24,9 @@ const HASH_ATTR: &str = "Hash";
 // but useful to know exist nonetheless
 pub(crate) const REFLECT_DEFAULT: &str = "ReflectDefault";
 
+// Attributes for `FromReflect` derive
+const FROM_REFLECT_AUTO_DERIVE_ATTR: &str = "auto_derive";
+
 /// A marker for trait implementations registered via the `Reflect` derive macro.
 #[derive(Clone, Default)]
 pub(crate) enum TraitImpl {
@@ -245,3 +249,59 @@ impl Parse for ReflectTraits {
         Ok(ReflectTraits::from_nested_metas(&result))
     }
 }
+
+/// A collection of attributes used for deriving `FromReflect`.
+#[derive(Clone)]
+pub(crate) struct FromReflectAttrs {
+    auto_derive: bool,
+}
+
+impl Default for FromReflectAttrs {
+    fn default() -> Self {
+        Self { auto_derive: true }
+    }
+}
+
+impl FromReflectAttrs {
+    pub fn from_nested_metas(nested_metas: &Punctuated<NestedMeta, Comma>) -> syn::Result<Self> {
+        let mut attrs = FromReflectAttrs::default();
+        for nested_meta in nested_metas.iter() {
+            if let NestedMeta::Meta(Meta::NameValue(pair)) = nested_meta {
+                let ident = pair.path.get_ident().ok_or_else(|| {
+                    syn::Error::new(
+                        pair.path.span(),
+                        "expected ident key in `from_reflect` attribute",
+                    )
+                })?;
+
+                let key = ident.to_string();
+                match key.as_str() {
+                    FROM_REFLECT_AUTO_DERIVE_ATTR => match &pair.lit {
+                        Lit::Bool(auto_derive) => attrs.auto_derive = auto_derive.value,
+                        lit => return Err(syn::Error::new(lit.span(), "expected boolean value")),
+                    },
+                    unknown => {
+                        return Err(syn::Error::new(
+                            ident.span(),
+                            format!("unknown key in `from_reflect` attribute: `{}`", unknown),
+                        ))
+                    }
+                }
+            }
+        }
+
+        Ok(attrs)
+    }
+
+    /// Returns true if `FromReflect` should be automatically derived as part of the `Reflect` derive.
+    pub fn should_auto_derive(&self) -> bool {
+        self.auto_derive
+    }
+}
+
+impl Parse for FromReflectAttrs {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let result = Punctuated::<NestedMeta, Comma>::parse_terminated(input)?;
+        FromReflectAttrs::from_nested_metas(&result)
+    }
+}

crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs

@@ -1,10 +1,12 @@
-use crate::container_attributes::ReflectTraits;
+use crate::container_attributes::{FromReflectAttrs, ReflectTraits};
 use crate::field_attributes::{parse_field_attrs, ReflectFieldAttr};
 use crate::utility::members_to_serialization_denylist;
 use bit_set::BitSet;
 use quote::quote;
 
-use crate::{utility, REFLECT_ATTRIBUTE_NAME, REFLECT_VALUE_ATTRIBUTE_NAME};
+use crate::{
+    utility, FROM_REFLECT_ATTRIBUTE_NAME, REFLECT_ATTRIBUTE_NAME, REFLECT_VALUE_ATTRIBUTE_NAME,
+};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
 use syn::{Data, DeriveInput, Field, Fields, Generics, Ident, Meta, Path, Token, Variant};
@@ -33,6 +35,8 @@ pub(crate) enum ReflectDerive<'a> {
 pub(crate) struct ReflectMeta<'a> {
     /// The registered traits for this type.
     traits: ReflectTraits,
+    /// The `FromReflect` attributes for this type.
+    from_reflect: FromReflectAttrs,
     /// The name of this type.
     type_name: &'a Ident,
     /// The generics defined on this type.
@@ -111,6 +115,7 @@ pub(crate) enum EnumVariantFields<'a> {
 impl<'a> ReflectDerive<'a> {
     pub fn from_input(input: &'a DeriveInput) -> Result<Self, syn::Error> {
         let mut traits = ReflectTraits::default();
+        let mut from_reflect = FromReflectAttrs::default();
         // Should indicate whether `#[reflect_value]` was used
         let mut force_reflect_value = false;
 
@@ -123,6 +128,9 @@ impl<'a> ReflectDerive<'a> {
                     force_reflect_value = true;
                     traits = ReflectTraits::from_nested_metas(&meta_list.nested);
                 }
+                Meta::List(meta_list) if meta_list.path.is_ident(FROM_REFLECT_ATTRIBUTE_NAME) => {
+                    from_reflect = FromReflectAttrs::from_nested_metas(&meta_list.nested)?;
+                }
                 Meta::Path(path) if path.is_ident(REFLECT_VALUE_ATTRIBUTE_NAME) => {
                     force_reflect_value = true;
                 }
@@ -134,13 +142,14 @@ impl<'a> ReflectDerive<'a> {
                 &input.ident,
                 &input.generics,
                 traits,
+                from_reflect,
             )));
         }
 
         return match &input.data {
             Data::Struct(data) => {
                 let fields = Self::collect_struct_fields(&data.fields)?;
-                let meta = ReflectMeta::new(&input.ident, &input.generics, traits);
+                let meta = ReflectMeta::new(&input.ident, &input.generics, traits, from_reflect);
                 let reflect_struct = ReflectStruct {
                     meta,
                     serialization_denylist: members_to_serialization_denylist(
@@ -157,7 +166,7 @@ impl<'a> ReflectDerive<'a> {
             }
             Data::Enum(data) => {
                 let variants = Self::collect_enum_variants(&data.variants)?;
-                let meta = ReflectMeta::new(&input.ident, &input.generics, traits);
+                let meta = ReflectMeta::new(&input.ident, &input.generics, traits, from_reflect);
 
                 let reflect_enum = ReflectEnum { meta, variants };
                 Ok(Self::Enum(reflect_enum))
@@ -220,9 +229,15 @@ impl<'a> ReflectDerive<'a> {
 }
 
 impl<'a> ReflectMeta<'a> {
-    pub fn new(type_name: &'a Ident, generics: &'a Generics, traits: ReflectTraits) -> Self {
+    pub fn new(
+        type_name: &'a Ident,
+        generics: &'a Generics,
+        traits: ReflectTraits,
+        from_reflect: FromReflectAttrs,
+    ) -> Self {
         Self {
             traits,
+            from_reflect,
             type_name,
             generics,
             bevy_reflect_path: utility::get_bevy_reflect_path(),
@@ -234,6 +249,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.from_reflect
+    }
+
     /// The name of this struct.
     pub fn type_name(&self) -> &'a Ident {
         self.type_name

crates/bevy_reflect/bevy_reflect_derive/src/lib.rs

@@ -35,8 +35,9 @@ use syn::{parse_macro_input, DeriveInput};
 
 pub(crate) static REFLECT_ATTRIBUTE_NAME: &str = "reflect";
 pub(crate) static REFLECT_VALUE_ATTRIBUTE_NAME: &str = "reflect_value";
+pub(crate) static FROM_REFLECT_ATTRIBUTE_NAME: &str = "from_reflect";
 
-#[proc_macro_derive(Reflect, attributes(reflect, reflect_value, module))]
+#[proc_macro_derive(Reflect, attributes(reflect, reflect_value, from_reflect, module))]
 pub fn derive_reflect(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
 
@@ -48,17 +49,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! {
@@ -112,6 +132,7 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
         &def.type_name,
         &def.generics,
         def.traits.unwrap_or_default(),
+        def.from_reflect.unwrap_or_default(),
     );
     let reflect_impls = impls::impl_value(&meta);
     let from_reflect_impl = from_reflect::impl_value(&meta);
@@ -160,13 +181,11 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
 
     match derive_data {
         ReflectDerive::Struct(struct_data) => {
-            let impl_struct: proc_macro2::TokenStream = impls::impl_struct(&struct_data).into();
-            let impl_from_struct: proc_macro2::TokenStream =
-                from_reflect::impl_struct(&struct_data).into();
+            let impl_struct = impls::impl_struct(&struct_data);
+            let impl_from_struct = from_reflect::impl_struct(&struct_data);
 
             TokenStream::from(quote! {
                 #impl_struct
-
                 #impl_from_struct
             })
         }
@@ -195,6 +214,7 @@ pub fn impl_from_reflect_value(input: TokenStream) -> TokenStream {
         &def.type_name,
         &def.generics,
         def.traits.unwrap_or_default(),
+        def.from_reflect.unwrap_or_default(),
     ))
     .into()
 }

crates/bevy_reflect/bevy_reflect_derive/src/reflect_value.rs

@@ -1,4 +1,4 @@
-use crate::container_attributes::ReflectTraits;
+use crate::container_attributes::{FromReflectAttrs, ReflectTraits};
 use proc_macro2::Ident;
 use syn::parse::{Parse, ParseStream};
 use syn::token::{Paren, Where};
@@ -22,6 +22,7 @@ pub(crate) struct ReflectValueDef {
     pub type_name: Ident,
     pub generics: Generics,
     pub traits: Option<ReflectTraits>,
+    pub from_reflect: Option<FromReflectAttrs>,
 }
 
 impl Parse for ReflectValueDef {
@@ -49,6 +50,7 @@ impl Parse for ReflectValueDef {
                 ..generics
             },
             traits,
+            from_reflect: None,
         })
     }
 }

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 `#[from_reflect(auto_derive = false)]` attribute.
 #[derive(Reflect)]
+#[from_reflect(auto_derive = false)]
 pub struct Foo {
     a: usize,
     nested: Bar,