From 71a770fad4d436aa8ef3c4e9a1ff3b74b582bcaf Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 19 Apr 2022 11:01:20 -0400
Subject: [PATCH 01/52] Implemented impl_reflect_struct

---
 .../bevy_reflect_derive/src/lib.rs            | 88 ++++++++++++++++++-
 1 file changed, 87 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 8128b292b8559..c091ff7a56052 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -575,6 +575,92 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
     )
 }
 
+#[proc_macro]
+pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+
+    let bevy_reflect_path = 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,
+        // 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 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,
+    );
+
+    impl_struct(
+        ident,
+        generics,
+        &get_type_registration_impl,
+        &bevy_reflect_path,
+        &reflect_attrs,
+        &active_fields
+    )
+}
+
 #[derive(Default)]
 struct ReflectAttrs {
     reflect_hash: TraitImpl,
@@ -849,4 +935,4 @@ pub fn impl_from_reflect_value(input: TokenStream) -> TokenStream {
     let bevy_reflect_path = BevyManifest::default().get_path("bevy_reflect");
     let ty = &reflect_value_def.type_name;
     from_reflect::impl_value(ty, &reflect_value_def.generics, &bevy_reflect_path)
-}
+}
\ No newline at end of file

From 58604962be1055b4fbecbea6a38d636a0460d1ab Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 19 Apr 2022 11:01:47 -0400
Subject: [PATCH 02/52] Testing impl_reflect_struct

---
 crates/bevy_reflect/src/impls/glam.rs | 50 +++++++++++++++++++++++++--
 1 file changed, 47 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 077a202fbb872..6a5360f5e7b0e 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -1,16 +1,17 @@
 use crate as bevy_reflect;
 use crate::ReflectDeserialize;
-use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value};
+use crate::reflect::Reflect;
+use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value, impl_reflect_struct};
 use glam::*;
 
-impl_reflect_value!(IVec2(PartialEq, Serialize, Deserialize));
+// impl_reflect_value!(IVec2(PartialEq, Serialize, Deserialize));
 impl_reflect_value!(IVec3(PartialEq, Serialize, Deserialize));
 impl_reflect_value!(IVec4(PartialEq, Serialize, Deserialize));
 impl_reflect_value!(UVec2(PartialEq, Serialize, Deserialize));
 impl_reflect_value!(UVec3(PartialEq, Serialize, Deserialize));
 impl_reflect_value!(UVec4(PartialEq, Serialize, Deserialize));
 impl_reflect_value!(Vec2(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(Vec3(PartialEq, Serialize, Deserialize));
+// impl_reflect_value!(Vec3(PartialEq, Serialize, Deserialize));
 impl_reflect_value!(Vec3A(PartialEq, Serialize, Deserialize));
 impl_reflect_value!(Vec4(PartialEq, Serialize, Deserialize));
 impl_reflect_value!(DVec2(PartialEq, Serialize, Deserialize));
@@ -23,6 +24,27 @@ impl_reflect_value!(DMat3(PartialEq, Serialize, Deserialize));
 impl_reflect_value!(DMat4(PartialEq, Serialize, Deserialize));
 impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize));
 
+/*
+==========================
+|     Updated impls      |
+==========================
+*/
+
+impl_reflect_struct!(
+    struct IVec2 {
+        x: i32,
+        y: i32
+    }
+);
+
+impl_reflect_struct!(
+    struct Vec3 {
+        x: f32,
+        y: f32,
+        z: f32
+    }
+);
+
 impl_from_reflect_value!(IVec2);
 impl_from_reflect_value!(IVec3);
 impl_from_reflect_value!(IVec4);
@@ -42,3 +64,25 @@ impl_from_reflect_value!(Quat);
 impl_from_reflect_value!(DMat3);
 impl_from_reflect_value!(DMat4);
 impl_from_reflect_value!(DQuat);
+
+#[test]
+fn temp_test() {
+    let v = vec3(12.0, 0.0, 0.0);
+
+    let refl: &dyn Reflect = &v;
+
+    assert!(match refl.reflect_ref() {
+        bevy_reflect::ReflectRef::Struct(_) => true,
+        _ => false,
+    });
+
+    assert!(match refl.reflect_ref() {
+        bevy_reflect::ReflectRef::Struct(s) => s.field("x").is_some(),
+        _ => false
+    });
+
+    assert!(match refl.reflect_ref() {
+        bevy_reflect::ReflectRef::Struct(s) => s.field("x").unwrap().downcast_ref::<f32>().unwrap() == &12.0,
+        _ => false
+    });
+}
\ No newline at end of file

From 478d9ce64999829de268a5b345a70c9361a611ae Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 19 Apr 2022 11:05:34 -0400
Subject: [PATCH 03/52] Rephrased impl_struct for from_reflect To be compatible
 with non-constructible foreign types

---
 .../bevy_reflect_derive/src/from_reflect.rs         | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
index 68d18d36a6f4c..bf6acc706c036 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
@@ -66,14 +66,11 @@ pub fn impl_struct(
             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(),)*
-                        }
-                    )
+                    let mut value: Self = Default::default();
+                    #(
+                        value.#field_idents = <#field_types as #bevy_reflect_path::FromReflect>::from_reflect(ref_struct.field(#field_names)?)?
+                    )*
+                    Some(value)
                 } else {
                     None
                 }

From 650e7a741ca68fa4f59c3efbf5839cc1b2be3863 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 19 Apr 2022 11:24:10 -0400
Subject: [PATCH 04/52] Added from_reflect to impl_reflect_struct

---
 .../bevy_reflect_derive/src/from_reflect.rs   |  2 +-
 .../bevy_reflect_derive/src/lib.rs            | 32 ++++++++++++++++---
 crates/bevy_reflect/src/impls/glam.rs         | 10 +++---
 3 files changed, 34 insertions(+), 10 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
index bf6acc706c036..b9b2ffd37672b 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
@@ -68,7 +68,7 @@ pub fn impl_struct(
                 if let #bevy_reflect_path::ReflectRef::Struct(ref_struct) = reflect.reflect_ref() {
                     let mut value: Self = Default::default();
                     #(
-                        value.#field_idents = <#field_types as #bevy_reflect_path::FromReflect>::from_reflect(ref_struct.field(#field_names)?)?
+                        value.#field_idents = <#field_types as #bevy_reflect_path::FromReflect>::from_reflect(ref_struct.field(#field_names)?)?;
                     )*
                     Some(value)
                 } else {
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index c091ff7a56052..c83caf7d0f5bc 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -576,7 +576,7 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
 }
 
 #[proc_macro]
-pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
+pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
 
     let bevy_reflect_path = BevyManifest::default().get_path("bevy_reflect");
@@ -584,7 +584,7 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
     let generics = &ast.generics;
     let data = match &ast.data {
         Data::Struct(r#struct) => r#struct,
-        // Don't believe enum reflection is implemented right now,
+        // I don't believe enum reflection is implemented right now,
         // and unions are likely not going to be reflected.
         _ => unimplemented!()
     };
@@ -627,6 +627,16 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
         })
         .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()) {
@@ -651,14 +661,28 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
         generics,
     );
 
-    impl_struct(
+    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
+    ).into();
+
+    quote!(
+        #impl_struct
+
+        #impl_from_struct
+    ).into()
 }
 
 #[derive(Default)]
diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 6a5360f5e7b0e..d1700108cc4c9 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -1,7 +1,7 @@
 use crate as bevy_reflect;
 use crate::ReflectDeserialize;
 use crate::reflect::Reflect;
-use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value, impl_reflect_struct};
+use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value, impl_reflect_struct_and_from_reflect_struct};
 use glam::*;
 
 // impl_reflect_value!(IVec2(PartialEq, Serialize, Deserialize));
@@ -30,14 +30,14 @@ impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize));
 ==========================
 */
 
-impl_reflect_struct!(
+impl_reflect_struct_and_from_reflect_struct!(
     struct IVec2 {
         x: i32,
         y: i32
     }
 );
 
-impl_reflect_struct!(
+impl_reflect_struct_and_from_reflect_struct!(
     struct Vec3 {
         x: f32,
         y: f32,
@@ -45,14 +45,14 @@ impl_reflect_struct!(
     }
 );
 
-impl_from_reflect_value!(IVec2);
+// impl_from_reflect_value!(IVec2);
 impl_from_reflect_value!(IVec3);
 impl_from_reflect_value!(IVec4);
 impl_from_reflect_value!(UVec2);
 impl_from_reflect_value!(UVec3);
 impl_from_reflect_value!(UVec4);
 impl_from_reflect_value!(Vec2);
-impl_from_reflect_value!(Vec3);
+// impl_from_reflect_value!(Vec3);
 impl_from_reflect_value!(Vec4);
 impl_from_reflect_value!(Vec3A);
 impl_from_reflect_value!(DVec2);

From fd4f58df2c796ddb4c1d24c04bead9c45b39d643 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 19 Apr 2022 12:15:20 -0400
Subject: [PATCH 05/52] Altered impl_struct to accept a custom constructor for
 compatibility with non-default non-constructible foreign types

---
 .../bevy_reflect_derive/src/from_reflect.rs   | 30 +++++++++++++++----
 .../bevy_reflect_derive/src/lib.rs            | 19 +++++++++++-
 crates/bevy_reflect/src/impls/glam.rs         |  7 +++++
 3 files changed, 50 insertions(+), 6 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
index b9b2ffd37672b..2a8830607e4b9 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
+++ b/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,17 +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() {
-                    let mut value: Self = Default::default();
-                    #(
-                        value.#field_idents = <#field_types as #bevy_reflect_path::FromReflect>::from_reflect(ref_struct.field(#field_names)?)?;
-                    )*
-                    Some(value)
+                    #ctor
                 } else {
                     None
                 }
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index c83caf7d0f5bc..09c57da7eed50 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -577,6 +577,21 @@ 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();
+    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 input = iter.collect();
+
     let ast = parse_macro_input!(input as DeriveInput);
 
     let bevy_reflect_path = BevyManifest::default().get_path("bevy_reflect");
@@ -675,7 +690,8 @@ pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenS
         generics, 
         &bevy_reflect_path, 
         &active_fields, 
-        &ignored_fields
+        &ignored_fields,
+        Some(ctor)
     ).into();
 
     quote!(
@@ -940,6 +956,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,
diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index d1700108cc4c9..5e7cc4196dfef 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -31,6 +31,7 @@ impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize));
 */
 
 impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
     struct IVec2 {
         x: i32,
         y: i32
@@ -38,6 +39,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 
 impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
     struct Vec3 {
         x: f32,
         y: f32,
@@ -85,4 +87,9 @@ fn temp_test() {
         bevy_reflect::ReflectRef::Struct(s) => s.field("x").unwrap().downcast_ref::<f32>().unwrap() == &12.0,
         _ => false
     });
+
+    use bevy_reflect::FromReflect;
+    let v2 = Vec3::from_reflect(refl).unwrap();
+
+    assert_eq!(v2.x, 12.0);
 }
\ No newline at end of file

From 9a9aaf69b0bb45c9a6ec7cefe02f866661db28c7 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 19 Apr 2022 13:55:37 -0400
Subject: [PATCH 06/52] Verified trait reflection

---
 crates/bevy_reflect/src/impls/glam.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 5e7cc4196dfef..35c850b5bf74c 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -32,6 +32,7 @@ impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize));
 
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
     struct IVec2 {
         x: i32,
         y: i32
@@ -40,6 +41,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
     struct Vec3 {
         x: f32,
         y: f32,
@@ -73,10 +75,7 @@ fn temp_test() {
 
     let refl: &dyn Reflect = &v;
 
-    assert!(match refl.reflect_ref() {
-        bevy_reflect::ReflectRef::Struct(_) => true,
-        _ => false,
-    });
+    assert!(matches!(refl.reflect_ref(), bevy_reflect::ReflectRef::Struct(_)));
 
     assert!(match refl.reflect_ref() {
         bevy_reflect::ReflectRef::Struct(s) => s.field("x").is_some(),
@@ -92,4 +91,6 @@ fn temp_test() {
     let v2 = Vec3::from_reflect(refl).unwrap();
 
     assert_eq!(v2.x, 12.0);
+
+    assert!(refl.reflect_partial_eq(&v2).is_some() && refl.reflect_partial_eq(&v2).unwrap())
 }
\ No newline at end of file

From 401fe37c8762ee2eeeb105c7ec459e81e829a328 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 19 Apr 2022 14:29:51 -0400
Subject: [PATCH 07/52] Switched all (less quats) impls to structs

---
 crates/bevy_reflect/src/impls/glam.rs | 195 ++++++++++++++++++++------
 1 file changed, 149 insertions(+), 46 deletions(-)

diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 35c850b5bf74c..e0fb482fa37cb 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -1,35 +1,9 @@
 use crate as bevy_reflect;
 use crate::ReflectDeserialize;
 use crate::reflect::Reflect;
-use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value, impl_reflect_struct_and_from_reflect_struct};
+use bevy_reflect_derive::{impl_reflect_value, impl_reflect_struct_and_from_reflect_struct};
 use glam::*;
 
-// impl_reflect_value!(IVec2(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(IVec3(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(IVec4(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(UVec2(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(UVec3(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(UVec4(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(Vec2(PartialEq, Serialize, Deserialize));
-// impl_reflect_value!(Vec3(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(Vec3A(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(Vec4(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(DVec2(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(DVec3(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(DVec4(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(Mat3(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(Mat4(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(Quat(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(DMat3(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(DMat4(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize));
-
-/*
-==========================
-|     Updated impls      |
-==========================
-*/
-
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
     #[reflect(PartialEq, Serialize, Deserialize)]
@@ -38,7 +12,62 @@ impl_reflect_struct_and_from_reflect_struct!(
         y: i32
     }
 );
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct IVec3 {
+        x: i32,
+        y: i32,
+        z: i32
+    }
+);
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct IVec4 {
+        x: i32,
+        y: i32,
+        z: i32,
+        w: i32
+    }
+);
 
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct UVec2 {
+        x: u32,
+        y: u32
+    }
+);
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct UVec3 {
+        x: u32,
+        y: u32,
+        z: u32
+    }
+);
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct UVec4 {
+        x: u32,
+        y: u32,
+        z: u32,
+        w: u32
+    }
+);
+
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct Vec2 {
+        x: f32,
+        y: f32
+    }
+);
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
     #[reflect(PartialEq, Serialize, Deserialize)]
@@ -48,26 +77,100 @@ impl_reflect_struct_and_from_reflect_struct!(
         z: f32
     }
 );
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct Vec3A {
+        x: f32,
+        y: f32,
+        z: f32
+    }
+);
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct Vec4 {
+        x: f32,
+        y: f32,
+        z: f32,
+        w: f32
+    }
+);
+
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct DVec2 {
+        x: f64,
+        y: f64
+    }
+);
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct DVec3 {
+        x: f64,
+        y: f64,
+        z: f64
+    }
+);
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct DVec4 {
+        x: f64,
+        y: f64,
+        z: f64,
+        w: f64
+    }
+);
+
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct Mat3 {
+        x_axis: Vec3,
+        y_axis: Vec3,
+        z_axis: Vec3
+    }
+);
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct Mat4 {
+        x_axis: Vec4,
+        y_axis: Vec4,
+        z_axis: Vec4,
+        w_axis: Vec4
+    }
+);
 
-// impl_from_reflect_value!(IVec2);
-impl_from_reflect_value!(IVec3);
-impl_from_reflect_value!(IVec4);
-impl_from_reflect_value!(UVec2);
-impl_from_reflect_value!(UVec3);
-impl_from_reflect_value!(UVec4);
-impl_from_reflect_value!(Vec2);
-// impl_from_reflect_value!(Vec3);
-impl_from_reflect_value!(Vec4);
-impl_from_reflect_value!(Vec3A);
-impl_from_reflect_value!(DVec2);
-impl_from_reflect_value!(DVec3);
-impl_from_reflect_value!(DVec4);
-impl_from_reflect_value!(Mat3);
-impl_from_reflect_value!(Mat4);
-impl_from_reflect_value!(Quat);
-impl_from_reflect_value!(DMat3);
-impl_from_reflect_value!(DMat4);
-impl_from_reflect_value!(DQuat);
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct DMat3 {
+        x_axis: DVec3,
+        y_axis: DVec3,
+        z_axis: DVec3
+    }
+);
+impl_reflect_struct_and_from_reflect_struct!(
+    Constructor(Default::default())
+    #[reflect(PartialEq, Serialize, Deserialize)]
+    struct DMat4 {
+        x_axis: DVec4,
+        y_axis: DVec4,
+        z_axis: DVec4,
+        w_axis: DVec4
+    }
+);
+
+// Quat fields are read-only (as of now), and reflection is currently missing 
+// mechanisms for read-only fields. I doubt those mechanisms would be added,
+// so for now quaternions will remain as values. They are represented identically
+// to Vec4 and DVec4, so you may use those instead and convert between.
+impl_reflect_value!(Quat(PartialEq, Serialize, Deserialize));
+impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize));
 
 #[test]
 fn temp_test() {

From 6592abe22f729d5da1840879789156accf6610df Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 19 Apr 2022 14:30:02 -0400
Subject: [PATCH 08/52] Removed messy temp test

---
 crates/bevy_reflect/src/impls/glam.rs | 28 +--------------------------
 1 file changed, 1 insertion(+), 27 deletions(-)

diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index e0fb482fa37cb..d6c0e4af23381 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -170,30 +170,4 @@ impl_reflect_struct_and_from_reflect_struct!(
 // so for now quaternions will remain as values. They are represented identically
 // to Vec4 and DVec4, so you may use those instead and convert between.
 impl_reflect_value!(Quat(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize));
-
-#[test]
-fn temp_test() {
-    let v = vec3(12.0, 0.0, 0.0);
-
-    let refl: &dyn Reflect = &v;
-
-    assert!(matches!(refl.reflect_ref(), bevy_reflect::ReflectRef::Struct(_)));
-
-    assert!(match refl.reflect_ref() {
-        bevy_reflect::ReflectRef::Struct(s) => s.field("x").is_some(),
-        _ => false
-    });
-
-    assert!(match refl.reflect_ref() {
-        bevy_reflect::ReflectRef::Struct(s) => s.field("x").unwrap().downcast_ref::<f32>().unwrap() == &12.0,
-        _ => false
-    });
-
-    use bevy_reflect::FromReflect;
-    let v2 = Vec3::from_reflect(refl).unwrap();
-
-    assert_eq!(v2.x, 12.0);
-
-    assert!(refl.reflect_partial_eq(&v2).is_some() && refl.reflect_partial_eq(&v2).unwrap())
-}
\ No newline at end of file
+impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize));
\ No newline at end of file

From ac61dd2df68f4c0b0892ebb1897bc966fd21b05a Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 19 Apr 2022 14:58:49 -0400
Subject: [PATCH 09/52] Ran cargo fmt

---
 .../bevy_reflect_derive/src/from_reflect.rs   |  2 +-
 .../bevy_reflect_derive/src/lib.rs            | 50 ++++++++++---------
 crates/bevy_reflect/src/impls/glam.rs         |  8 +--
 3 files changed, 31 insertions(+), 29 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
index 2a8830607e4b9..ed2d8f7a12397 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
@@ -8,7 +8,7 @@ pub fn impl_struct(
     bevy_reflect_path: &Path,
     active_fields: &[(&Field, usize)],
     ignored_fields: &[(&Field, usize)],
-    custom_ctor: Option<proc_macro2::TokenStream>
+    custom_ctor: Option<proc_macro2::TokenStream>,
 ) -> TokenStream {
     let field_names = active_fields
         .iter()
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 09c57da7eed50..1e4703506fb23 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -580,15 +580,18 @@ pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenS
     let mut iter = input.into_iter();
     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")
+        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();
+        _ => panic!("Invalid constructor syntax"),
+    }
+    .into();
 
     let input = iter.collect();
 
@@ -601,7 +604,7 @@ pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenS
         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!()
+        _ => unimplemented!(),
     };
     let fields = &data.fields;
     let fields_and_args = fields
@@ -669,12 +672,8 @@ pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenS
     }
 
     let registration_data = &reflect_attrs.data;
-    let get_type_registration_impl = impl_get_type_registration(
-        ident,
-        &bevy_reflect_path,
-        registration_data,
-        generics,
-    );
+    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,
@@ -682,23 +681,26 @@ pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenS
         &get_type_registration_impl,
         &bevy_reflect_path,
         &reflect_attrs,
-        &active_fields
-    ).into();
+        &active_fields,
+    )
+    .into();
 
     let impl_from_struct: proc_macro2::TokenStream = from_reflect::impl_struct(
-        ident, 
-        generics, 
-        &bevy_reflect_path, 
-        &active_fields, 
+        ident,
+        generics,
+        &bevy_reflect_path,
+        &active_fields,
         &ignored_fields,
-        Some(ctor)
-    ).into();
+        Some(ctor),
+    )
+    .into();
 
     quote!(
         #impl_struct
 
         #impl_from_struct
-    ).into()
+    )
+    .into()
 }
 
 #[derive(Default)]
@@ -956,7 +958,7 @@ pub fn derive_from_reflect(input: TokenStream) -> TokenStream {
             &bevy_reflect_path,
             &active_fields,
             &ignored_fields,
-            None
+            None,
         ),
         DeriveType::TupleStruct => from_reflect::impl_tuple_struct(
             type_name,
@@ -976,4 +978,4 @@ pub fn impl_from_reflect_value(input: TokenStream) -> TokenStream {
     let bevy_reflect_path = BevyManifest::default().get_path("bevy_reflect");
     let ty = &reflect_value_def.type_name;
     from_reflect::impl_value(ty, &reflect_value_def.generics, &bevy_reflect_path)
-}
\ No newline at end of file
+}
diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index d6c0e4af23381..95fe81956402f 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -1,7 +1,7 @@
 use crate as bevy_reflect;
-use crate::ReflectDeserialize;
 use crate::reflect::Reflect;
-use bevy_reflect_derive::{impl_reflect_value, impl_reflect_struct_and_from_reflect_struct};
+use crate::ReflectDeserialize;
+use bevy_reflect_derive::{impl_reflect_struct_and_from_reflect_struct, impl_reflect_value};
 use glam::*;
 
 impl_reflect_struct_and_from_reflect_struct!(
@@ -165,9 +165,9 @@ impl_reflect_struct_and_from_reflect_struct!(
     }
 );
 
-// Quat fields are read-only (as of now), and reflection is currently missing 
+// Quat fields are read-only (as of now), and reflection is currently missing
 // mechanisms for read-only fields. I doubt those mechanisms would be added,
 // so for now quaternions will remain as values. They are represented identically
 // to Vec4 and DVec4, so you may use those instead and convert between.
 impl_reflect_value!(Quat(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize));
\ No newline at end of file
+impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize));

From 44b06ba5e200b55cf795f487147af10f7506ca61 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Wed, 20 Apr 2022 11:10:38 -0400
Subject: [PATCH 10/52] Added bevy_reflect path override To address issues
 where `use bevy_reflect::Struct` is ambiguous when called from bevy_reflect

---
 .../bevy_reflect_derive/src/lib.rs            | 25 +++++++++++++++++--
 crates/bevy_reflect/src/impls/glam.rs         | 17 +++++++++++++
 2 files changed, 40 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 1e4703506fb23..647b92681d154 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -577,7 +577,7 @@ 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();
+    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) => {
@@ -593,11 +593,32 @@ pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenS
     }
     .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 = BevyManifest::default().get_path("bevy_reflect");
+    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 {
diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 95fe81956402f..78629755d9547 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -6,6 +6,7 @@ use glam::*;
 
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct IVec2 {
         x: i32,
@@ -14,6 +15,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct IVec3 {
         x: i32,
@@ -23,6 +25,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct IVec4 {
         x: i32,
@@ -34,6 +37,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct UVec2 {
         x: u32,
@@ -42,6 +46,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct UVec3 {
         x: u32,
@@ -51,6 +56,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct UVec4 {
         x: u32,
@@ -62,6 +68,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct Vec2 {
         x: f32,
@@ -70,6 +77,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct Vec3 {
         x: f32,
@@ -79,6 +87,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct Vec3A {
         x: f32,
@@ -88,6 +97,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct Vec4 {
         x: f32,
@@ -99,6 +109,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct DVec2 {
         x: f64,
@@ -107,6 +118,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct DVec3 {
         x: f64,
@@ -116,6 +128,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct DVec4 {
         x: f64,
@@ -127,6 +140,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct Mat3 {
         x_axis: Vec3,
@@ -136,6 +150,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct Mat4 {
         x_axis: Vec4,
@@ -147,6 +162,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct DMat3 {
         x_axis: DVec3,
@@ -156,6 +172,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 impl_reflect_struct_and_from_reflect_struct!(
     Constructor(Default::default())
+    BevyReflectPath(self::bevy_reflect)
     #[reflect(PartialEq, Serialize, Deserialize)]
     struct DMat4 {
         x_axis: DVec4,

From b584f14fb7a2083d8ff1426e431ce619083432e5 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 21 Apr 2022 12:55:37 -0400
Subject: [PATCH 11/52] Restored `impl_from_reflect_value` for Quat/DQuat

---
 crates/bevy_reflect/src/impls/glam.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 78629755d9547..48a3f8c9f7192 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -188,3 +188,6 @@ impl_reflect_struct_and_from_reflect_struct!(
 // to Vec4 and DVec4, so you may use those instead and convert between.
 impl_reflect_value!(Quat(PartialEq, Serialize, Deserialize));
 impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize));
+
+impl_from_reflect_value!(Quat);
+impl_from_reflect_value!(DQuat);
\ No newline at end of file

From fb4c12e51d19a313edaad8da5f12d479b33843c6 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 21 Apr 2022 13:01:37 -0400
Subject: [PATCH 12/52] Added use for impl_from_reflect_value

---
 crates/bevy_reflect/src/impls/glam.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 48a3f8c9f7192..7cc74976e491f 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -1,7 +1,7 @@
 use crate as bevy_reflect;
 use crate::reflect::Reflect;
 use crate::ReflectDeserialize;
-use bevy_reflect_derive::{impl_reflect_struct_and_from_reflect_struct, impl_reflect_value};
+use bevy_reflect_derive::{impl_reflect_struct_and_from_reflect_struct, impl_reflect_value, impl_from_reflect_value};
 use glam::*;
 
 impl_reflect_struct_and_from_reflect_struct!(

From 1bdefbf59197767a07708146f8ebf514987f1121 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 21 Apr 2022 13:11:17 -0400
Subject: [PATCH 13/52] Ran cargo fmt again

---
 crates/bevy_reflect/src/impls/glam.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 7cc74976e491f..0336d1bd8b5c8 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -1,7 +1,9 @@
 use crate as bevy_reflect;
 use crate::reflect::Reflect;
 use crate::ReflectDeserialize;
-use bevy_reflect_derive::{impl_reflect_struct_and_from_reflect_struct, impl_reflect_value, impl_from_reflect_value};
+use bevy_reflect_derive::{
+    impl_from_reflect_value, impl_reflect_struct_and_from_reflect_struct, impl_reflect_value,
+};
 use glam::*;
 
 impl_reflect_struct_and_from_reflect_struct!(
@@ -190,4 +192,4 @@ impl_reflect_value!(Quat(PartialEq, Serialize, Deserialize));
 impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize));
 
 impl_from_reflect_value!(Quat);
-impl_from_reflect_value!(DQuat);
\ No newline at end of file
+impl_from_reflect_value!(DQuat);

From c5d8ce1f40f51571189fb265610687a98eb5290d Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Sat, 23 Apr 2022 16:19:57 -0400
Subject: [PATCH 14/52] Added tests for Vec3 serialization behavior

---
 crates/bevy_reflect/src/lib.rs | 55 ++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
index cd479d1e07dec..dfa827b61d5ae 100644
--- a/crates/bevy_reflect/src/lib.rs
+++ b/crates/bevy_reflect/src/lib.rs
@@ -50,7 +50,10 @@ pub use erased_serde;
 #[allow(clippy::blacklisted_name, clippy::approx_constant)]
 mod tests {
     use ::serde::de::DeserializeSeed;
+    use ::serde::Serialize;
     use bevy_utils::HashMap;
+    #[cfg(feature = "glam")]
+    use ::glam::{vec3, Vec3};
     use ron::{
         ser::{to_string_pretty, PrettyConfig},
         Deserializer,
@@ -423,4 +426,56 @@ mod tests {
             std::any::type_name::<TestTupleStruct>()
         );
     }
+
+    #[cfg(feature = "glam")]
+    mod glam {
+        use super::*;
+
+        #[test]
+        fn vec3_serialization() {
+            let v = vec3(12.0, 3.0, -6.9);
+
+            let mut registry = TypeRegistry::default();
+            registry.add_registration(Vec3::get_type_registration());
+
+            let ser = ReflectSerializer::new(&v, &registry);
+
+            let mut dest = vec![];
+            let mut serializer = ron::ser::Serializer::new(&mut dest, None, false)
+                .expect("Failed to acquire serializer");
+
+            ser.serialize(&mut serializer).expect("Failed to serialize");
+
+            let result = String::from_utf8(dest).expect("Failed to convert to string");
+
+            assert_eq!(
+                result,
+                r#"{"type":"glam::vec3::Vec3","struct":{"x":{"type":"f32","value":12},"y":{"type":"f32","value":3},"z":{"type":"f32","value":-6.9}}}"#
+            );
+        }
+
+        #[test]
+        fn vec3_deserialization() {
+            let data = r#"{"type":"glam::vec3::Vec3","struct":{"x":{"type":"f32","value":12},"y":{"type":"f32","value":3},"z":{"type":"f32","value":-6.9}}}"#;
+
+            let mut registry = TypeRegistry::default();
+            registry.add_registration(Vec3::get_type_registration());
+            registry.add_registration(f32::get_type_registration());
+
+            let de = ReflectDeserializer::new(&registry);
+
+            let mut deserializer =
+                ron::de::Deserializer::from_str(data).expect("Failed to acquire deserializer");
+
+            let dynamic_struct = de
+                .deserialize(&mut deserializer)
+                .expect("Failed to deserialize");
+
+            let mut result = Vec3::default();
+
+            result.apply(&*dynamic_struct);
+            
+            assert_eq!(result, vec3(12.0, 3.0, -6.9));
+        }
+    }
 }

From ed5372f8305130e6f0f5ca07b808aab0399147ac Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Sat, 23 Apr 2022 16:30:53 -0400
Subject: [PATCH 15/52] Ran cargo fmt --all

---
 crates/bevy_reflect/src/lib.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
index dfa827b61d5ae..38568a7907ad5 100644
--- a/crates/bevy_reflect/src/lib.rs
+++ b/crates/bevy_reflect/src/lib.rs
@@ -49,11 +49,11 @@ pub use erased_serde;
 #[cfg(test)]
 #[allow(clippy::blacklisted_name, clippy::approx_constant)]
 mod tests {
+    #[cfg(feature = "glam")]
+    use ::glam::{vec3, Vec3};
     use ::serde::de::DeserializeSeed;
     use ::serde::Serialize;
     use bevy_utils::HashMap;
-    #[cfg(feature = "glam")]
-    use ::glam::{vec3, Vec3};
     use ron::{
         ser::{to_string_pretty, PrettyConfig},
         Deserializer,
@@ -474,8 +474,10 @@ mod tests {
             let mut result = Vec3::default();
 
             result.apply(&*dynamic_struct);
-            
+
             assert_eq!(result, vec3(12.0, 3.0, -6.9));
         }
+
+        // Tests: Paths, Dynamic Construction,
     }
 }

From 44f66c93ae10d183529f6a72045cfc8ab3237757 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Mon, 25 Apr 2022 13:15:36 -0400
Subject: [PATCH 16/52] Split parsing into a separate Parse struct

---
 .../bevy_reflect_derive/src/lib.rs            | 160 ++++++++++--------
 1 file changed, 90 insertions(+), 70 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 647b92681d154..85f9b5eeaeb15 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -575,59 +575,94 @@ 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")
+struct ReflectStructDef {
+    type_name: Ident,
+    generics: Generics,
+    attrs: ReflectAttrs,
+    fields: Fields,
+    ctor: Option<proc_macro2::TokenStream>,
+    path: Path,
+}
+
+impl Parse for ReflectStructDef {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let mut ctor = None;
+        let mut path = None;
+        while input.fork().peek(Ident) {
+            let ident = input.parse::<Ident>().unwrap();
+            match &ident.to_string()[..] {
+                "Constructor" => {
+                    let ctor_group = input
+                        .parse::<proc_macro2::Group>()
+                        .expect("Invalid constructor syntax");
+
+                    ctor = Some(ctor_group.stream());
+                }
+                "BevyReflectPath" => {
+                    let path_group = input
+                        .parse::<proc_macro2::Group>()
+                        .expect("Invalid path override syntax");
+
+                    path = Some(path_group.stream());
+                }
+                _ => (),
             }
         }
-        _ => 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!"),
-            })
+        let path = if let Some(path) = path {
+            syn::parse(path.into()).expect("Invalid BevyReflectPath override!")
         } else {
-            None
+            BevyManifest::default().get_path("bevy_reflect")
+        };
+
+        let ast = input.parse::<DeriveInput>()?;
+
+        let type_name = ast.ident;
+        let generics = ast.generics;
+        let fields = match ast.data {
+            Data::Struct(data) => data.fields,
+            // I don't believe enum reflection is implemented right now,
+            // and unions are likely not going to be reflected.
+            _ => unimplemented!(),
+        };
+
+        let mut 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 {
+                    attrs = ReflectAttrs::from_nested_metas(&meta_list.nested);
+                }
+            }
         }
-    } else {
-        None
-    };
 
-    let input = iter.collect();
+        Ok(Self {
+            type_name,
+            generics,
+            attrs,
+            fields,
+            ctor,
+            path,
+        })
+    }
+}
 
-    let ast = parse_macro_input!(input as DeriveInput);
+#[proc_macro]
+pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenStream {
+    let ReflectStructDef {
+        type_name,
+        generics,
+        attrs,
+        fields,
+        ctor,
+        path,
+    } = parse_macro_input!(input as ReflectStructDef);
 
-    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()
@@ -677,42 +712,27 @@ pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenS
         .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 registration_data = &attrs.data;
     let get_type_registration_impl =
-        impl_get_type_registration(ident, &bevy_reflect_path, registration_data, generics);
+        impl_get_type_registration(&type_name, &path, registration_data, &generics);
 
     let impl_struct: proc_macro2::TokenStream = impl_struct(
-        ident,
-        generics,
+        &type_name,
+        &generics,
         &get_type_registration_impl,
-        &bevy_reflect_path,
-        &reflect_attrs,
+        &path,
+        &attrs,
         &active_fields,
     )
     .into();
 
     let impl_from_struct: proc_macro2::TokenStream = from_reflect::impl_struct(
-        ident,
-        generics,
-        &bevy_reflect_path,
+        &type_name,
+        &generics,
+        &path,
         &active_fields,
         &ignored_fields,
-        Some(ctor),
+        ctor,
     )
     .into();
 

From b6c196e10c5539c691d7601095c79e059aefd5bf Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Mon, 25 Apr 2022 15:08:56 -0400
Subject: [PATCH 17/52] Added tests for Vec3 reflection behavior

---
 crates/bevy_reflect/src/lib.rs | 36 +++++++++++++++++++++++++++++++++-
 1 file changed, 35 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
index 38568a7907ad5..c75fe4029ca43 100644
--- a/crates/bevy_reflect/src/lib.rs
+++ b/crates/bevy_reflect/src/lib.rs
@@ -478,6 +478,40 @@ mod tests {
             assert_eq!(result, vec3(12.0, 3.0, -6.9));
         }
 
-        // Tests: Paths, Dynamic Construction,
+        #[test]
+        fn vec3_field_access() {
+            let mut v = vec3(1.0, 2.0, 3.0);
+
+            assert_eq!(*v.get_field::<f32>("x").unwrap(), 1.0);
+
+            *v.get_field_mut::<f32>("y").unwrap() = 6.0;
+
+            assert_eq!(v.y, 6.0);
+        }
+
+        #[test]
+        fn vec3_path_access() {
+            let mut v = vec3(1.0, 2.0, 3.0);
+
+            assert_eq!(*v.path("x").unwrap().downcast_ref::<f32>().unwrap(), 1.0);
+
+            *v.path_mut("y").unwrap().downcast_mut::<f32>().unwrap() = 6.0;
+
+            assert_eq!(v.y, 6.0);
+        }
+
+        #[test]
+        fn vec3_apply_dynamic() {
+            let mut v = vec3(3.0, 3.0, 3.0);
+
+            let mut d = DynamicStruct::default();
+            d.insert("x", 4.0f32);
+            d.insert("y", 2.0f32);
+            d.insert("z", 1.0f32);
+
+            v.apply(&d);
+
+            assert_eq!(v, vec3(4.0, 2.0, 1.0));
+        }
     }
 }

From 1e7cd551cd6c88e51391c454a9e971bd11a9e3ee Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 26 Apr 2022 09:43:59 -0400
Subject: [PATCH 18/52] Added docstrings to ReflectStructDef and
 impl_reflect_struct_and_from_reflect_struct

---
 .../bevy_reflect_derive/src/lib.rs            | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 454a95482e1ee..b0e6f4aaae94d 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -607,6 +607,24 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
     )
 }
 
+/// Represents the information needed to implement a type as a Reflect Struct. 
+/// TODO: Update this docstring as other suggestions are added
+/// ## Example
+/// ```
+/// impl_reflect_struct_and_from_reflect_struct!(
+///    Constructor(Default::default()) // << ctor
+///    BevyReflectPath(self::bevy_reflect) // << path
+///    #[reflect(PartialEq, Serialize, Deserialize)] // << attrs
+///    //   type_name generics 
+///    //      vvv      vvv
+///    //     |---||----------|
+///    struct Thing<T1, T2, T3> {
+///        x: T1, // ]
+///        y: T2, // |- fields 
+///        z: T3  // ]
+///    }
+/// );
+/// ```
 struct ReflectStructDef {
     type_name: Ident,
     generics: Generics,
@@ -684,6 +702,24 @@ impl Parse for ReflectStructDef {
     }
 }
 
+/// A replacement for #\[derive(Reflect)] to be used with foreign types which
+/// the definitions of cannot be altered. It is an alternative to [impl_reflect_value] and
+/// [impl_from_reflect_value] which implement foreign types as Value types. This macro 
+/// implements them as Struct types, which have greater functionality.
+/// TODO: update this example as the other suggestions are added
+/// ## Example 
+/// ```
+/// impl_reflect_struct_and_from_reflect_struct!(
+///    Constructor(Default::default())
+///    BevyReflectPath(self::bevy_reflect)
+///    #[reflect(PartialEq, Serialize, Deserialize)]
+///    struct Vec3 {
+///        x: f32,
+///        y: f32,
+///        z: f32
+///    }
+/// );
+/// ```
 #[proc_macro]
 pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenStream {
     let ReflectStructDef {

From 080971d35d5f0abf039a96b498bc8806cc2396f9 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 26 Apr 2022 10:33:58 -0400
Subject: [PATCH 19/52] Fixed parsing issue

---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index b0e6f4aaae94d..f9d6abe40881c 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -639,9 +639,11 @@ impl Parse for ReflectStructDef {
         let mut ctor = None;
         let mut path = None;
         while input.fork().peek(Ident) {
-            let ident = input.parse::<Ident>().unwrap();
+            let ident = input.fork().parse::<Ident>().unwrap();
             match &ident.to_string()[..] {
                 "Constructor" => {
+                    input.parse::<Ident>().unwrap();
+
                     let ctor_group = input
                         .parse::<proc_macro2::Group>()
                         .expect("Invalid constructor syntax");
@@ -649,6 +651,8 @@ impl Parse for ReflectStructDef {
                     ctor = Some(ctor_group.stream());
                 }
                 "BevyReflectPath" => {
+                    input.parse::<Ident>().unwrap();
+
                     let path_group = input
                         .parse::<proc_macro2::Group>()
                         .expect("Invalid path override syntax");

From db1cd6026ad74365df345f59a665b662ed51d09d Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 26 Apr 2022 10:40:34 -0400
Subject: [PATCH 20/52] Updated parsing to use custom_keyword!()

---
 .../bevy_reflect_derive/src/lib.rs            | 33 +++++++++----------
 1 file changed, 15 insertions(+), 18 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index f9d6abe40881c..b8606568f5e8c 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -638,28 +638,25 @@ impl Parse for ReflectStructDef {
     fn parse(input: ParseStream) -> syn::Result<Self> {
         let mut ctor = None;
         let mut path = None;
-        while input.fork().peek(Ident) {
-            let ident = input.fork().parse::<Ident>().unwrap();
-            match &ident.to_string()[..] {
-                "Constructor" => {
-                    input.parse::<Ident>().unwrap();
 
-                    let ctor_group = input
-                        .parse::<proc_macro2::Group>()
-                        .expect("Invalid constructor syntax");
+        syn::custom_keyword!(Constructor);
+        syn::custom_keyword!(BevyReflectPath);
 
-                    ctor = Some(ctor_group.stream());
-                }
-                "BevyReflectPath" => {
-                    input.parse::<Ident>().unwrap();
+        loop {
+            if input.parse::<Constructor>().is_ok() {
+                let ctor_group = input
+                .parse::<proc_macro2::Group>()
+                .expect("Invalid constructor syntax");
 
-                    let path_group = input
-                        .parse::<proc_macro2::Group>()
-                        .expect("Invalid path override syntax");
+                ctor = Some(ctor_group.stream());
+            } else if input.parse::<BevyReflectPath>().is_ok() {
+                let path_group = input
+                .parse::<proc_macro2::Group>()
+                .expect("Invalid path override syntax");
 
-                    path = Some(path_group.stream());
-                }
-                _ => (),
+                path = Some(path_group.stream());
+            } else {
+                break;
             }
         }
 

From b83578a32ac9d526e871664f35406b1395410457 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 26 Apr 2022 11:19:03 -0400
Subject: [PATCH 21/52] Ran cargo fmt --all

---
 .../bevy_reflect_derive/src/lib.rs             | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index b8606568f5e8c..7707ad38209ed 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -607,7 +607,7 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
     )
 }
 
-/// Represents the information needed to implement a type as a Reflect Struct. 
+/// Represents the information needed to implement a type as a Reflect Struct.
 /// TODO: Update this docstring as other suggestions are added
 /// ## Example
 /// ```
@@ -615,12 +615,12 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
 ///    Constructor(Default::default()) // << ctor
 ///    BevyReflectPath(self::bevy_reflect) // << path
 ///    #[reflect(PartialEq, Serialize, Deserialize)] // << attrs
-///    //   type_name generics 
+///    //   type_name generics
 ///    //      vvv      vvv
 ///    //     |---||----------|
 ///    struct Thing<T1, T2, T3> {
 ///        x: T1, // ]
-///        y: T2, // |- fields 
+///        y: T2, // |- fields
 ///        z: T3  // ]
 ///    }
 /// );
@@ -645,14 +645,14 @@ impl Parse for ReflectStructDef {
         loop {
             if input.parse::<Constructor>().is_ok() {
                 let ctor_group = input
-                .parse::<proc_macro2::Group>()
-                .expect("Invalid constructor syntax");
+                    .parse::<proc_macro2::Group>()
+                    .expect("Invalid constructor syntax");
 
                 ctor = Some(ctor_group.stream());
             } else if input.parse::<BevyReflectPath>().is_ok() {
                 let path_group = input
-                .parse::<proc_macro2::Group>()
-                .expect("Invalid path override syntax");
+                    .parse::<proc_macro2::Group>()
+                    .expect("Invalid path override syntax");
 
                 path = Some(path_group.stream());
             } else {
@@ -705,10 +705,10 @@ impl Parse for ReflectStructDef {
 
 /// A replacement for #\[derive(Reflect)] to be used with foreign types which
 /// the definitions of cannot be altered. It is an alternative to [impl_reflect_value] and
-/// [impl_from_reflect_value] which implement foreign types as Value types. This macro 
+/// [impl_from_reflect_value] which implement foreign types as Value types. This macro
 /// implements them as Struct types, which have greater functionality.
 /// TODO: update this example as the other suggestions are added
-/// ## Example 
+/// ## Example
 /// ```
 /// impl_reflect_struct_and_from_reflect_struct!(
 ///    Constructor(Default::default())

From 7f46274c9622918f318a42c7232352796c2ee213 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 26 Apr 2022 11:24:11 -0400
Subject: [PATCH 22/52] Added panics for enum and union cases

---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 7707ad38209ed..651cf64309f5d 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -672,9 +672,8 @@ impl Parse for ReflectStructDef {
         let generics = ast.generics;
         let fields = match ast.data {
             Data::Struct(data) => data.fields,
-            // I don't believe enum reflection is implemented right now,
-            // and unions are likely not going to be reflected.
-            _ => unimplemented!(),
+            Data::Enum(_) => panic!("Enums are not currently supported for reflection"),
+            Data::Union(_) => panic!("Unions are not supported for reflection")
         };
 
         let mut attrs = ReflectAttrs::default();

From a42f5f06ef60e46a624fcc64b041dc90ddf902b0 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 26 Apr 2022 19:42:35 -0400
Subject: [PATCH 23/52] Switched to attribute-based overrides

---
 .../bevy_reflect_derive/src/lib.rs            | 102 +++++++++---------
 crates/bevy_reflect/src/impls/glam.rs         |  68 +++---------
 2 files changed, 69 insertions(+), 101 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 651cf64309f5d..2f37c2f99e153 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -608,20 +608,18 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
 }
 
 /// Represents the information needed to implement a type as a Reflect Struct.
-/// TODO: Update this docstring as other suggestions are added
 /// ## Example
 /// ```
 /// impl_reflect_struct_and_from_reflect_struct!(
-///    Constructor(Default::default()) // << ctor
-///    BevyReflectPath(self::bevy_reflect) // << path
-///    #[reflect(PartialEq, Serialize, Deserialize)] // << attrs
-///    //   type_name generics
-///    //      vvv      vvv
-///    //     |---||----------|
-///    struct Thing<T1, T2, T3> {
-///        x: T1, // ]
+///    //               path override                ctor override                       attrs
+///    //        |-------------------------|  |-------------------------|  |-------------------------------|
+///    #[reflect(path = "self::bevy_reflect", ctor = "Default::default()", PartialEq, Serialize, Deserialize)]
+///    //            type_name       generics
+///    //     |-------------------||----------|
+///    struct ThingThatImReflecting<T1, T2, T3> {
+///        x: T1, // |
 ///        y: T2, // |- fields
-///        z: T3  // ]
+///        z: T3  // |
 ///    }
 /// );
 /// ```
@@ -631,41 +629,11 @@ struct ReflectStructDef {
     attrs: ReflectAttrs,
     fields: Fields,
     ctor: Option<proc_macro2::TokenStream>,
-    path: Path,
+    bevy_reflect_path: Option<Path>,
 }
 
 impl Parse for ReflectStructDef {
     fn parse(input: ParseStream) -> syn::Result<Self> {
-        let mut ctor = None;
-        let mut path = None;
-
-        syn::custom_keyword!(Constructor);
-        syn::custom_keyword!(BevyReflectPath);
-
-        loop {
-            if input.parse::<Constructor>().is_ok() {
-                let ctor_group = input
-                    .parse::<proc_macro2::Group>()
-                    .expect("Invalid constructor syntax");
-
-                ctor = Some(ctor_group.stream());
-            } else if input.parse::<BevyReflectPath>().is_ok() {
-                let path_group = input
-                    .parse::<proc_macro2::Group>()
-                    .expect("Invalid path override syntax");
-
-                path = Some(path_group.stream());
-            } else {
-                break;
-            }
-        }
-
-        let path = if let Some(path) = path {
-            syn::parse(path.into()).expect("Invalid BevyReflectPath override!")
-        } else {
-            BevyManifest::default().get_path("bevy_reflect")
-        };
-
         let ast = input.parse::<DeriveInput>()?;
 
         let type_name = ast.ident;
@@ -676,6 +644,9 @@ impl Parse for ReflectStructDef {
             Data::Union(_) => panic!("Unions are not supported for reflection")
         };
 
+        let mut ctor = None;
+        let mut bevy_reflect_path = None;
+
         let mut 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 {
@@ -686,6 +657,28 @@ impl Parse for ReflectStructDef {
 
             if let Some(ident) = meta_list.path.get_ident() {
                 if ident == REFLECT_ATTRIBUTE_NAME || ident == REFLECT_VALUE_ATTRIBUTE_NAME {
+                    for name_val in meta_list.nested.iter().filter_map(|m| if let NestedMeta::Meta(Meta::NameValue(name_val)) = m { Some(name_val) } else { None }) {
+                        if let Some(syn::PathSegment { ident, arguments: _ }) = name_val.path.segments.first() {
+                            match &ident.to_string()[..] {
+                                "path" => {
+                                    let path_str = match &name_val.lit {
+                                        syn::Lit::Str(s) => s,
+                                        _ => panic!("Invalid path")
+                                    };
+                                    bevy_reflect_path = Some(path_str.parse::<Path>().expect("Invalid path"));
+                                },
+                                "ctor" => {
+                                    let ctor_str = match &name_val.lit {
+                                        syn::Lit::Str(s) => s,
+                                        _ => panic!("Invalid ctor")
+                                    };
+                                    ctor = Some(ctor_str.parse::<proc_macro2::TokenStream>().expect("Invalid ctor code"));
+                                },
+                                _ => ()
+                            }
+                        }
+                    }
+
                     attrs = ReflectAttrs::from_nested_metas(&meta_list.nested);
                 }
             }
@@ -697,7 +690,7 @@ impl Parse for ReflectStructDef {
             attrs,
             fields,
             ctor,
-            path,
+            bevy_reflect_path,
         })
     }
 }
@@ -706,13 +699,16 @@ impl Parse for ReflectStructDef {
 /// the definitions of cannot be altered. It is an alternative to [impl_reflect_value] and
 /// [impl_from_reflect_value] which implement foreign types as Value types. This macro
 /// implements them as Struct types, which have greater functionality.
-/// TODO: update this example as the other suggestions are added
+/// 
+/// The extra ctor tag allows overriding the default construction behavior, which is necessary
+/// for non-constructible foreign types, among other cases.
+/// 
+/// The extra path tag allows overriding the path used to access the bevy_reflect module, which
+/// can be helpful in certain edge cases of invocations of the macro.
 /// ## Example
 /// ```
 /// impl_reflect_struct_and_from_reflect_struct!(
-///    Constructor(Default::default())
-///    BevyReflectPath(self::bevy_reflect)
-///    #[reflect(PartialEq, Serialize, Deserialize)]
+///    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
 ///    struct Vec3 {
 ///        x: f32,
 ///        y: f32,
@@ -728,9 +724,15 @@ pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenS
         attrs,
         fields,
         ctor,
-        path,
+        bevy_reflect_path,
     } = parse_macro_input!(input as ReflectStructDef);
 
+    let bevy_reflect_path = if let Some(path) = bevy_reflect_path {
+        path
+    } else {
+        BevyManifest::default().get_path("bevy_reflect")
+    };
+
     let fields_and_args = fields
         .iter()
         .enumerate()
@@ -782,13 +784,13 @@ pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenS
 
     let registration_data = &attrs.data;
     let get_type_registration_impl =
-        impl_get_type_registration(&type_name, &path, registration_data, &generics);
+        impl_get_type_registration(&type_name, &bevy_reflect_path, registration_data, &generics);
 
     let impl_struct: proc_macro2::TokenStream = impl_struct(
         &type_name,
         &generics,
         &get_type_registration_impl,
-        &path,
+        &bevy_reflect_path,
         &attrs,
         &active_fields,
     )
@@ -797,7 +799,7 @@ pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenS
     let impl_from_struct: proc_macro2::TokenStream = from_reflect::impl_struct(
         &type_name,
         &generics,
-        &path,
+        &bevy_reflect_path,
         &active_fields,
         &ignored_fields,
         ctor,
diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 0336d1bd8b5c8..0207aa3e6d6df 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -7,18 +7,14 @@ use bevy_reflect_derive::{
 use glam::*;
 
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct IVec2 {
         x: i32,
         y: i32
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct IVec3 {
         x: i32,
         y: i32,
@@ -26,9 +22,7 @@ impl_reflect_struct_and_from_reflect_struct!(
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct IVec4 {
         x: i32,
         y: i32,
@@ -38,18 +32,14 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct UVec2 {
         x: u32,
         y: u32
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct UVec3 {
         x: u32,
         y: u32,
@@ -57,9 +47,7 @@ impl_reflect_struct_and_from_reflect_struct!(
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct UVec4 {
         x: u32,
         y: u32,
@@ -69,18 +57,14 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct Vec2 {
         x: f32,
         y: f32
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct Vec3 {
         x: f32,
         y: f32,
@@ -88,9 +72,7 @@ impl_reflect_struct_and_from_reflect_struct!(
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct Vec3A {
         x: f32,
         y: f32,
@@ -98,9 +80,7 @@ impl_reflect_struct_and_from_reflect_struct!(
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct Vec4 {
         x: f32,
         y: f32,
@@ -110,18 +90,14 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct DVec2 {
         x: f64,
         y: f64
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct DVec3 {
         x: f64,
         y: f64,
@@ -129,9 +105,7 @@ impl_reflect_struct_and_from_reflect_struct!(
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct DVec4 {
         x: f64,
         y: f64,
@@ -141,9 +115,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct Mat3 {
         x_axis: Vec3,
         y_axis: Vec3,
@@ -151,9 +123,7 @@ impl_reflect_struct_and_from_reflect_struct!(
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct Mat4 {
         x_axis: Vec4,
         y_axis: Vec4,
@@ -163,9 +133,7 @@ impl_reflect_struct_and_from_reflect_struct!(
 );
 
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct DMat3 {
         x_axis: DVec3,
         y_axis: DVec3,
@@ -173,9 +141,7 @@ impl_reflect_struct_and_from_reflect_struct!(
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    Constructor(Default::default())
-    BevyReflectPath(self::bevy_reflect)
-    #[reflect(PartialEq, Serialize, Deserialize)]
+    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
     struct DMat4 {
         x_axis: DVec4,
         y_axis: DVec4,

From 3ef21d947f9f5fae0988c2d8fd6caff90aee3b08 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 26 Apr 2022 19:43:00 -0400
Subject: [PATCH 24/52] Ran cargo fmt --all

---
 .../bevy_reflect_derive/src/lib.rs            |  39 ++--
 crates/bevy_reflect/src/impls/glam.rs         | 170 ++++++++++++++----
 2 files changed, 163 insertions(+), 46 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 2f37c2f99e153..8d11f37215dad 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -641,7 +641,7 @@ impl Parse for ReflectStructDef {
         let fields = match ast.data {
             Data::Struct(data) => data.fields,
             Data::Enum(_) => panic!("Enums are not currently supported for reflection"),
-            Data::Union(_) => panic!("Unions are not supported for reflection")
+            Data::Union(_) => panic!("Unions are not supported for reflection"),
         };
 
         let mut ctor = None;
@@ -657,24 +657,39 @@ impl Parse for ReflectStructDef {
 
             if let Some(ident) = meta_list.path.get_ident() {
                 if ident == REFLECT_ATTRIBUTE_NAME || ident == REFLECT_VALUE_ATTRIBUTE_NAME {
-                    for name_val in meta_list.nested.iter().filter_map(|m| if let NestedMeta::Meta(Meta::NameValue(name_val)) = m { Some(name_val) } else { None }) {
-                        if let Some(syn::PathSegment { ident, arguments: _ }) = name_val.path.segments.first() {
+                    for name_val in meta_list.nested.iter().filter_map(|m| {
+                        if let NestedMeta::Meta(Meta::NameValue(name_val)) = m {
+                            Some(name_val)
+                        } else {
+                            None
+                        }
+                    }) {
+                        if let Some(syn::PathSegment {
+                            ident,
+                            arguments: _,
+                        }) = name_val.path.segments.first()
+                        {
                             match &ident.to_string()[..] {
                                 "path" => {
                                     let path_str = match &name_val.lit {
                                         syn::Lit::Str(s) => s,
-                                        _ => panic!("Invalid path")
+                                        _ => panic!("Invalid path"),
                                     };
-                                    bevy_reflect_path = Some(path_str.parse::<Path>().expect("Invalid path"));
-                                },
+                                    bevy_reflect_path =
+                                        Some(path_str.parse::<Path>().expect("Invalid path"));
+                                }
                                 "ctor" => {
                                     let ctor_str = match &name_val.lit {
                                         syn::Lit::Str(s) => s,
-                                        _ => panic!("Invalid ctor")
+                                        _ => panic!("Invalid ctor"),
                                     };
-                                    ctor = Some(ctor_str.parse::<proc_macro2::TokenStream>().expect("Invalid ctor code"));
-                                },
-                                _ => ()
+                                    ctor = Some(
+                                        ctor_str
+                                            .parse::<proc_macro2::TokenStream>()
+                                            .expect("Invalid ctor code"),
+                                    );
+                                }
+                                _ => (),
                             }
                         }
                     }
@@ -699,10 +714,10 @@ impl Parse for ReflectStructDef {
 /// the definitions of cannot be altered. It is an alternative to [impl_reflect_value] and
 /// [impl_from_reflect_value] which implement foreign types as Value types. This macro
 /// implements them as Struct types, which have greater functionality.
-/// 
+///
 /// The extra ctor tag allows overriding the default construction behavior, which is necessary
 /// for non-constructible foreign types, among other cases.
-/// 
+///
 /// The extra path tag allows overriding the path used to access the bevy_reflect module, which
 /// can be helpful in certain edge cases of invocations of the macro.
 /// ## Example
diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 0207aa3e6d6df..f6eb27a08cde7 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -7,146 +7,248 @@ use bevy_reflect_derive::{
 use glam::*;
 
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct IVec2 {
         x: i32,
-        y: i32
+        y: i32,
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct IVec3 {
         x: i32,
         y: i32,
-        z: i32
+        z: i32,
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct IVec4 {
         x: i32,
         y: i32,
         z: i32,
-        w: i32
+        w: i32,
     }
 );
 
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct UVec2 {
         x: u32,
-        y: u32
+        y: u32,
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct UVec3 {
         x: u32,
         y: u32,
-        z: u32
+        z: u32,
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct UVec4 {
         x: u32,
         y: u32,
         z: u32,
-        w: u32
+        w: u32,
     }
 );
 
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct Vec2 {
         x: f32,
-        y: f32
+        y: f32,
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct Vec3 {
         x: f32,
         y: f32,
-        z: f32
+        z: f32,
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct Vec3A {
         x: f32,
         y: f32,
-        z: f32
+        z: f32,
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct Vec4 {
         x: f32,
         y: f32,
         z: f32,
-        w: f32
+        w: f32,
     }
 );
 
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct DVec2 {
         x: f64,
-        y: f64
+        y: f64,
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct DVec3 {
         x: f64,
         y: f64,
-        z: f64
+        z: f64,
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct DVec4 {
         x: f64,
         y: f64,
         z: f64,
-        w: f64
+        w: f64,
     }
 );
 
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct Mat3 {
         x_axis: Vec3,
         y_axis: Vec3,
-        z_axis: Vec3
+        z_axis: Vec3,
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct Mat4 {
         x_axis: Vec4,
         y_axis: Vec4,
         z_axis: Vec4,
-        w_axis: Vec4
+        w_axis: Vec4,
     }
 );
 
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct DMat3 {
         x_axis: DVec3,
         y_axis: DVec3,
-        z_axis: DVec3
+        z_axis: DVec3,
     }
 );
 impl_reflect_struct_and_from_reflect_struct!(
-    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+    #[reflect(
+        ctor = "Default::default()",
+        path = "self::bevy_reflect",
+        PartialEq,
+        Serialize,
+        Deserialize
+    )]
     struct DMat4 {
         x_axis: DVec4,
         y_axis: DVec4,
         z_axis: DVec4,
-        w_axis: DVec4
+        w_axis: DVec4,
     }
 );
 

From b2ae524530555dcdcdd2888dfd9158f4cb5e5538 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 26 Apr 2022 19:46:06 -0400
Subject: [PATCH 25/52] Added doc comment link backticks

---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 8d11f37215dad..49f379627ce33 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -711,8 +711,8 @@ impl Parse for ReflectStructDef {
 }
 
 /// A replacement for #\[derive(Reflect)] to be used with foreign types which
-/// the definitions of cannot be altered. It is an alternative to [impl_reflect_value] and
-/// [impl_from_reflect_value] which implement foreign types as Value types. This macro
+/// the definitions of cannot be altered. It is an alternative to [`impl_reflect_value`] and
+/// [`impl_from_reflect_value`] which implement foreign types as Value types. This macro
 /// implements them as Struct types, which have greater functionality.
 ///
 /// The extra ctor tag allows overriding the default construction behavior, which is necessary

From 91e8255f0109da423f45f33fbed44e1475a9a021 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Tue, 26 Apr 2022 22:08:58 -0400
Subject: [PATCH 26/52] Fixed doc links, ignored doc comment examples

---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 49f379627ce33..108d23594a96e 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -608,8 +608,8 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
 }
 
 /// Represents the information needed to implement a type as a Reflect Struct.
-/// ## Example
-/// ```
+/// # Example
+/// ```ignore
 /// impl_reflect_struct_and_from_reflect_struct!(
 ///    //               path override                ctor override                       attrs
 ///    //        |-------------------------|  |-------------------------|  |-------------------------------|
@@ -711,17 +711,17 @@ impl Parse for ReflectStructDef {
 }
 
 /// A replacement for #\[derive(Reflect)] to be used with foreign types which
-/// the definitions of cannot be altered. It is an alternative to [`impl_reflect_value`] and
-/// [`impl_from_reflect_value`] which implement foreign types as Value types. This macro
+/// the definitions of cannot be altered. It is an alternative to [`impl_reflect_value!`] and
+/// [`impl_from_reflect_value!`] which implement foreign types as Value types. This macro
 /// implements them as Struct types, which have greater functionality.
 ///
 /// The extra ctor tag allows overriding the default construction behavior, which is necessary
 /// for non-constructible foreign types, among other cases.
 ///
-/// The extra path tag allows overriding the path used to access the bevy_reflect module, which
+/// The extra path tag allows overriding the path used to access the `bevy_reflect` module, which
 /// can be helpful in certain edge cases of invocations of the macro.
-/// ## Example
-/// ```
+/// # Example
+/// ```ignore
 /// impl_reflect_struct_and_from_reflect_struct!(
 ///    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
 ///    struct Vec3 {

From 1f90de7fc0e841707c0ac708702c51d26ce70e97 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Wed, 27 Apr 2022 10:51:42 -0400
Subject: [PATCH 27/52] Changed to syn::Error instead of panics

---
 .../bevy_reflect_derive/src/lib.rs            | 54 ++++++++++++++-----
 1 file changed, 42 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 108d23594a96e..6563a29cc7ec1 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -640,8 +640,18 @@ impl Parse for ReflectStructDef {
         let generics = ast.generics;
         let fields = match ast.data {
             Data::Struct(data) => data.fields,
-            Data::Enum(_) => panic!("Enums are not currently supported for reflection"),
-            Data::Union(_) => panic!("Unions are not supported for reflection"),
+            Data::Enum(data) => {
+                return Err(syn::Error::new(
+                    data.enum_token.span,
+                    "Enums are not currently supported for reflection",
+                ))
+            }
+            Data::Union(data) => {
+                return Err(syn::Error::new(
+                    data.union_token.span,
+                    "Unions are not supported for reflection",
+                ))
+            }
         };
 
         let mut ctor = None;
@@ -672,21 +682,41 @@ impl Parse for ReflectStructDef {
                             match &ident.to_string()[..] {
                                 "path" => {
                                     let path_str = match &name_val.lit {
-                                        syn::Lit::Str(s) => s,
-                                        _ => panic!("Invalid path"),
-                                    };
+                                        syn::Lit::Str(s) => Ok(s),
+                                        _ => Err(syn::Error::new(
+                                            name_val.lit.span(),
+                                            "Invalid path",
+                                        )),
+                                    }?;
                                     bevy_reflect_path =
-                                        Some(path_str.parse::<Path>().expect("Invalid path"));
+                                        Some(path_str.parse::<Path>().map_err(|e| {
+                                            let mut err = syn::Error::new(
+                                                path_str.span(),
+                                                "Failed to parse path:",
+                                            );
+                                            err.combine(e);
+                                            err
+                                        })?);
                                 }
                                 "ctor" => {
                                     let ctor_str = match &name_val.lit {
-                                        syn::Lit::Str(s) => s,
-                                        _ => panic!("Invalid ctor"),
-                                    };
+                                        syn::Lit::Str(s) => Ok(s),
+                                        _ => Err(syn::Error::new(
+                                            name_val.lit.span(),
+                                            "Invalid ctor value",
+                                        )),
+                                    }?;
                                     ctor = Some(
-                                        ctor_str
-                                            .parse::<proc_macro2::TokenStream>()
-                                            .expect("Invalid ctor code"),
+                                        ctor_str.parse::<proc_macro2::TokenStream>().map_err(
+                                            |e| {
+                                                let mut err = syn::Error::new(
+                                                    ctor_str.span(),
+                                                    "Failed to parse ctor:",
+                                                );
+                                                err.combine(e);
+                                                err
+                                            },
+                                        )?,
                                     );
                                 }
                                 _ => (),

From 21cc040f4bddbecbdbc55cfa330664c307fdde07 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Wed, 27 Apr 2022 11:05:32 -0400
Subject: [PATCH 28/52] Switched from syn::Error::new to new_spanned

---
 .../bevy_reflect_derive/src/lib.rs            | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 6563a29cc7ec1..9372a98b1f48d 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -641,14 +641,14 @@ impl Parse for ReflectStructDef {
         let fields = match ast.data {
             Data::Struct(data) => data.fields,
             Data::Enum(data) => {
-                return Err(syn::Error::new(
-                    data.enum_token.span,
+                return Err(syn::Error::new_spanned(
+                    data.enum_token,
                     "Enums are not currently supported for reflection",
                 ))
             }
             Data::Union(data) => {
-                return Err(syn::Error::new(
-                    data.union_token.span,
+                return Err(syn::Error::new_spanned(
+                    data.union_token,
                     "Unions are not supported for reflection",
                 ))
             }
@@ -683,15 +683,15 @@ impl Parse for ReflectStructDef {
                                 "path" => {
                                     let path_str = match &name_val.lit {
                                         syn::Lit::Str(s) => Ok(s),
-                                        _ => Err(syn::Error::new(
-                                            name_val.lit.span(),
+                                        _ => Err(syn::Error::new_spanned(
+                                            &name_val.lit,
                                             "Invalid path",
                                         )),
                                     }?;
                                     bevy_reflect_path =
                                         Some(path_str.parse::<Path>().map_err(|e| {
-                                            let mut err = syn::Error::new(
-                                                path_str.span(),
+                                            let mut err = syn::Error::new_spanned(
+                                                path_str,
                                                 "Failed to parse path:",
                                             );
                                             err.combine(e);
@@ -701,16 +701,16 @@ impl Parse for ReflectStructDef {
                                 "ctor" => {
                                     let ctor_str = match &name_val.lit {
                                         syn::Lit::Str(s) => Ok(s),
-                                        _ => Err(syn::Error::new(
-                                            name_val.lit.span(),
+                                        _ => Err(syn::Error::new_spanned(
+                                            &name_val.lit,
                                             "Invalid ctor value",
                                         )),
                                     }?;
                                     ctor = Some(
                                         ctor_str.parse::<proc_macro2::TokenStream>().map_err(
                                             |e| {
-                                                let mut err = syn::Error::new(
-                                                    ctor_str.span(),
+                                                let mut err = syn::Error::new_spanned(
+                                                    ctor_str,
                                                     "Failed to parse ctor:",
                                                 );
                                                 err.combine(e);

From 133d2be9904e8389a03ab72f25dc2be790ce6cbd Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 28 Apr 2022 08:27:34 -0400
Subject: [PATCH 29/52] Renamed to impl_reflect_struct

---
 .../bevy_reflect_derive/src/lib.rs            |  5 +--
 crates/bevy_reflect/src/impls/glam.rs         | 34 +++++++++----------
 2 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 9372a98b1f48d..56bb6a8690857 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -742,7 +742,8 @@ impl Parse for ReflectStructDef {
 
 /// A replacement for #\[derive(Reflect)] to be used with foreign types which
 /// the definitions of cannot be altered. It is an alternative to [`impl_reflect_value!`] and
-/// [`impl_from_reflect_value!`] which implement foreign types as Value types. This macro
+/// [`impl_from_reflect_value!`] which implement foreign types as Value types. Note that there
+/// is no `impl_from_reflect_struct`, this macro will do the job of both. This macro
 /// implements them as Struct types, which have greater functionality.
 ///
 /// The extra ctor tag allows overriding the default construction behavior, which is necessary
@@ -762,7 +763,7 @@ impl Parse for ReflectStructDef {
 /// );
 /// ```
 #[proc_macro]
-pub fn impl_reflect_struct_and_from_reflect_struct(input: TokenStream) -> TokenStream {
+pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
     let ReflectStructDef {
         type_name,
         generics,
diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index f6eb27a08cde7..8c89b4e6d1b29 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -6,7 +6,7 @@ use bevy_reflect_derive::{
 };
 use glam::*;
 
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -19,7 +19,7 @@ impl_reflect_struct_and_from_reflect_struct!(
         y: i32,
     }
 );
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -33,7 +33,7 @@ impl_reflect_struct_and_from_reflect_struct!(
         z: i32,
     }
 );
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -49,7 +49,7 @@ impl_reflect_struct_and_from_reflect_struct!(
     }
 );
 
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -62,7 +62,7 @@ impl_reflect_struct_and_from_reflect_struct!(
         y: u32,
     }
 );
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -76,7 +76,7 @@ impl_reflect_struct_and_from_reflect_struct!(
         z: u32,
     }
 );
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -92,7 +92,7 @@ impl_reflect_struct_and_from_reflect_struct!(
     }
 );
 
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -105,7 +105,7 @@ impl_reflect_struct_and_from_reflect_struct!(
         y: f32,
     }
 );
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -119,7 +119,7 @@ impl_reflect_struct_and_from_reflect_struct!(
         z: f32,
     }
 );
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -133,7 +133,7 @@ impl_reflect_struct_and_from_reflect_struct!(
         z: f32,
     }
 );
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -149,7 +149,7 @@ impl_reflect_struct_and_from_reflect_struct!(
     }
 );
 
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -162,7 +162,7 @@ impl_reflect_struct_and_from_reflect_struct!(
         y: f64,
     }
 );
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -176,7 +176,7 @@ impl_reflect_struct_and_from_reflect_struct!(
         z: f64,
     }
 );
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -192,7 +192,7 @@ impl_reflect_struct_and_from_reflect_struct!(
     }
 );
 
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -206,7 +206,7 @@ impl_reflect_struct_and_from_reflect_struct!(
         z_axis: Vec3,
     }
 );
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -222,7 +222,7 @@ impl_reflect_struct_and_from_reflect_struct!(
     }
 );
 
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",
@@ -236,7 +236,7 @@ impl_reflect_struct_and_from_reflect_struct!(
         z_axis: DVec3,
     }
 );
-impl_reflect_struct_and_from_reflect_struct!(
+impl_reflect_struct!(
     #[reflect(
         ctor = "Default::default()",
         path = "self::bevy_reflect",

From abf7ed21e63003bf820d5ce04b5421f12b9518fd Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 28 Apr 2022 08:29:19 -0400
Subject: [PATCH 30/52] Fix use statement

---
 crates/bevy_reflect/src/impls/glam.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 8c89b4e6d1b29..3c315f2cec3e3 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -2,7 +2,7 @@ use crate as bevy_reflect;
 use crate::reflect::Reflect;
 use crate::ReflectDeserialize;
 use bevy_reflect_derive::{
-    impl_from_reflect_value, impl_reflect_struct_and_from_reflect_struct, impl_reflect_value,
+    impl_from_reflect_value, impl_reflect_struct, impl_reflect_value,
 };
 use glam::*;
 

From f4c3478b6cea0fe641d65d7ba09b498fe4ee22f6 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 28 Apr 2022 08:29:43 -0400
Subject: [PATCH 31/52] Cargo fmt --all

---
 crates/bevy_reflect/src/impls/glam.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 3c315f2cec3e3..843dd179d65f3 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -1,9 +1,7 @@
 use crate as bevy_reflect;
 use crate::reflect::Reflect;
 use crate::ReflectDeserialize;
-use bevy_reflect_derive::{
-    impl_from_reflect_value, impl_reflect_struct, impl_reflect_value,
-};
+use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_struct, impl_reflect_value};
 use glam::*;
 
 impl_reflect_struct!(

From 8ef79e1a3d6befeb27f63e3ebbc3234813e3023a Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 5 May 2022 10:32:25 -0400
Subject: [PATCH 32/52] Add reflect(Default) to glam types

---
 crates/bevy_reflect/src/impls/glam.rs | 55 ++++++++++++++++++---------
 1 file changed, 36 insertions(+), 19 deletions(-)

diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 843dd179d65f3..dabe4e6253a5f 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -10,7 +10,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct IVec2 {
         x: i32,
@@ -23,7 +24,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct IVec3 {
         x: i32,
@@ -37,7 +39,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct IVec4 {
         x: i32,
@@ -53,7 +56,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct UVec2 {
         x: u32,
@@ -66,7 +70,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct UVec3 {
         x: u32,
@@ -80,7 +85,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct UVec4 {
         x: u32,
@@ -96,7 +102,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct Vec2 {
         x: f32,
@@ -109,7 +116,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct Vec3 {
         x: f32,
@@ -123,7 +131,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct Vec3A {
         x: f32,
@@ -137,7 +146,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct Vec4 {
         x: f32,
@@ -153,7 +163,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct DVec2 {
         x: f64,
@@ -166,7 +177,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct DVec3 {
         x: f64,
@@ -180,7 +192,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct DVec4 {
         x: f64,
@@ -196,7 +209,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct Mat3 {
         x_axis: Vec3,
@@ -210,7 +224,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct Mat4 {
         x_axis: Vec4,
@@ -226,7 +241,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct DMat3 {
         x_axis: DVec3,
@@ -240,7 +256,8 @@ impl_reflect_struct!(
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
-        Deserialize
+        Deserialize,
+        Default
     )]
     struct DMat4 {
         x_axis: DVec4,
@@ -254,8 +271,8 @@ impl_reflect_struct!(
 // mechanisms for read-only fields. I doubt those mechanisms would be added,
 // so for now quaternions will remain as values. They are represented identically
 // to Vec4 and DVec4, so you may use those instead and convert between.
-impl_reflect_value!(Quat(PartialEq, Serialize, Deserialize));
-impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize));
+impl_reflect_value!(Quat(PartialEq, Serialize, Deserialize, Default));
+impl_reflect_value!(DQuat(PartialEq, Serialize, Deserialize, Default));
 
 impl_from_reflect_value!(Quat);
 impl_from_reflect_value!(DQuat);

From 7bbff479bd97b92cafbfcadb2d1bdf70004f0f99 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 5 May 2022 11:55:19 -0400
Subject: [PATCH 33/52] Add `use create::prelude::ReflectDefault`

---
 crates/bevy_reflect/src/impls/glam.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index dabe4e6253a5f..7d225a1fa142e 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -1,6 +1,7 @@
 use crate as bevy_reflect;
 use crate::reflect::Reflect;
 use crate::ReflectDeserialize;
+use crate::prelude::ReflectDefault;
 use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_struct, impl_reflect_value};
 use glam::*;
 

From cdae659bf159ae35d0e32a14630ec372f68c0e4f Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 5 May 2022 12:37:26 -0400
Subject: [PATCH 34/52] Removed explicit ctor attribute Use
 `#[reflect(Default)]` instead

---
 .../bevy_reflect_derive/src/lib.rs            | 59 +++++++++++--------
 crates/bevy_reflect/src/impls/glam.rs         | 19 +-----
 2 files changed, 35 insertions(+), 43 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 56bb6a8690857..7d2bc45de9988 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -628,7 +628,7 @@ struct ReflectStructDef {
     generics: Generics,
     attrs: ReflectAttrs,
     fields: Fields,
-    ctor: Option<proc_macro2::TokenStream>,
+    // ctor: Option<proc_macro2::TokenStream>,
     bevy_reflect_path: Option<Path>,
 }
 
@@ -654,7 +654,7 @@ impl Parse for ReflectStructDef {
             }
         };
 
-        let mut ctor = None;
+        // let mut ctor = None;
         let mut bevy_reflect_path = None;
 
         let mut attrs = ReflectAttrs::default();
@@ -698,27 +698,27 @@ impl Parse for ReflectStructDef {
                                             err
                                         })?);
                                 }
-                                "ctor" => {
-                                    let ctor_str = match &name_val.lit {
-                                        syn::Lit::Str(s) => Ok(s),
-                                        _ => Err(syn::Error::new_spanned(
-                                            &name_val.lit,
-                                            "Invalid ctor value",
-                                        )),
-                                    }?;
-                                    ctor = Some(
-                                        ctor_str.parse::<proc_macro2::TokenStream>().map_err(
-                                            |e| {
-                                                let mut err = syn::Error::new_spanned(
-                                                    ctor_str,
-                                                    "Failed to parse ctor:",
-                                                );
-                                                err.combine(e);
-                                                err
-                                            },
-                                        )?,
-                                    );
-                                }
+                                // "ctor" => {
+                                //     let ctor_str = match &name_val.lit {
+                                //         syn::Lit::Str(s) => Ok(s),
+                                //         _ => Err(syn::Error::new_spanned(
+                                //             &name_val.lit,
+                                //             "Invalid ctor value",
+                                //         )),
+                                //     }?;
+                                //     ctor = Some(
+                                //         ctor_str.parse::<proc_macro2::TokenStream>().map_err(
+                                //             |e| {
+                                //                 let mut err = syn::Error::new_spanned(
+                                //                     ctor_str,
+                                //                     "Failed to parse ctor:",
+                                //                 );
+                                //                 err.combine(e);
+                                //                 err
+                                //             },
+                                //         )?,
+                                //     );
+                                // }
                                 _ => (),
                             }
                         }
@@ -734,7 +734,7 @@ impl Parse for ReflectStructDef {
             generics,
             attrs,
             fields,
-            ctor,
+            // ctor,
             bevy_reflect_path,
         })
     }
@@ -769,7 +769,7 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
         generics,
         attrs,
         fields,
-        ctor,
+        // ctor,
         bevy_reflect_path,
     } = parse_macro_input!(input as ReflectStructDef);
 
@@ -828,6 +828,15 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
         .map(|(f, _attr, i)| (*f, *i))
         .collect::<Vec<(&Field, usize)>>();
 
+    let ctor = if attrs
+        .data
+        .contains(&Ident::new("ReflectDefault", Span::call_site()))
+    {
+        Some(quote! { Default::default() })
+    } else {
+        None
+    };
+
     let registration_data = &attrs.data;
     let get_type_registration_impl =
         impl_get_type_registration(&type_name, &bevy_reflect_path, registration_data, &generics);
diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 7d225a1fa142e..27fab7961ba8e 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -1,13 +1,12 @@
 use crate as bevy_reflect;
+use crate::prelude::ReflectDefault;
 use crate::reflect::Reflect;
 use crate::ReflectDeserialize;
-use crate::prelude::ReflectDefault;
 use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_struct, impl_reflect_value};
 use glam::*;
 
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -21,7 +20,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -36,7 +34,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -53,7 +50,6 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -67,7 +63,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -82,7 +77,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -99,7 +93,6 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -113,7 +106,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -128,7 +120,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -143,7 +134,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -160,7 +150,6 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -174,7 +163,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -189,7 +177,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -206,7 +193,6 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -221,7 +207,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -238,7 +223,6 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,
@@ -253,7 +237,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        ctor = "Default::default()",
         path = "self::bevy_reflect",
         PartialEq,
         Serialize,

From d6232eb3480d00e1f439f96be36a6bc72e7a64b6 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 5 May 2022 12:41:12 -0400
Subject: [PATCH 35/52] Fixed clippy warning

---
 .../bevy_reflect_derive/src/lib.rs            | 57 ++++++-------------
 1 file changed, 16 insertions(+), 41 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 7d2bc45de9988..d71558b3ef2fa 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -679,47 +679,22 @@ impl Parse for ReflectStructDef {
                             arguments: _,
                         }) = name_val.path.segments.first()
                         {
-                            match &ident.to_string()[..] {
-                                "path" => {
-                                    let path_str = match &name_val.lit {
-                                        syn::Lit::Str(s) => Ok(s),
-                                        _ => Err(syn::Error::new_spanned(
-                                            &name_val.lit,
-                                            "Invalid path",
-                                        )),
-                                    }?;
-                                    bevy_reflect_path =
-                                        Some(path_str.parse::<Path>().map_err(|e| {
-                                            let mut err = syn::Error::new_spanned(
-                                                path_str,
-                                                "Failed to parse path:",
-                                            );
-                                            err.combine(e);
-                                            err
-                                        })?);
-                                }
-                                // "ctor" => {
-                                //     let ctor_str = match &name_val.lit {
-                                //         syn::Lit::Str(s) => Ok(s),
-                                //         _ => Err(syn::Error::new_spanned(
-                                //             &name_val.lit,
-                                //             "Invalid ctor value",
-                                //         )),
-                                //     }?;
-                                //     ctor = Some(
-                                //         ctor_str.parse::<proc_macro2::TokenStream>().map_err(
-                                //             |e| {
-                                //                 let mut err = syn::Error::new_spanned(
-                                //                     ctor_str,
-                                //                     "Failed to parse ctor:",
-                                //                 );
-                                //                 err.combine(e);
-                                //                 err
-                                //             },
-                                //         )?,
-                                //     );
-                                // }
-                                _ => (),
+                            if &ident.to_string()[..] == "path" {
+                                let path_str = match &name_val.lit {
+                                    syn::Lit::Str(s) => Ok(s),
+                                    _ => {
+                                        Err(syn::Error::new_spanned(&name_val.lit, "Invalid path"))
+                                    }
+                                }?;
+                                bevy_reflect_path =
+                                    Some(path_str.parse::<Path>().map_err(|e| {
+                                        let mut err = syn::Error::new_spanned(
+                                            path_str,
+                                            "Failed to parse path:",
+                                        );
+                                        err.combine(e);
+                                        err
+                                    })?);
                             }
                         }
                     }

From 1864fb3f2e4eeedf1420b96d9c0bbd476ad1b080 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 5 May 2022 15:02:42 -0400
Subject: [PATCH 36/52] Removed instances of `use bevy_reflect::Struct` And
 removed path and ctor special attributes

---
 .../bevy_reflect_derive/src/from_reflect.rs   |  5 +-
 .../bevy_reflect_derive/src/lib.rs            | 53 ++-----------------
 2 files changed, 5 insertions(+), 53 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
index ed2d8f7a12397..c63555870ba09 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
@@ -66,7 +66,7 @@ pub fn impl_struct(
             let mut value: Self = #ctor;
             #(
                 value.#field_idents = {
-                    <#field_types as #bevy_reflect_path::FromReflect>::from_reflect(ref_struct.field(#field_names)?)?
+                    <#field_types as #bevy_reflect_path::FromReflect>::from_reflect(#bevy_reflect_path::Struct::field(ref_struct, #field_names)?)?
                 };
             )*
             Some(value)
@@ -76,7 +76,7 @@ pub fn impl_struct(
             Some(
                 Self {
                     #(#field_idents: {
-                        <#field_types as #bevy_reflect_path::FromReflect>::from_reflect(ref_struct.field(#field_names)?)?
+                        <#field_types as #bevy_reflect_path::FromReflect>::from_reflect(#bevy_reflect_path::Struct::field(ref_struct, #field_names)?)?
                     },)*
                     #(#ignored_field_idents: Default::default(),)*
                 }
@@ -88,7 +88,6 @@ pub fn impl_struct(
         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() {
                     #ctor
                 } else {
diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index d71558b3ef2fa..a3acc136ca24b 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -287,8 +287,7 @@ fn impl_struct(
 
             #[inline]
             fn clone_value(&self) -> Box<dyn #bevy_reflect_path::Reflect> {
-                use #bevy_reflect_path::Struct;
-                Box::new(self.clone_dynamic())
+                Box::new(#bevy_reflect_path::Struct::clone_dynamic(self))
             }
             #[inline]
             fn set(&mut self, value: Box<dyn #bevy_reflect_path::Reflect>) -> Result<(), Box<dyn #bevy_reflect_path::Reflect>> {
@@ -298,11 +297,10 @@ fn impl_struct(
 
             #[inline]
             fn apply(&mut self, value: &dyn #bevy_reflect_path::Reflect) {
-                use #bevy_reflect_path::Struct;
                 if let #bevy_reflect_path::ReflectRef::Struct(struct_value) = value.reflect_ref() {
                     for (i, value) in struct_value.iter_fields().enumerate() {
                         let name = struct_value.name_at(i).unwrap();
-                        self.field_mut(name).map(|v| v.apply(value));
+                        #bevy_reflect_path::Struct::field_mut(self, name).map(|v| v.apply(value));
                     }
                 } else {
                     panic!("Attempted to apply non-struct type to struct type.");
@@ -628,8 +626,6 @@ struct ReflectStructDef {
     generics: Generics,
     attrs: ReflectAttrs,
     fields: Fields,
-    // ctor: Option<proc_macro2::TokenStream>,
-    bevy_reflect_path: Option<Path>,
 }
 
 impl Parse for ReflectStructDef {
@@ -654,9 +650,6 @@ impl Parse for ReflectStructDef {
             }
         };
 
-        // let mut ctor = None;
-        let mut bevy_reflect_path = None;
-
         let mut 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 {
@@ -667,38 +660,6 @@ impl Parse for ReflectStructDef {
 
             if let Some(ident) = meta_list.path.get_ident() {
                 if ident == REFLECT_ATTRIBUTE_NAME || ident == REFLECT_VALUE_ATTRIBUTE_NAME {
-                    for name_val in meta_list.nested.iter().filter_map(|m| {
-                        if let NestedMeta::Meta(Meta::NameValue(name_val)) = m {
-                            Some(name_val)
-                        } else {
-                            None
-                        }
-                    }) {
-                        if let Some(syn::PathSegment {
-                            ident,
-                            arguments: _,
-                        }) = name_val.path.segments.first()
-                        {
-                            if &ident.to_string()[..] == "path" {
-                                let path_str = match &name_val.lit {
-                                    syn::Lit::Str(s) => Ok(s),
-                                    _ => {
-                                        Err(syn::Error::new_spanned(&name_val.lit, "Invalid path"))
-                                    }
-                                }?;
-                                bevy_reflect_path =
-                                    Some(path_str.parse::<Path>().map_err(|e| {
-                                        let mut err = syn::Error::new_spanned(
-                                            path_str,
-                                            "Failed to parse path:",
-                                        );
-                                        err.combine(e);
-                                        err
-                                    })?);
-                            }
-                        }
-                    }
-
                     attrs = ReflectAttrs::from_nested_metas(&meta_list.nested);
                 }
             }
@@ -709,8 +670,6 @@ impl Parse for ReflectStructDef {
             generics,
             attrs,
             fields,
-            // ctor,
-            bevy_reflect_path,
         })
     }
 }
@@ -744,15 +703,9 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
         generics,
         attrs,
         fields,
-        // ctor,
-        bevy_reflect_path,
     } = parse_macro_input!(input as ReflectStructDef);
 
-    let bevy_reflect_path = if let Some(path) = bevy_reflect_path {
-        path
-    } else {
-        BevyManifest::default().get_path("bevy_reflect")
-    };
+    let bevy_reflect_path = BevyManifest::default().get_path("bevy_reflect");
 
     let fields_and_args = fields
         .iter()

From 35bde41edf82f9ae5a0f2be76299c07ca31bc513 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 5 May 2022 15:02:52 -0400
Subject: [PATCH 37/52] Removed uses of path special attribute

---
 crates/bevy_reflect/src/impls/glam.rs | 17 -----------------
 1 file changed, 17 deletions(-)

diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 27fab7961ba8e..2e02d73c47aca 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -7,7 +7,6 @@ use glam::*;
 
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -20,7 +19,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -34,7 +32,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -50,7 +47,6 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -63,7 +59,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -77,7 +72,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -93,7 +87,6 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -106,7 +99,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -120,7 +112,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -134,7 +125,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -150,7 +140,6 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -163,7 +152,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -177,7 +165,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -193,7 +180,6 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -207,7 +193,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -223,7 +208,6 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,
@@ -237,7 +221,6 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(
-        path = "self::bevy_reflect",
         PartialEq,
         Serialize,
         Deserialize,

From ca0c3a5f2516fc8a342a35a5ce0d99503baff723 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 5 May 2022 15:03:25 -0400
Subject: [PATCH 38/52] cargo fmt --all

---
 crates/bevy_reflect/src/impls/glam.rs | 119 ++++----------------------
 1 file changed, 17 insertions(+), 102 deletions(-)

diff --git a/crates/bevy_reflect/src/impls/glam.rs b/crates/bevy_reflect/src/impls/glam.rs
index 2e02d73c47aca..93f803cc0cf94 100644
--- a/crates/bevy_reflect/src/impls/glam.rs
+++ b/crates/bevy_reflect/src/impls/glam.rs
@@ -6,24 +6,14 @@ use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_struct, impl_ref
 use glam::*;
 
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct IVec2 {
         x: i32,
         y: i32,
     }
 );
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct IVec3 {
         x: i32,
         y: i32,
@@ -31,12 +21,7 @@ impl_reflect_struct!(
     }
 );
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct IVec4 {
         x: i32,
         y: i32,
@@ -46,24 +31,14 @@ impl_reflect_struct!(
 );
 
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct UVec2 {
         x: u32,
         y: u32,
     }
 );
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct UVec3 {
         x: u32,
         y: u32,
@@ -71,12 +46,7 @@ impl_reflect_struct!(
     }
 );
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct UVec4 {
         x: u32,
         y: u32,
@@ -86,24 +56,14 @@ impl_reflect_struct!(
 );
 
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct Vec2 {
         x: f32,
         y: f32,
     }
 );
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct Vec3 {
         x: f32,
         y: f32,
@@ -111,12 +71,7 @@ impl_reflect_struct!(
     }
 );
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct Vec3A {
         x: f32,
         y: f32,
@@ -124,12 +79,7 @@ impl_reflect_struct!(
     }
 );
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct Vec4 {
         x: f32,
         y: f32,
@@ -139,24 +89,14 @@ impl_reflect_struct!(
 );
 
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct DVec2 {
         x: f64,
         y: f64,
     }
 );
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct DVec3 {
         x: f64,
         y: f64,
@@ -164,12 +104,7 @@ impl_reflect_struct!(
     }
 );
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct DVec4 {
         x: f64,
         y: f64,
@@ -179,12 +114,7 @@ impl_reflect_struct!(
 );
 
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct Mat3 {
         x_axis: Vec3,
         y_axis: Vec3,
@@ -192,12 +122,7 @@ impl_reflect_struct!(
     }
 );
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct Mat4 {
         x_axis: Vec4,
         y_axis: Vec4,
@@ -207,12 +132,7 @@ impl_reflect_struct!(
 );
 
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct DMat3 {
         x_axis: DVec3,
         y_axis: DVec3,
@@ -220,12 +140,7 @@ impl_reflect_struct!(
     }
 );
 impl_reflect_struct!(
-    #[reflect(
-        PartialEq,
-        Serialize,
-        Deserialize,
-        Default
-    )]
+    #[reflect(PartialEq, Serialize, Deserialize, Default)]
     struct DMat4 {
         x_axis: DVec4,
         y_axis: DVec4,

From dd4c158d690e3ffbdb3eae753eb7a372fdf50f09 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Thu, 5 May 2022 22:25:24 -0400
Subject: [PATCH 39/52] Updated doc comments

---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index a3acc136ca24b..c9557b852a9d9 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -608,10 +608,10 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
 /// Represents the information needed to implement a type as a Reflect Struct.
 /// # Example
 /// ```ignore
-/// impl_reflect_struct_and_from_reflect_struct!(
-///    //               path override                ctor override                       attrs
-///    //        |-------------------------|  |-------------------------|  |-------------------------------|
-///    #[reflect(path = "self::bevy_reflect", ctor = "Default::default()", PartialEq, Serialize, Deserialize)]
+/// impl_reflect_struct!(
+///    //                          attrs
+///    //        |----------------------------------------|
+///    #[reflect(PartialEq, Serialize, Deserialize, Default)]
 ///    //            type_name       generics
 ///    //     |-------------------||----------|
 ///    struct ThingThatImReflecting<T1, T2, T3> {
@@ -674,7 +674,7 @@ impl Parse for ReflectStructDef {
     }
 }
 
-/// A replacement for #\[derive(Reflect)] to be used with foreign types which
+/// A replacement for `#[derive(Reflect)]` to be used with foreign types which
 /// the definitions of cannot be altered. It is an alternative to [`impl_reflect_value!`] and
 /// [`impl_from_reflect_value!`] which implement foreign types as Value types. Note that there
 /// is no `impl_from_reflect_struct`, this macro will do the job of both. This macro
@@ -687,8 +687,8 @@ impl Parse for ReflectStructDef {
 /// can be helpful in certain edge cases of invocations of the macro.
 /// # Example
 /// ```ignore
-/// impl_reflect_struct_and_from_reflect_struct!(
-///    #[reflect(ctor = "Default::default()", path = "self::bevy_reflect", PartialEq, Serialize, Deserialize)]
+/// impl_reflect_struct!(
+///    #[reflect(PartialEq, Serialize, Deserialize, Default)]
 ///    struct Vec3 {
 ///        x: f32,
 ///        y: f32,

From ad8637f5f0a8eae5746dcbddafc2154d9b61df05 Mon Sep 17 00:00:00 2001
From: PROMETHIA-27 <42193387+PROMETHIA-27@users.noreply.github.com>
Date: Sun, 8 May 2022 14:49:01 -0400
Subject: [PATCH 40/52] Fix doc space

Co-authored-by: MrGVSV <49806985+MrGVSV@users.noreply.github.com>
---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index c9557b852a9d9..5725ab1625d60 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -606,6 +606,7 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
 }
 
 /// Represents the information needed to implement a type as a Reflect Struct.
+/// 
 /// # Example
 /// ```ignore
 /// impl_reflect_struct!(

From 907ea5544c4c4d146163ee63678aed2b265e1de4 Mon Sep 17 00:00:00 2001
From: PROMETHIA-27 <42193387+PROMETHIA-27@users.noreply.github.com>
Date: Sun, 8 May 2022 14:50:37 -0400
Subject: [PATCH 41/52] Split comment into quick and extended summaries

Co-authored-by: MrGVSV <49806985+MrGVSV@users.noreply.github.com>
---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 5725ab1625d60..ace95245171cc 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -676,10 +676,12 @@ impl Parse for ReflectStructDef {
 }
 
 /// A replacement for `#[derive(Reflect)]` to be used with foreign types which
-/// the definitions of cannot be altered. It is an alternative to [`impl_reflect_value!`] and
-/// [`impl_from_reflect_value!`] which implement foreign types as Value types. Note that there
-/// is no `impl_from_reflect_struct`, this macro will do the job of both. This macro
-/// implements them as Struct types, which have greater functionality.
+/// the definitions of cannot be altered.
+///
+/// This macro is an alternative to [`impl_reflect_value!`] and [`impl_from_reflect_value!`]
+/// which implement foreign types as Value types. Note that there is no `impl_from_reflect_struct`,
+/// as this macro will do the job of both. This macro implements them as `Struct` types,
+/// which have greater functionality.
 ///
 /// The extra ctor tag allows overriding the default construction behavior, which is necessary
 /// for non-constructible foreign types, among other cases.

From 27755a31332d37bc0a6db1da5e4f066085e3490c Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Sun, 8 May 2022 14:56:32 -0400
Subject: [PATCH 42/52] Replace outdated explanations of special attrs

---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index c9557b852a9d9..ab6cd82a49fa6 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -680,11 +680,11 @@ impl Parse for ReflectStructDef {
 /// is no `impl_from_reflect_struct`, this macro will do the job of both. This macro
 /// implements them as Struct types, which have greater functionality.
 ///
-/// The extra ctor tag allows overriding the default construction behavior, which is necessary
-/// for non-constructible foreign types, among other cases.
-///
-/// The extra path tag allows overriding the path used to access the `bevy_reflect` module, which
-/// can be helpful in certain edge cases of invocations of the macro.
+/// It may be necessary to add `#[reflect(Default)]` for some types, specifically non-constructible
+/// foreign types. Without Default reflected for such types, you will usually get an arcane
+/// error message and fail to compile. If the type does not implement Default, it may not
+/// be possible to reflect without extending the macro.
+/// 
 /// # Example
 /// ```ignore
 /// impl_reflect_struct!(

From 9a73dfe59819a4a7c3491b730d8f19233e8b76ad Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Sun, 8 May 2022 14:59:24 -0400
Subject: [PATCH 43/52] Explain type must be in scope

---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 1a83d21398ceb..113e63c5b91ff 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -681,11 +681,12 @@ impl Parse for ReflectStructDef {
 /// This macro is an alternative to [`impl_reflect_value!`] and [`impl_from_reflect_value!`]
 /// which implement foreign types as Value types. Note that there is no `impl_from_reflect_struct`,
 /// as this macro will do the job of both. This macro implements them as `Struct` types,
-/// which have greater functionality.
+/// which have greater functionality. The type being reflected must be in scope, as you cannot
+/// qualify it in the macro as e.g. `bevy::prelude::Vec3`.
 ///
 /// It may be necessary to add `#[reflect(Default)]` for some types, specifically non-constructible
-/// foreign types. Without Default reflected for such types, you will usually get an arcane
-/// error message and fail to compile. If the type does not implement Default, it may not
+/// foreign types. Without `Default` reflected for such types, you will usually get an arcane
+/// error message and fail to compile. If the type does not implement `Default`, it may not
 /// be possible to reflect without extending the macro.
 /// 
 /// # Example

From 68fef527c0d09630cf29cea4d5e994443ff1ca8b Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Sun, 8 May 2022 15:00:19 -0400
Subject: [PATCH 44/52] Explain example

---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 113e63c5b91ff..936b217874459 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -690,6 +690,7 @@ impl Parse for ReflectStructDef {
 /// be possible to reflect without extending the macro.
 /// 
 /// # Example
+/// Implementing `Reflect` for `glam::Vec3` as a struct type:
 /// ```ignore
 /// impl_reflect_struct!(
 ///    #[reflect(PartialEq, Serialize, Deserialize, Default)]

From 467a39a37b5ad4c11f47f29428b401c4d41ad914 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Sun, 8 May 2022 15:00:51 -0400
Subject: [PATCH 45/52] Show Vec3 in scope

---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 936b217874459..d34a153df197b 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -690,8 +690,10 @@ impl Parse for ReflectStructDef {
 /// be possible to reflect without extending the macro.
 /// 
 /// # Example
-/// Implementing `Reflect` for `glam::Vec3` as a struct type:
+/// Implementing `Reflect` for `bevy::prelude::Vec3` as a struct type:
 /// ```ignore
+/// use bevy::prelude::Vec3;
+/// 
 /// impl_reflect_struct!(
 ///    #[reflect(PartialEq, Serialize, Deserialize, Default)]
 ///    struct Vec3 {

From 2f63312e6a214d69faa2ccf82a6a2388884915e0 Mon Sep 17 00:00:00 2001
From: PROMETHIA-27 <42193387+PROMETHIA-27@users.noreply.github.com>
Date: Sun, 8 May 2022 15:11:38 -0400
Subject: [PATCH 46/52] .into -> TokenStream::from

Co-authored-by: MrGVSV <49806985+MrGVSV@users.noreply.github.com>
---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index ace95245171cc..45c3ab475d025 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -792,12 +792,11 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
     )
     .into();
 
-    quote!(
+    TokenStream::from(quote! {
         #impl_struct
 
         #impl_from_struct
-    )
-    .into()
+    })
 }
 
 #[derive(Default)]

From 7aa58dba473257e9584e039a6dc8d6b5fba0808f Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Sun, 8 May 2022 15:14:12 -0400
Subject: [PATCH 47/52] Cargo fmt --all

---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index 1fa7eaa1e7e6e..de824baa5428a 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -606,7 +606,7 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
 }
 
 /// Represents the information needed to implement a type as a Reflect Struct.
-/// 
+///
 /// # Example
 /// ```ignore
 /// impl_reflect_struct!(
@@ -688,12 +688,12 @@ impl Parse for ReflectStructDef {
 /// foreign types. Without `Default` reflected for such types, you will usually get an arcane
 /// error message and fail to compile. If the type does not implement `Default`, it may not
 /// be possible to reflect without extending the macro.
-/// 
+///
 /// # Example
 /// Implementing `Reflect` for `bevy::prelude::Vec3` as a struct type:
 /// ```ignore
 /// use bevy::prelude::Vec3;
-/// 
+///
 /// impl_reflect_struct!(
 ///    #[reflect(PartialEq, Serialize, Deserialize, Default)]
 ///    struct Vec3 {

From 05f4f0b6b1a41bf39ccf12ee5b1e23d01a07ec79 Mon Sep 17 00:00:00 2001
From: PROMETHIA-27 <42193387+PROMETHIA-27@users.noreply.github.com>
Date: Mon, 9 May 2022 12:11:18 -0400
Subject: [PATCH 48/52] ctor -> constructor

Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
---
 crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
index c63555870ba09..4c692cb2f06a7 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
@@ -8,7 +8,7 @@ pub fn impl_struct(
     bevy_reflect_path: &Path,
     active_fields: &[(&Field, usize)],
     ignored_fields: &[(&Field, usize)],
-    custom_ctor: Option<proc_macro2::TokenStream>,
+    custom_constructor: Option<proc_macro2::TokenStream>,
 ) -> TokenStream {
     let field_names = active_fields
         .iter()

From 7683aa993f3ba5a70652a91b3757ba356d5295ae Mon Sep 17 00:00:00 2001
From: PROMETHIA-27 <42193387+PROMETHIA-27@users.noreply.github.com>
Date: Mon, 9 May 2022 12:11:39 -0400
Subject: [PATCH 49/52] ctor -> constructor

Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
---
 crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
index 4c692cb2f06a7..47f5aa8d9af8f 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
@@ -61,7 +61,7 @@ pub fn impl_struct(
         #(#field_types: #bevy_reflect_path::FromReflect,)*
     });
 
-    let ctor = if let Some(ctor) = custom_ctor {
+    let constructor = if let Some(ctor) = custom_constructor {
         quote!(
             let mut value: Self = #ctor;
             #(

From 58e127c03abd42ee625650f27d050e20d2821553 Mon Sep 17 00:00:00 2001
From: PROMETHIA-27 <42193387+PROMETHIA-27@users.noreply.github.com>
Date: Mon, 9 May 2022 12:11:48 -0400
Subject: [PATCH 50/52] ctor -> constructor

Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
---
 crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
index 47f5aa8d9af8f..92e56330af4f4 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
@@ -89,7 +89,7 @@ pub fn impl_struct(
         {
             fn from_reflect(reflect: &dyn #bevy_reflect_path::Reflect) -> Option<Self> {
                 if let #bevy_reflect_path::ReflectRef::Struct(ref_struct) = reflect.reflect_ref() {
-                    #ctor
+                    #constructor
                 } else {
                     None
                 }

From ca936c83fc83a9efc52b44a7ebbe5b35fe201b07 Mon Sep 17 00:00:00 2001
From: PROMETHIA <electriccobras@gmail.com>
Date: Mon, 9 May 2022 12:17:16 -0400
Subject: [PATCH 51/52] ctor -> constructor

---
 crates/bevy_reflect/bevy_reflect_derive/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
index de824baa5428a..2b5f93a85edd4 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/lib.rs
@@ -763,7 +763,7 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
         .map(|(f, _attr, i)| (*f, *i))
         .collect::<Vec<(&Field, usize)>>();
 
-    let ctor = if attrs
+    let constructor = if attrs
         .data
         .contains(&Ident::new("ReflectDefault", Span::call_site()))
     {
@@ -792,7 +792,7 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
         &bevy_reflect_path,
         &active_fields,
         &ignored_fields,
-        ctor,
+        constructor,
     )
     .into();
 

From b7d76fb0c1139d1af09e377d652e02bcb3f5072a Mon Sep 17 00:00:00 2001
From: PROMETHIA-27 <42193387+PROMETHIA-27@users.noreply.github.com>
Date: Mon, 9 May 2022 12:20:44 -0400
Subject: [PATCH 52/52] last ctor -> constructor batch

Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>
---
 crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
index 92e56330af4f4..aabf75d904479 100644
--- a/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
+++ b/crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs
@@ -61,9 +61,9 @@ pub fn impl_struct(
         #(#field_types: #bevy_reflect_path::FromReflect,)*
     });
 
-    let constructor = if let Some(ctor) = custom_constructor {
+    let constructor = if let Some(constructor) = custom_constructor {
         quote!(
-            let mut value: Self = #ctor;
+            let mut value: Self = #constructor;
             #(
                 value.#field_idents = {
                     <#field_types as #bevy_reflect_path::FromReflect>::from_reflect(#bevy_reflect_path::Struct::field(ref_struct, #field_names)?)?