Add #[from_reflect(auto_derive = false)] attribute

MrGVSV · MrGVSV · commit 8c6bbfca76b2 · 2022-11-09T23:18:08.000-07:00
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs b/crates/bevy_reflect/bevy_reflect_derive/src/container_attributes.rs
@@ -12,7 +12,7 @@ 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, ...)]`
@@ -24,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";
+
 // The error message to show when a trait/type is specified multiple times
 const CONFLICTING_TYPE_DATA_MESSAGE: &str = "conflicting type data registration";
 
@@ -323,3 +326,59 @@ fn add_unique_ident(idents: &mut Vec<Ident>, ident: Ident) -> Result<(), syn::Er
     idents.push(ident);
     Ok(())
 }
+
+/// 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)
+    }
+}
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs b/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.
@@ -129,6 +133,7 @@ enum ReflectMode {
 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 reflect_mode = None;
 
@@ -161,6 +166,9 @@ impl<'a> ReflectDerive<'a> {
                     let new_traits = ReflectTraits::from_nested_metas(&meta_list.nested)?;
                     traits = traits.merge(new_traits)?;
                 }
+                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) => {
                     if !matches!(reflect_mode, None | Some(ReflectMode::Value)) {
                         return Err(syn::Error::new(
@@ -181,7 +189,7 @@ impl<'a> ReflectDerive<'a> {
             }
         }
 
-        let meta = ReflectMeta::new(&input.ident, &input.generics, traits);
+        let meta = ReflectMeta::new(&input.ident, &input.generics, traits, from_reflect);
 
         #[cfg(feature = "documentation")]
         let meta = meta.with_docs(doc);
@@ -278,9 +286,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(),
@@ -300,6 +314,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
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -37,8 +37,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);
 
@@ -50,17 +51,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! {
@@ -114,6 +134,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(),
     );
 
     #[cfg(feature = "documentation")]
@@ -171,7 +192,6 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
 
             TokenStream::from(quote! {
                 #impl_struct
-
                 #impl_from_struct
             })
         }
@@ -200,6 +220,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()
 }
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/reflect_value.rs b/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};
@@ -24,6 +24,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 {
@@ -53,6 +54,7 @@ impl Parse for ReflectValueDef {
                 ..generics
             },
             traits,
+            from_reflect: None,
         })
     }
 }
diff --git a/examples/reflection/reflection.rs b/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,

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use crate::container_attributes::ReflectTraits;`
	`1`	`+use crate::container_attributes::{FromReflectAttrs, ReflectTraits};`
`2`	`2`	`use proc_macro2::Ident;`
`3`	`3`	`use syn::parse::{Parse, ParseStream};`
`4`	`4`	`use syn::token::{Paren, Where};`
`@@ -24,6 +24,7 @@ pub(crate) struct ReflectValueDef {`
`24`	`24`	`pub type_name: Ident,`
`25`	`25`	`pub generics: Generics,`
`26`	`26`	`pub traits: Option<ReflectTraits>,`
	`27`	`+ pub from_reflect: Option<FromReflectAttrs>,`
`27`	`28`	`}`
`28`	`29`
`29`	`30`	`impl Parse for ReflectValueDef {`
`@@ -53,6 +54,7 @@ impl Parse for ReflectValueDef {`
`53`	`54`	`..generics`
`54`	`55`	`},`
`55`	`56`	`traits,`
	`57`	`+ from_reflect: None,`
`56`	`58`	`})`
`57`	`59`	`}`
`58`	`60`	`}`