Added #[reflect(default)] attribute

Author: MrGVSV

crates/bevy_reflect/bevy_reflect_derive/src/field_attributes.rs

@@ -7,15 +7,37 @@
 use crate::REFLECT_ATTRIBUTE_NAME;
 use quote::ToTokens;
 use syn::spanned::Spanned;
-use syn::{Attribute, Meta, NestedMeta};
+use syn::{Attribute, Lit, Meta, NestedMeta};
 
 pub(crate) static IGNORE_ATTR: &str = "ignore";
+pub(crate) static DEFAULT_ATTR: &str = "default";
 
 /// A container for attributes defined on a field reflected type's field.
 #[derive(Default)]
 pub(crate) struct ReflectFieldAttr {
     /// Determines if this field should be ignored.
     pub ignore: bool,
+    /// Sets the default behavior of this field.
+    pub default: DefaultBehavior,
+}
+
+/// Controls how the default value is determined for a field.
+pub(crate) enum DefaultBehavior {
+    /// Field is required.
+    Required,
+    /// Field can be defaulted using `Default::default()`.
+    Default,
+    /// Field can be created using the given function name.
+    ///
+    /// This assumes the function is in scope, is callable with zero arguments,
+    /// and returns the expected type.
+    Func(syn::ExprPath),
+}
+
+impl Default for DefaultBehavior {
+    fn default() -> Self {
+        Self::Required
+    }
 }
 
 /// Parse all field attributes marked "reflect" (such as `#[reflect(ignore)]`).
@@ -50,10 +72,29 @@ fn parse_meta(args: &mut ReflectFieldAttr, meta: &Meta) -> Result<(), syn::Error
             args.ignore = true;
             Ok(())
         }
+        Meta::Path(path) if path.is_ident(DEFAULT_ATTR) => {
+            args.default = DefaultBehavior::Default;
+            Ok(())
+        }
         Meta::Path(path) => Err(syn::Error::new(
             path.span(),
             format!("unknown attribute parameter: {}", path.to_token_stream()),
         )),
+        Meta::NameValue(pair) if pair.path.is_ident(DEFAULT_ATTR) => {
+            let lit = &pair.lit;
+            match lit {
+                Lit::Str(lit_str) => {
+                    args.default = DefaultBehavior::Func(lit_str.parse()?);
+                    Ok(())
+                }
+                err => {
+                    Err(syn::Error::new(
+                        err.span(),
+                        format!("expected a string literal containing the name of a function, but found: {}", err.to_token_stream()),
+                    ))
+                }
+            }
+        }
         Meta::NameValue(pair) => {
             let path = &pair.path;
             Err(syn::Error::new(

crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs

@@ -1,3 +1,4 @@
+use crate::field_attributes::DefaultBehavior;
 use crate::ReflectDeriveData;
 use proc_macro::TokenStream;
 use proc_macro2::Span;
@@ -112,8 +113,10 @@ fn get_ignored_fields(derive_data: &ReflectDeriveData, is_tuple: bool) -> Member
             .ignored_fields()
             .map(|field| {
                 let member = get_ident(field.data, field.index, is_tuple);
-                let value = quote! {
-                    Default::default()
+
+                let value = match &field.attrs.default {
+                    DefaultBehavior::Func(path) => quote! {#path()},
+                    _ => quote! {Default::default()},
                 };
 
                 (member, value)
@@ -139,12 +142,29 @@ fn get_active_fields(
                 let accessor = get_field_accessor(field.data, field.index, is_tuple);
                 let ty = field.data.ty.clone();
 
-                let value = quote! { {
-                    <#ty as #bevy_reflect_path::FromReflect>::from_reflect(
-                        // Accesses the field on the given dynamic struct or tuple struct
-                        #bevy_reflect_path::#struct_type::field(#dyn_struct_name, #accessor)?
-                    )?
-                }};
+                let get_field = quote! {
+                    #bevy_reflect_path::#struct_type::field(#dyn_struct_name, #accessor)
+                };
+
+                let value = match &field.attrs.default {
+                    DefaultBehavior::Func(path) => quote! {
+                        if let Some(field) = #get_field {
+                            <#ty as #bevy_reflect_path::FromReflect>::from_reflect(field)?
+                        } else {
+                            #path()
+                        }
+                    },
+                    DefaultBehavior::Default => quote! {
+                        if let Some(field) = #get_field {
+                            <#ty as #bevy_reflect_path::FromReflect>::from_reflect(field)?
+                        } else {
+                            Default::default()
+                        }
+                    },
+                    DefaultBehavior::Required => quote! {
+                        <#ty as #bevy_reflect_path::FromReflect>::from_reflect(#get_field?)?
+                    },
+                };
 
                 (member, value)
             })