[Merged by Bors] - Add macro to implement reflect for struct types and migrate glam types

crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs

@@ -8,6 +8,7 @@ pub fn impl_struct(
     bevy_reflect_path: &Path,
     active_fields: &[(&Field, usize)],
     ignored_fields: &[(&Field, usize)],
+    custom_ctor: Option<proc_macro2::TokenStream>,
 ) -> TokenStream {
     let field_names = active_fields
         .iter()
@@ -60,20 +61,36 @@ pub fn impl_struct(
         #(#field_types: #bevy_reflect_path::FromReflect,)*
     });
 
+    let ctor = if let Some(ctor) = custom_ctor {
+        quote!(
+            let mut value: Self = #ctor;
+            #(
+                value.#field_idents = {
+                    <#field_types as #bevy_reflect_path::FromReflect>::from_reflect(ref_struct.field(#field_names)?)?
+                };
+            )*
+            Some(value)
+        )
+    } else {
+        quote!(
+            Some(
+                Self {
+                    #(#field_idents: {
+                        <#field_types as #bevy_reflect_path::FromReflect>::from_reflect(ref_struct.field(#field_names)?)?
+                    },)*
+                    #(#ignored_field_idents: Default::default(),)*
+                }
+            )
+        )
+    };
+
     TokenStream::from(quote! {
         impl #impl_generics #bevy_reflect_path::FromReflect for #struct_name #ty_generics #where_from_reflect_clause
         {
             fn from_reflect(reflect: &dyn #bevy_reflect_path::Reflect) -> Option<Self> {
                 use #bevy_reflect_path::Struct;
                 if let #bevy_reflect_path::ReflectRef::Struct(ref_struct) = reflect.reflect_ref() {
-                    Some(
-                        Self{
-                            #(#field_idents: {
-                                <#field_types as #bevy_reflect_path::FromReflect>::from_reflect(ref_struct.field(#field_names)?)?
-                            },)*
-                            #(#ignored_field_idents: Default::default(),)*
-                        }
-                    )
+                    #ctor
                 } else {
                     None
                 }

crates/bevy_reflect/bevy_reflect_derive/src/lib.rs

@@ -575,6 +575,155 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
     )
 }
 
+#[proc_macro]
+pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenStream {
+    let mut iter = input.into_iter().peekable();
+    let (r#constructor, ctor) = (iter.next().unwrap(), iter.next().unwrap());
+    match r#constructor {
+        proc_macro::TokenTree::Ident(i) => {
+            if i.to_string() != "Constructor" {
+                panic!("Invalid constructor syntax")
+            }
+        }
+        _ => panic!("Invalid constructor syntax"),
+    };
+    let ctor: proc_macro2::TokenStream = match ctor {
+        proc_macro::TokenTree::Group(g) => g.stream(),
+        _ => panic!("Invalid constructor syntax"),
+    }
+    .into();
+
+    let path_override = if let Some(next) = iter.peek() {
+        if match next {
+            proc_macro::TokenTree::Ident(i) => i.to_string() == "BevyReflectPath",
+            _ => false,
+        } {
+            _ = iter.next(); // Discard BevyReflectPath
+            Some(match iter.next() {
+                Some(proc_macro::TokenTree::Group(g)) => g.stream(),
+                _ => panic!("Invalid BevyReflectPath override!"),
+            })
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    let input = iter.collect();
+
+    let ast = parse_macro_input!(input as DeriveInput);
+
+    let bevy_reflect_path = if let Some(r#override) = path_override {
+        syn::parse(r#override).expect("Invalid BevyReflectPath override!")
+    } else {
+        BevyManifest::default().get_path("bevy_reflect")
+    };
+    let ident = &ast.ident;
+    let generics = &ast.generics;
+    let data = match &ast.data {
+        Data::Struct(r#struct) => r#struct,
+        // I don't believe enum reflection is implemented right now,
+        // and unions are likely not going to be reflected.
+        _ => unimplemented!(),
+    };
+    let fields = &data.fields;
+    let fields_and_args = fields
+        .iter()
+        .enumerate()
+        .map(|(i, f)| {
+            (
+                f,
+                f.attrs
+                    .iter()
+                    .find(|a| *a.path.get_ident().as_ref().unwrap() == REFLECT_ATTRIBUTE_NAME)
+                    .map(|a| {
+                        syn::custom_keyword!(ignore);
+                        let mut attribute_args = PropAttributeArgs { ignore: None };
+                        a.parse_args_with(|input: ParseStream| {
+                            if input.parse::<Option<ignore>>()?.is_some() {
+                                attribute_args.ignore = Some(true);
+                                return Ok(());
+                            }
+                            Ok(())
+                        })
+                        .expect("Invalid 'property' attribute format.");
+
+                        attribute_args
+                    }),
+                i,
+            )
+        })
+        .collect::<Vec<(&Field, Option<PropAttributeArgs>, usize)>>();
+    let active_fields = fields_and_args
+        .iter()
+        .filter(|(_field, attrs, _i)| {
+            attrs.is_none()
+                || match attrs.as_ref().unwrap().ignore {
+                    Some(ignore) => !ignore,
+                    None => true,
+                }
+        })
+        .map(|(f, _attr, i)| (*f, *i))
+        .collect::<Vec<(&Field, usize)>>();
+    let ignored_fields = fields_and_args
+        .iter()
+        .filter(|(_field, attrs, _i)| {
+            attrs
+                .as_ref()
+                .map(|attrs| attrs.ignore.unwrap_or(false))
+                .unwrap_or(false)
+        })
+        .map(|(f, _attr, i)| (*f, *i))
+        .collect::<Vec<(&Field, usize)>>();
+
+    let mut reflect_attrs = ReflectAttrs::default();
+    for attribute in ast.attrs.iter().filter_map(|attr| attr.parse_meta().ok()) {
+        let meta_list = if let Meta::List(meta_list) = attribute {
+            meta_list
+        } else {
+            continue;
+        };
+
+        if let Some(ident) = meta_list.path.get_ident() {
+            if ident == REFLECT_ATTRIBUTE_NAME || ident == REFLECT_VALUE_ATTRIBUTE_NAME {
+                reflect_attrs = ReflectAttrs::from_nested_metas(&meta_list.nested);
+            }
+        }
+    }
+
+    let registration_data = &reflect_attrs.data;
+    let get_type_registration_impl =
+        impl_get_type_registration(ident, &bevy_reflect_path, registration_data, generics);
+
+    let impl_struct: proc_macro2::TokenStream = impl_struct(
+        ident,
+        generics,
+        &get_type_registration_impl,
+        &bevy_reflect_path,
+        &reflect_attrs,
+        &active_fields,
+    )
+    .into();
+
+    let impl_from_struct: proc_macro2::TokenStream = from_reflect::impl_struct(
+        ident,
+        generics,
+        &bevy_reflect_path,
+        &active_fields,
+        &ignored_fields,
+        Some(ctor),
+    )
+    .into();
+
+    quote!(
+        #impl_struct
+
+        #impl_from_struct
+    )
+    .into()
+}
+
 #[derive(Default)]
 struct ReflectAttrs {
     reflect_hash: TraitImpl,
@@ -830,6 +979,7 @@ pub fn derive_from_reflect(input: TokenStream) -> TokenStream {
             &bevy_reflect_path,
             &active_fields,
             &ignored_fields,
+            None,
         ),
         DeriveType::TupleStruct => from_reflect::impl_tuple_struct(
             type_name,