Update from_reflect to return a Result

crates/bevy_reflect/bevy_reflect_derive/src/enum_utility.rs

@@ -1,4 +1,4 @@
-use crate::fq_std::FQDefault;
+use crate::fq_std::{FQBox, FQDefault};
 use crate::{
     derive_data::{EnumVariantFields, ReflectEnum},
     utility::ident_or_index,
@@ -53,18 +53,62 @@ pub(crate) fn get_variant_constructors(
                     );
                     quote!(.expect(#type_err_message))
                 } else {
-                    quote!(?)
+                    match &field.data.ident {
+                        Some(ident) => {
+                            let name = ident.to_string();
+                            quote!(.map_err(|err| #bevy_reflect_path::FromReflectError::NamedFieldError {
+                                from_type: #bevy_reflect_path::Reflect::get_type_info(#ref_value),
+                                from_kind: #bevy_reflect_path::Reflect::reflect_kind(#ref_value),
+                                to_type: <Self as #bevy_reflect_path::Typed>::type_info(),
+                                field: #name,
+                                source: #FQBox::new(err),
+                            })?)
+                        },
+                        None => quote!(.map_err(|err| #bevy_reflect_path::FromReflectError::UnnamedFieldError {
+                            from_type: #bevy_reflect_path::Reflect::get_type_info(#ref_value),
+                            from_kind: #bevy_reflect_path::Reflect::reflect_kind(#ref_value),
+                            to_type: <Self as #bevy_reflect_path::Typed>::type_info(),
+                            index: #reflect_index,
+                            source: #FQBox::new(err),
+                        })?)
+                    }
                 };
                 let field_accessor = match &field.data.ident {
                     Some(ident) => {
                         let name = ident.to_string();
-                        quote!(.field(#name))
+                        if can_panic {
+                            quote!(.field(#name))
+                        } else {
+                            quote!(.field(#name)
+                                   .ok_or_else(|| #bevy_reflect_path::FromReflectError::MissingNamedField {
+                                       from_type: #bevy_reflect_path::Reflect::get_type_info(#ref_value),
+                                       from_kind: #bevy_reflect_path::Reflect::reflect_kind(#ref_value),
+                                       to_type: <Self as #bevy_reflect_path::Typed>::type_info(),
+                                       field: #name,
+                                   })
+                            )
+                        }
+                    }
+                    None => if can_panic {
+                        quote!(.field_at(#reflect_index))
+                    } else {
+                        quote!(.field_at(#reflect_index)
+                               .ok_or_else(|| #bevy_reflect_path::FromReflectError::MissingUnnamedField {
+                                   from_type: #bevy_reflect_path::Reflect::get_type_info(#ref_value),
+                                   from_kind: #bevy_reflect_path::Reflect::reflect_kind(#ref_value),
+                                   to_type: <Self as #bevy_reflect_path::Typed>::type_info(),
+                                   index: #reflect_index,
+                               })
+                        )
                     }
-                    None => quote!(.field_at(#reflect_index)),
                 };
                 reflect_index += 1;
                 let missing_field_err_message = format!("the field {error_repr} was not declared");
-                let accessor = quote!(#field_accessor .expect(#missing_field_err_message));
+                let accessor = if can_panic {
+                    quote!(#field_accessor .expect(#missing_field_err_message))
+                } else {
+                    quote!(#field_accessor?)
+                };
                 quote! {
                     #bevy_reflect_path::FromReflect::from_reflect(#ref_value #accessor)
                     #unwrapper

crates/bevy_reflect/bevy_reflect_derive/src/fq_std.rs

@@ -36,6 +36,7 @@ use quote::{quote, ToTokens};
 pub(crate) struct FQAny;
 pub(crate) struct FQBox;
 pub(crate) struct FQClone;
+pub(crate) struct FQCow;
 pub(crate) struct FQDefault;
 pub(crate) struct FQOption;
 pub(crate) struct FQResult;
@@ -58,6 +59,12 @@ impl ToTokens for FQClone {
     }
 }
 
+impl ToTokens for FQCow {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        quote!(::std::borrow::Cow).to_tokens(tokens);
+    }
+}
+
 impl ToTokens for FQDefault {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         quote!(::core::default::Default).to_tokens(tokens);

crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs

@@ -2,7 +2,7 @@ use crate::container_attributes::REFLECT_DEFAULT;
 use crate::derive_data::ReflectEnum;
 use crate::enum_utility::{get_variant_constructors, EnumVariantConstructors};
 use crate::field_attributes::DefaultBehavior;
-use crate::fq_std::{FQAny, FQClone, FQDefault, FQOption};
+use crate::fq_std::{FQAny, FQBox, FQClone, FQCow, FQDefault, FQResult};
 use crate::{ReflectMeta, ReflectStruct};
 use proc_macro::TokenStream;
 use proc_macro2::Span;
@@ -26,16 +26,25 @@ pub(crate) fn impl_value(meta: &ReflectMeta) -> TokenStream {
     let (impl_generics, ty_generics, where_clause) = meta.generics().split_for_impl();
     TokenStream::from(quote! {
         impl #impl_generics #bevy_reflect_path::FromReflect for #type_name #ty_generics #where_clause  {
-            fn from_reflect(reflect: &dyn #bevy_reflect_path::Reflect) -> #FQOption<Self> {
-                #FQOption::Some(#FQClone::clone(<dyn #FQAny>::downcast_ref::<#type_name #ty_generics>(<dyn #bevy_reflect_path::Reflect>::as_any(reflect))?))
+            fn from_reflect(reflect: &dyn #bevy_reflect_path::Reflect) -> #FQResult<Self, #bevy_reflect_path::FromReflectError> {
+                #FQResult::Ok(#FQClone::clone(
+                    <dyn #FQAny>::downcast_ref::<#type_name #ty_generics>(<dyn #bevy_reflect_path::Reflect>::as_any(reflect))
+                    .ok_or_else(|| #bevy_reflect_path::FromReflectError::InvalidType {
+                        from_type: #bevy_reflect_path::Reflect::get_type_info(reflect),
+                        from_kind: #bevy_reflect_path::Reflect::reflect_kind(reflect),
+                        to_type: <Self as #bevy_reflect_path::Typed>::type_info(),
+                    })?
+                ))
             }
         }
     })
 }
 
 /// Implements `FromReflect` for the given enum type
 pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
-    let fqoption = FQOption.into_token_stream();
+    let fqresult = FQResult.into_token_stream();
+    let fqbox = FQBox.into_token_stream();
+    let fqcow = FQCow.into_token_stream();
 
     let type_name = reflect_enum.meta().type_name();
     let bevy_reflect_path = reflect_enum.meta().bevy_reflect_path();
@@ -50,14 +59,31 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
         reflect_enum.meta().generics().split_for_impl();
     TokenStream::from(quote! {
         impl #impl_generics #bevy_reflect_path::FromReflect for #type_name #ty_generics #where_clause  {
-            fn from_reflect(#ref_value: &dyn #bevy_reflect_path::Reflect) -> #FQOption<Self> {
+            fn from_reflect(#ref_value: &dyn #bevy_reflect_path::Reflect) -> #FQResult<Self, #bevy_reflect_path::FromReflectError> {
                 if let #bevy_reflect_path::ReflectRef::Enum(#ref_value) = #bevy_reflect_path::Reflect::reflect_ref(#ref_value) {
                     match #bevy_reflect_path::Enum::variant_name(#ref_value) {
-                        #(#variant_names => #fqoption::Some(#variant_constructors),)*
-                        name => panic!("variant with name `{}` does not exist on enum `{}`", name, ::core::any::type_name::<Self>()),
+                        #(#variant_names => (|| #fqresult::Ok(#variant_constructors))().map_err(|err| {
+                            #bevy_reflect_path::FromReflectError::VariantError {
+                                from_type: #bevy_reflect_path::Reflect::get_type_info(#ref_value),
+                                from_kind: #bevy_reflect_path::Reflect::reflect_kind(#ref_value),
+                                to_type: <Self as #bevy_reflect_path::Typed>::type_info(),
+                                variant: #fqcow::Borrowed(#variant_names),
+                                source: #fqbox::new(err),
+                            }
+                        }),)*
+                        name => #FQResult::Err(#bevy_reflect_path::FromReflectError::MissingVariant {
+                            from_type: #bevy_reflect_path::Reflect::get_type_info(#ref_value),
+                            from_kind: #bevy_reflect_path::Reflect::reflect_kind(#ref_value),
+                            to_type: <Self as #bevy_reflect_path::Typed>::type_info(),
+                            variant: #fqcow::Owned(name.to_string()),
+                        }),
                     }
                 } else {
-                    #FQOption::None
+                    #FQResult::Err(#bevy_reflect_path::FromReflectError::InvalidType {
+                        from_type: #bevy_reflect_path::Reflect::get_type_info(#ref_value),
+                        from_kind: #bevy_reflect_path::Reflect::reflect_kind(#ref_value),
+                        to_type: <Self as #bevy_reflect_path::Typed>::type_info(),
+                    })
                 }
             }
         }
@@ -75,7 +101,7 @@ impl MemberValuePair {
 }
 
 fn impl_struct_internal(reflect_struct: &ReflectStruct, is_tuple: bool) -> TokenStream {
-    let fqoption = FQOption.into_token_stream();
+    let fqresult = FQResult.into_token_stream();
 
     let struct_name = reflect_struct.meta().type_name();
     let generics = reflect_struct.meta().generics();
@@ -92,23 +118,29 @@ fn impl_struct_internal(reflect_struct: &ReflectStruct, is_tuple: bool) -> Token
     let MemberValuePair(active_members, active_values) =
         get_active_fields(reflect_struct, &ref_struct, &ref_struct_type, is_tuple);
 
+    let error = quote!(#bevy_reflect_path::FromReflectError::InvalidType {
+        from_type: #bevy_reflect_path::Reflect::get_type_info(reflect),
+        from_kind: #bevy_reflect_path::Reflect::reflect_kind(reflect),
+        to_type: <Self as #bevy_reflect_path::Typed>::type_info(),
+    });
+
     let constructor = if reflect_struct.meta().traits().contains(REFLECT_DEFAULT) {
         quote!(
             let mut __this: Self = #FQDefault::default();
             #(
-                if let #fqoption::Some(__field) = #active_values() {
+                if let #fqresult::Ok(__field) = #active_values() {
                     // Iff field exists -> use its value
                     __this.#active_members = __field;
                 }
             )*
-            #FQOption::Some(__this)
+            #FQResult::Ok(__this)
         )
     } else {
         let MemberValuePair(ignored_members, ignored_values) =
             get_ignored_fields(reflect_struct, is_tuple);
 
         quote!(
-            #FQOption::Some(
+            #FQResult::Ok(
                 Self {
                     #(#active_members: #active_values()?,)*
                     #(#ignored_members: #ignored_values,)*
@@ -134,11 +166,11 @@ fn impl_struct_internal(reflect_struct: &ReflectStruct, is_tuple: bool) -> Token
     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) -> #FQOption<Self> {
+            fn from_reflect(reflect: &dyn #bevy_reflect_path::Reflect) -> #FQResult<Self, #bevy_reflect_path::FromReflectError> {
                 if let #bevy_reflect_path::ReflectRef::#ref_struct_type(#ref_struct) = #bevy_reflect_path::Reflect::reflect_ref(reflect) {
                     #constructor
                 } else {
-                    #FQOption::None
+                    #FQResult::Err(#error)
                 }
             }
         }
@@ -187,31 +219,65 @@ fn get_active_fields(
                 let accessor = get_field_accessor(field.data, field.index, is_tuple);
                 let ty = field.data.ty.clone();
 
+                let missing_error = if is_tuple {
+                    quote!(|| #bevy_reflect_path::FromReflectError::MissingUnnamedField {
+                        from_type: #bevy_reflect_path::Reflect::get_type_info(reflect),
+                        from_kind: #bevy_reflect_path::Reflect::reflect_kind(reflect),
+                        to_type: <Self as #bevy_reflect_path::Typed>::type_info(),
+                        index: #accessor,
+                    })
+                } else {
+                    quote!(|| #bevy_reflect_path::FromReflectError::MissingNamedField {
+                        from_type: #bevy_reflect_path::Reflect::get_type_info(reflect),
+                        from_kind: #bevy_reflect_path::Reflect::reflect_kind(reflect),
+                        to_type: <Self as #bevy_reflect_path::Typed>::type_info(),
+                        field: #accessor,
+                    })
+                };
+
                 let get_field = quote! {
-                    #bevy_reflect_path::#struct_type::field(#dyn_struct_name, #accessor)
+                    #bevy_reflect_path::#struct_type::field(#dyn_struct_name, #accessor).ok_or_else(#missing_error)
+                };
+
+                let error = if is_tuple {
+                    quote!(|err| #bevy_reflect_path::FromReflectError::UnnamedFieldError {
+                        from_type: #bevy_reflect_path::Reflect::get_type_info(reflect),
+                        from_kind: #bevy_reflect_path::Reflect::reflect_kind(reflect),
+                        to_type: <Self as #bevy_reflect_path::Typed>::type_info(),
+                        index: #accessor,
+                        source: #FQBox::new(err),
+                    })
+                } else {
+                    quote!(|err| #bevy_reflect_path::FromReflectError::NamedFieldError {
+                        from_type: #bevy_reflect_path::Reflect::get_type_info(reflect),
+                        from_kind: #bevy_reflect_path::Reflect::reflect_kind(reflect),
+                        to_type: <Self as #bevy_reflect_path::Typed>::type_info(),
+                        field: #accessor,
+                        source: #FQBox::new(err),
+                    })
                 };
 
                 let value = match &field.attrs.default {
                     DefaultBehavior::Func(path) => quote! {
                         (||
-                            if let #FQOption::Some(field) = #get_field {
-                                <#ty as #bevy_reflect_path::FromReflect>::from_reflect(field)
+                            if let #FQResult::Ok(field) = #get_field {
+                                <#ty as #bevy_reflect_path::FromReflect>::from_reflect(field).map_err(#error)
                             } else {
-                                #FQOption::Some(#path())
+                                #FQResult::Ok(#path())
                             }
                         )
                     },
                     DefaultBehavior::Default => quote! {
                         (||
-                            if let #FQOption::Some(field) = #get_field {
-                                <#ty as #bevy_reflect_path::FromReflect>::from_reflect(field)
+                            if let #FQResult::Ok(field) = #get_field {
+                                <#ty as #bevy_reflect_path::FromReflect>::from_reflect(field).map_err(#error)
                             } else {
-                                #FQOption::Some(#FQDefault::default())
+                                #FQResult::Ok(#FQDefault::default())
                             }
                         )
                     },
                     DefaultBehavior::Required => quote! {
-                        (|| <#ty as #bevy_reflect_path::FromReflect>::from_reflect(#get_field?))
+                        (|| <#ty as #bevy_reflect_path::FromReflect>::from_reflect(#get_field?).map_err(#error))
                     },
                 };
 

crates/bevy_reflect/bevy_reflect_derive/src/impls/enums.rs

@@ -262,6 +262,10 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
                 }
             }
 
+            fn reflect_kind(&self) -> #bevy_reflect_path::ReflectKind {
+                #bevy_reflect_path::ReflectKind::Enum
+            }
+
             fn reflect_ref(&self) -> #bevy_reflect_path::ReflectRef {
                 #bevy_reflect_path::ReflectRef::Enum(self)
             }

crates/bevy_reflect/bevy_reflect_derive/src/impls/structs.rs

@@ -224,6 +224,10 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> TokenStream {
                 }
             }
 
+            fn reflect_kind(&self) -> #bevy_reflect_path::ReflectKind {
+                #bevy_reflect_path::ReflectKind::Struct
+            }
+
             fn reflect_ref(&self) -> #bevy_reflect_path::ReflectRef {
                 #bevy_reflect_path::ReflectRef::Struct(self)
             }

crates/bevy_reflect/bevy_reflect_derive/src/impls/tuple_structs.rs

@@ -185,6 +185,10 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> TokenStream {
                 }
             }
 
+            fn reflect_kind(&self) -> #bevy_reflect_path::ReflectKind {
+                #bevy_reflect_path::ReflectKind::TupleStruct
+            }
+
             fn reflect_ref(&self) -> #bevy_reflect_path::ReflectRef {
                 #bevy_reflect_path::ReflectRef::TupleStruct(self)
             }

crates/bevy_reflect/bevy_reflect_derive/src/impls/values.rs

@@ -101,6 +101,10 @@ pub(crate) fn impl_value(meta: &ReflectMeta) -> TokenStream {
                 #FQResult::Ok(())
             }
 
+            fn reflect_kind(&self) -> #bevy_reflect_path::ReflectKind {
+                #bevy_reflect_path::ReflectKind::Value
+            }
+
             fn reflect_ref(&self) -> #bevy_reflect_path::ReflectRef {
                 #bevy_reflect_path::ReflectRef::Value(self)
             }

crates/bevy_reflect/src/array.rs

@@ -1,6 +1,6 @@
 use crate::{
-    utility::NonGenericTypeInfoCell, DynamicInfo, Reflect, ReflectMut, ReflectOwned, ReflectRef,
-    TypeInfo, Typed,
+    utility::NonGenericTypeInfoCell, DynamicInfo, Reflect, ReflectKind, ReflectMut, ReflectOwned,
+    ReflectRef, TypeInfo, Typed,
 };
 use std::{
     any::{Any, TypeId},
@@ -222,6 +222,11 @@ impl Reflect for DynamicArray {
         Ok(())
     }
 
+    #[inline]
+    fn reflect_kind(&self) -> ReflectKind {
+        ReflectKind::Array
+    }
+
     #[inline]
     fn reflect_ref(&self) -> ReflectRef {
         ReflectRef::Array(self)

crates/bevy_reflect/src/enums/dynamic_enum.rs

@@ -1,7 +1,7 @@
 use crate::utility::NonGenericTypeInfoCell;
 use crate::{
     enum_debug, enum_hash, enum_partial_eq, DynamicInfo, DynamicStruct, DynamicTuple, Enum,
-    Reflect, ReflectMut, ReflectOwned, ReflectRef, Struct, Tuple, TypeInfo, Typed,
+    Reflect, ReflectKind, ReflectMut, ReflectOwned, ReflectRef, Struct, Tuple, TypeInfo, Typed,
     VariantFieldIter, VariantType,
 };
 use std::any::Any;
@@ -386,6 +386,11 @@ impl Reflect for DynamicEnum {
         Ok(())
     }
 
+    #[inline]
+    fn reflect_kind(&self) -> ReflectKind {
+        ReflectKind::Enum
+    }
+
     #[inline]
     fn reflect_ref(&self) -> ReflectRef {
         ReflectRef::Enum(self)