bevy_reflect: Add ReflectRef/ReflectMut/ReflectOwned convenience casting methods (#15235)

# Objective

#13320 added convenience methods for casting a `TypeInfo` into its
respective variant:

```rust
let info: &TypeInfo = <Vec<i32> as Typed>::type_info();

// We know `info` contains a `ListInfo`, so we can simply cast it:
let list_info: &ListInfo = info.as_list().unwrap();
```

This is especially helpful when you have already verified a type is a
certain kind via `ReflectRef`, `ReflectMut`, `ReflectOwned`, or
`ReflectKind`.

As mentioned in that PR, though, it would be useful to add similar
convenience methods to those types as well.

## Solution

Added convenience casting methods to `ReflectRef`, `ReflectMut`, and
`ReflectOwned`.

With these methods, I was able to reduce our nesting in certain places
throughout the crate.

Additionally, I took this opportunity to move these types (and
`ReflectKind`) to their own module to help clean up the `reflect`
module.

## Testing

You can test locally by running:

```
cargo test --package bevy_reflect --all-features
```

---

## Showcase

Convenience methods for casting `ReflectRef`, `ReflectMut`, and
`ReflectOwned` into their respective variants has been added! This
allows you to write cleaner code if you already know the kind of your
reflected data:

```rust
// BEFORE
let ReflectRef::List(list) = list.reflect_ref() else {
    panic!("expected list");
};

// AFTER
let list = list.reflect_ref().as_list().unwrap();
```

---------

Co-authored-by: Alice Cecile <[email protected]>
Co-authored-by: Pablo Reinhardt <[email protected]>

Author: 3 people

crates/bevy_asset/src/reflect.rs

@@ -249,7 +249,7 @@ mod tests {
     use crate::{Asset, AssetApp, AssetPlugin, ReflectAsset, UntypedHandle};
     use bevy_app::App;
     use bevy_ecs::reflect::AppTypeRegistry;
-    use bevy_reflect::{Reflect, ReflectMut};
+    use bevy_reflect::Reflect;
 
     #[derive(Asset, Reflect)]
     struct AssetType {
@@ -278,13 +278,13 @@ mod tests {
         };
 
         let handle = reflect_asset.add(app.world_mut(), &value);
-        let ReflectMut::Struct(strukt) = reflect_asset
+        // struct is a reserved keyword, so we can't use it here
+        let strukt = reflect_asset
             .get_mut(app.world_mut(), handle)
             .unwrap()
             .reflect_mut()
-        else {
-            unreachable!();
-        };
+            .as_struct()
+            .unwrap();
         strukt
             .field_mut("field")
             .unwrap()

crates/bevy_reflect/src/array.rs

@@ -436,23 +436,20 @@ pub fn array_try_apply<A: Array>(
     array: &mut A,
     reflect: &dyn PartialReflect,
 ) -> Result<(), ApplyError> {
-    if let ReflectRef::Array(reflect_array) = reflect.reflect_ref() {
-        if array.len() != reflect_array.len() {
-            return Err(ApplyError::DifferentSize {
-                from_size: reflect_array.len(),
-                to_size: array.len(),
-            });
-        }
-        for (i, value) in reflect_array.iter().enumerate() {
-            let v = array.get_mut(i).unwrap();
-            v.try_apply(value)?;
-        }
-    } else {
-        return Err(ApplyError::MismatchedKinds {
-            from_kind: reflect.reflect_kind(),
-            to_kind: ReflectKind::Array,
+    let reflect_array = reflect.reflect_ref().as_array()?;
+
+    if array.len() != reflect_array.len() {
+        return Err(ApplyError::DifferentSize {
+            from_size: reflect_array.len(),
+            to_size: array.len(),
         });
     }
+
+    for (i, value) in reflect_array.iter().enumerate() {
+        let v = array.get_mut(i).unwrap();
+        v.try_apply(value)?;
+    }
+
     Ok(())
 }
 
@@ -507,7 +504,7 @@ pub fn array_debug(dyn_array: &dyn Array, f: &mut Formatter<'_>) -> std::fmt::Re
 }
 #[cfg(test)]
 mod tests {
-    use crate::{Reflect, ReflectRef};
+    use crate::Reflect;
     #[test]
     fn next_index_increment() {
         const SIZE: usize = if cfg!(debug_assertions) {
@@ -519,9 +516,7 @@ mod tests {
 
         let b = Box::new([(); SIZE]).into_reflect();
 
-        let ReflectRef::Array(array) = b.reflect_ref() else {
-            panic!("Not an array...");
-        };
+        let array = b.reflect_ref().as_array().unwrap();
 
         let mut iter = array.iter();
         iter.index = SIZE - 1;

crates/bevy_reflect/src/enums/dynamic_enum.rs

@@ -322,55 +322,50 @@ impl PartialReflect for DynamicEnum {
 
     #[inline]
     fn try_apply(&mut self, value: &dyn PartialReflect) -> Result<(), ApplyError> {
-        if let ReflectRef::Enum(value) = value.reflect_ref() {
-            if Enum::variant_name(self) == value.variant_name() {
-                // Same variant -> just update fields
-                match value.variant_type() {
-                    VariantType::Struct => {
-                        for field in value.iter_fields() {
-                            let name = field.name().unwrap();
-                            if let Some(v) = Enum::field_mut(self, name) {
-                                v.try_apply(field.value())?;
-                            }
+        let value = value.reflect_ref().as_enum()?;
+
+        if Enum::variant_name(self) == value.variant_name() {
+            // Same variant -> just update fields
+            match value.variant_type() {
+                VariantType::Struct => {
+                    for field in value.iter_fields() {
+                        let name = field.name().unwrap();
+                        if let Some(v) = Enum::field_mut(self, name) {
+                            v.try_apply(field.value())?;
                         }
                     }
-                    VariantType::Tuple => {
-                        for (index, field) in value.iter_fields().enumerate() {
-                            if let Some(v) = Enum::field_at_mut(self, index) {
-                                v.try_apply(field.value())?;
-                            }
-                        }
-                    }
-                    _ => {}
                 }
-            } else {
-                // New variant -> perform a switch
-                let dyn_variant = match value.variant_type() {
-                    VariantType::Unit => DynamicVariant::Unit,
-                    VariantType::Tuple => {
-                        let mut dyn_tuple = DynamicTuple::default();
-                        for field in value.iter_fields() {
-                            dyn_tuple.insert_boxed(field.value().clone_value());
+                VariantType::Tuple => {
+                    for (index, field) in value.iter_fields().enumerate() {
+                        if let Some(v) = Enum::field_at_mut(self, index) {
+                            v.try_apply(field.value())?;
                         }
-                        DynamicVariant::Tuple(dyn_tuple)
                     }
-                    VariantType::Struct => {
-                        let mut dyn_struct = DynamicStruct::default();
-                        for field in value.iter_fields() {
-                            dyn_struct
-                                .insert_boxed(field.name().unwrap(), field.value().clone_value());
-                        }
-                        DynamicVariant::Struct(dyn_struct)
-                    }
-                };
-                self.set_variant(value.variant_name(), dyn_variant);
+                }
+                _ => {}
             }
         } else {
-            return Err(ApplyError::MismatchedKinds {
-                from_kind: value.reflect_kind(),
-                to_kind: ReflectKind::Enum,
-            });
+            // New variant -> perform a switch
+            let dyn_variant = match value.variant_type() {
+                VariantType::Unit => DynamicVariant::Unit,
+                VariantType::Tuple => {
+                    let mut dyn_tuple = DynamicTuple::default();
+                    for field in value.iter_fields() {
+                        dyn_tuple.insert_boxed(field.value().clone_value());
+                    }
+                    DynamicVariant::Tuple(dyn_tuple)
+                }
+                VariantType::Struct => {
+                    let mut dyn_struct = DynamicStruct::default();
+                    for field in value.iter_fields() {
+                        dyn_struct.insert_boxed(field.name().unwrap(), field.value().clone_value());
+                    }
+                    DynamicVariant::Struct(dyn_struct)
+                }
+            };
+            self.set_variant(value.variant_name(), dyn_variant);
         }
+
         Ok(())
     }
 

crates/bevy_reflect/src/impls/smallvec.rs

@@ -194,15 +194,15 @@ where
     T::Item: FromReflect + MaybeTyped + TypePath,
 {
     fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
-        if let ReflectRef::List(ref_list) = reflect.reflect_ref() {
-            let mut new_list = Self::with_capacity(ref_list.len());
-            for field in ref_list.iter() {
-                new_list.push(<T as SmallArray>::Item::from_reflect(field)?);
-            }
-            Some(new_list)
-        } else {
-            None
+        let ref_list = reflect.reflect_ref().as_list().ok()?;
+
+        let mut new_list = Self::with_capacity(ref_list.len());
+
+        for field in ref_list.iter() {
+            new_list.push(<T as SmallArray>::Item::from_reflect(field)?);
         }
+
+        Some(new_list)
     }
 }
 

crates/bevy_reflect/src/impls/std.rs

@@ -544,15 +544,15 @@ macro_rules! impl_reflect_for_veclike {
 
         impl<T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration> FromReflect for $ty {
             fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
-                if let ReflectRef::List(ref_list) = reflect.reflect_ref() {
-                    let mut new_list = Self::with_capacity(ref_list.len());
-                    for field in ref_list.iter() {
-                        $push(&mut new_list, T::from_reflect(field)?);
-                    }
-                    Some(new_list)
-                } else {
-                    None
+                let ref_list = reflect.reflect_ref().as_list().ok()?;
+
+                let mut new_list = Self::with_capacity(ref_list.len());
+
+                for field in ref_list.iter() {
+                    $push(&mut new_list, T::from_reflect(field)?);
                 }
+
+                Some(new_list)
             }
         }
     };
@@ -792,17 +792,17 @@ macro_rules! impl_reflect_for_hashmap {
             S: TypePath + BuildHasher + Default + Send + Sync,
         {
             fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
-                if let ReflectRef::Map(ref_map) = reflect.reflect_ref() {
-                    let mut new_map = Self::with_capacity_and_hasher(ref_map.len(), S::default());
-                    for (key, value) in ref_map.iter() {
-                        let new_key = K::from_reflect(key)?;
-                        let new_value = V::from_reflect(value)?;
-                        new_map.insert(new_key, new_value);
-                    }
-                    Some(new_map)
-                } else {
-                    None
+                let ref_map = reflect.reflect_ref().as_map().ok()?;
+
+                let mut new_map = Self::with_capacity_and_hasher(ref_map.len(), S::default());
+
+                for (key, value) in ref_map.iter() {
+                    let new_key = K::from_reflect(key)?;
+                    let new_value = V::from_reflect(value)?;
+                    new_map.insert(new_key, new_value);
                 }
+
+                Some(new_map)
             }
         }
     };
@@ -1013,16 +1013,16 @@ macro_rules! impl_reflect_for_hashset {
             S: TypePath + BuildHasher + Default + Send + Sync,
         {
             fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
-                if let ReflectRef::Set(ref_set) = reflect.reflect_ref() {
-                    let mut new_set = Self::with_capacity_and_hasher(ref_set.len(), S::default());
-                    for value in ref_set.iter() {
-                        let new_value = V::from_reflect(value)?;
-                        new_set.insert(new_value);
-                    }
-                    Some(new_set)
-                } else {
-                    None
+                let ref_set = reflect.reflect_ref().as_set().ok()?;
+
+                let mut new_set = Self::with_capacity_and_hasher(ref_set.len(), S::default());
+
+                for value in ref_set.iter() {
+                    let new_value = V::from_reflect(value)?;
+                    new_set.insert(new_value);
                 }
+
+                Some(new_set)
             }
         }
     };
@@ -1251,17 +1251,17 @@ where
     V: FromReflect + MaybeTyped + TypePath + GetTypeRegistration,
 {
     fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
-        if let ReflectRef::Map(ref_map) = reflect.reflect_ref() {
-            let mut new_map = Self::new();
-            for (key, value) in ref_map.iter() {
-                let new_key = K::from_reflect(key)?;
-                let new_value = V::from_reflect(value)?;
-                new_map.insert(new_key, new_value);
-            }
-            Some(new_map)
-        } else {
-            None
+        let ref_map = reflect.reflect_ref().as_map().ok()?;
+
+        let mut new_map = Self::new();
+
+        for (key, value) in ref_map.iter() {
+            let new_key = K::from_reflect(key)?;
+            let new_value = V::from_reflect(value)?;
+            new_map.insert(new_key, new_value);
         }
+
+        Some(new_map)
     }
 }
 
@@ -1422,15 +1422,15 @@ impl<T: FromReflect + MaybeTyped + TypePath + GetTypeRegistration, const N: usiz
     for [T; N]
 {
     fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
-        if let ReflectRef::Array(ref_array) = reflect.reflect_ref() {
-            let mut temp_vec = Vec::with_capacity(ref_array.len());
-            for field in ref_array.iter() {
-                temp_vec.push(T::from_reflect(field)?);
-            }
-            temp_vec.try_into().ok()
-        } else {
-            None
+        let ref_array = reflect.reflect_ref().as_array().ok()?;
+
+        let mut temp_vec = Vec::with_capacity(ref_array.len());
+
+        for field in ref_array.iter() {
+            temp_vec.push(T::from_reflect(field)?);
         }
+
+        temp_vec.try_into().ok()
     }
 }
 
@@ -1795,15 +1795,15 @@ impl<T: FromReflect + MaybeTyped + Clone + TypePath + GetTypeRegistration> FromR
     for Cow<'static, [T]>
 {
     fn from_reflect(reflect: &dyn PartialReflect) -> Option<Self> {
-        if let ReflectRef::List(ref_list) = reflect.reflect_ref() {
-            let mut temp_vec = Vec::with_capacity(ref_list.len());
-            for field in ref_list.iter() {
-                temp_vec.push(T::from_reflect(field)?);
-            }
-            Some(temp_vec.into())
-        } else {
-            None
+        let ref_list = reflect.reflect_ref().as_list().ok()?;
+
+        let mut temp_vec = Vec::with_capacity(ref_list.len());
+
+        for field in ref_list.iter() {
+            temp_vec.push(T::from_reflect(field)?);
         }
+
+        Some(temp_vec.into())
     }
 }