[Merged by Bors] - bevy_reflect: Add statically available type info for reflected types

crates/bevy_reflect/bevy_reflect_derive/src/lib.rs

@@ -189,6 +189,10 @@ fn impl_struct(
                 .unwrap_or_else(|| Member::Unnamed(Index::from(*index)))
         })
         .collect::<Vec<_>>();
+    let field_types = active_fields
+        .iter()
+        .map(|(field, _index)| field.ty.clone())
+        .collect::<Vec<_>>();
     let field_count = active_fields.len();
     let field_indices = (0..field_count).collect::<Vec<usize>>();
 
@@ -317,6 +321,14 @@ fn impl_struct(
             fn reflect_partial_eq(&self, value: &dyn #bevy_reflect_path::Reflect) -> Option<bool> {
                 #partial_eq_fn
             }
+
+            fn type_info() -> #bevy_reflect_path::TypeInfo where Self: Sized {
+                let fields: [#bevy_reflect_path::NamedField; #field_count] = [
+                    #(#bevy_reflect_path::NamedField::new::<#field_types>(#field_names),)*
+                ];
+                let info = #bevy_reflect_path::StructInfo::new::<Self>(&fields);
+                #bevy_reflect_path::TypeInfo::Struct(info)
+            }
         }
     })
 }
@@ -333,6 +345,10 @@ fn impl_tuple_struct(
         .iter()
         .map(|(_field, index)| Member::Unnamed(Index::from(*index)))
         .collect::<Vec<_>>();
+    let field_types = active_fields
+        .iter()
+        .map(|(field, _index)| field.ty.clone())
+        .collect::<Vec<_>>();
     let field_count = active_fields.len();
     let field_indices = (0..field_count).collect::<Vec<usize>>();
 
@@ -438,6 +454,14 @@ fn impl_tuple_struct(
             fn reflect_partial_eq(&self, value: &dyn #bevy_reflect_path::Reflect) -> Option<bool> {
                 #partial_eq_fn
             }
+
+            fn type_info() -> #bevy_reflect_path::TypeInfo where Self: Sized {
+                let fields: [#bevy_reflect_path::UnnamedField; #field_count] = [
+                    #(#bevy_reflect_path::UnnamedField::new::<#field_types>(#field_indices),)*
+                ];
+                let info = #bevy_reflect_path::TupleStructInfo::new::<Self>(&fields);
+                #bevy_reflect_path::TypeInfo::TupleStruct(info)
+            }
         }
     })
 }
@@ -514,6 +538,11 @@ fn impl_value(
             fn serializable(&self) -> Option<#bevy_reflect_path::serde::Serializable> {
                 #serialize_fn
             }
+
+            fn type_info() -> #bevy_reflect_path::TypeInfo where Self: Sized {
+                let info = #bevy_reflect_path::ValueInfo::new::<Self>();
+                #bevy_reflect_path::TypeInfo::Value(info)
+            }
         }
     })
 }

crates/bevy_reflect/src/fields.rs

@@ -0,0 +1,79 @@
+use crate::Reflect;
+use std::any::TypeId;
+use std::borrow::{Borrow, Cow};
+
+/// The named field of a reflected struct
+#[derive(Clone, Debug)]
+pub struct NamedField {
+    name: Cow<'static, str>,
+    type_name: Cow<'static, str>,
+    type_id: TypeId,
+}
+
+impl NamedField {
+    pub fn new<T: Reflect>(name: &str) -> Self {
+        Self {
+            name: Cow::Owned(name.into()),
+            type_name: Cow::Owned(std::any::type_name::<T>().to_string()),
+            type_id: TypeId::of::<T>(),
+        }
+    }
+
+    /// The name of the field
+    pub fn name(&self) -> &str {
+        self.name.borrow()
+    }
+
+    /// The type name of the field
+    pub fn type_name(&self) -> &str {
+        self.type_name.borrow()
+    }
+
+    /// The `TypeId` of the field
+    pub fn type_id(&self) -> TypeId {
+        self.type_id
+    }
+
+    /// Check if the given type matches this field's type
+    pub fn is<T: Reflect>(&self) -> bool {
+        TypeId::of::<T>() == self.type_id
+    }
+}
+
+/// The unnamed field of a reflected tuple or tuple struct
+#[derive(Clone, Debug)]
+pub struct UnnamedField {
+    index: usize,
+    type_name: Cow<'static, str>,
+    type_id: TypeId,
+}
+
+impl UnnamedField {
+    pub fn new<T: Reflect>(index: usize) -> Self {
+        Self {
+            index,
+            type_name: Cow::Owned(std::any::type_name::<T>().to_string()),
+            type_id: TypeId::of::<T>(),
+        }
+    }
+
+    /// Returns the index of the field
+    pub fn index(&self) -> usize {
+        self.index
+    }
+
+    /// The type name of the field
+    pub fn type_name(&self) -> &str {
+        self.type_name.borrow()
+    }
+
+    /// The `TypeId` of the field
+    pub fn type_id(&self) -> TypeId {
+        self.type_id
+    }
+
+    /// Check if the given type matches this field's type
+    pub fn is<T: Reflect>(&self) -> bool {
+        TypeId::of::<T>() == self.type_id
+    }
+}

crates/bevy_reflect/src/impls/smallvec.rs

@@ -1,7 +1,10 @@
 use smallvec::{Array, SmallVec};
 use std::any::Any;
 
-use crate::{serde::Serializable, FromReflect, List, ListIter, Reflect, ReflectMut, ReflectRef};
+use crate::{
+    serde::Serializable, FromReflect, List, ListInfo, ListIter, Reflect, ReflectMut, ReflectRef,
+    TypeInfo,
+};
 
 impl<T: Array + Send + Sync + 'static> List for SmallVec<T>
 where
@@ -96,6 +99,13 @@ where
     fn serializable(&self) -> Option<Serializable> {
         None
     }
+
+    fn type_info() -> TypeInfo
+    where
+        Self: Sized,
+    {
+        TypeInfo::List(ListInfo::new::<Self, T::Item>(Some(T::size())))
+    }
 }
 
 impl<T: Array + Send + Sync + 'static> FromReflect for SmallVec<T>

crates/bevy_reflect/src/impls/std.rs

@@ -1,8 +1,8 @@
 use crate as bevy_reflect;
 use crate::{
     map_partial_eq, serde::Serializable, DynamicMap, FromReflect, FromType, GetTypeRegistration,
-    List, ListIter, Map, MapIter, Reflect, ReflectDeserialize, ReflectMut, ReflectRef,
-    TypeRegistration,
+    List, ListInfo, ListIter, Map, MapInfo, MapIter, Reflect, ReflectDeserialize, ReflectMut,
+    ReflectRef, TypeInfo, TypeRegistration, ValueInfo,
 };
 
 use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value};
@@ -142,6 +142,13 @@ unsafe impl<T: FromReflect> Reflect for Vec<T> {
     fn serializable(&self) -> Option<Serializable> {
         None
     }
+
+    fn type_info() -> TypeInfo
+    where
+        Self: Sized,
+    {
+        TypeInfo::List(ListInfo::new::<Self, T>(None))
+    }
 }
 
 impl<T: FromReflect + for<'de> Deserialize<'de>> GetTypeRegistration for Vec<T> {
@@ -260,6 +267,13 @@ unsafe impl<K: Reflect + Eq + Hash, V: Reflect> Reflect for HashMap<K, V> {
     fn serializable(&self) -> Option<Serializable> {
         None
     }
+
+    fn type_info() -> TypeInfo
+    where
+        Self: Sized,
+    {
+        TypeInfo::Map(MapInfo::new::<Self, K, V>())
+    }
 }
 
 impl<K, V> GetTypeRegistration for HashMap<K, V>
@@ -349,6 +363,13 @@ unsafe impl Reflect for Cow<'static, str> {
     fn serializable(&self) -> Option<Serializable> {
         Some(Serializable::Borrowed(self))
     }
+
+    fn type_info() -> TypeInfo
+    where
+        Self: Sized,
+    {
+        TypeInfo::Value(ValueInfo::new::<Self>())
+    }
 }
 
 impl GetTypeRegistration for Cow<'static, str> {