[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>>();
 
@@ -318,6 +322,16 @@ fn impl_struct(
                 #partial_eq_fn
             }
         }
+
+        impl #impl_generics #bevy_reflect_path::Typed for #struct_name #ty_generics #where_clause {
+            fn type_info() -> #bevy_reflect_path::TypeInfo {
+                let fields: [#bevy_reflect_path::NamedField; #field_count] = [
+                    #(#bevy_reflect_path::NamedField::static_new::<#field_types>(#field_names),)*
+                ];
+                let info = #bevy_reflect_path::StructInfo::new::<Self>(&fields);
+                #bevy_reflect_path::TypeInfo::Struct(info)
+            }
+        }
     })
 }
 
@@ -333,6 +347,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>>();
 
@@ -346,11 +364,11 @@ fn impl_tuple_struct(
         TraitImpl::Implemented | TraitImpl::Custom(_) => reflect_attrs.get_partial_eq_impl(),
     };
 
-    let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
     TokenStream::from(quote! {
         #get_type_registration_impl
 
-        impl #impl_generics #bevy_reflect_path::TupleStruct for #struct_name #ty_generics {
+        impl #impl_generics #bevy_reflect_path::TupleStruct for #struct_name #ty_generics #where_clause {
             fn field(&self, index: usize) -> Option<&dyn #bevy_reflect_path::Reflect> {
                 match index {
                     #(#field_indices => Some(&self.#field_idents),)*
@@ -382,7 +400,7 @@ fn impl_tuple_struct(
         }
 
         // SAFE: any and any_mut both return self
-        unsafe impl #impl_generics #bevy_reflect_path::Reflect for #struct_name #ty_generics {
+        unsafe impl #impl_generics #bevy_reflect_path::Reflect for #struct_name #ty_generics #where_clause {
             #[inline]
             fn type_name(&self) -> &str {
                 std::any::type_name::<Self>()
@@ -439,6 +457,16 @@ fn impl_tuple_struct(
                 #partial_eq_fn
             }
         }
+
+        impl #impl_generics #bevy_reflect_path::Typed for #struct_name #ty_generics #where_clause {
+            fn type_info() -> #bevy_reflect_path::TypeInfo {
+                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)
+            }
+        }
     })
 }
 
@@ -515,6 +543,13 @@ fn impl_value(
                 #serialize_fn
             }
         }
+
+        impl #impl_generics #bevy_reflect_path::Typed for #type_name #ty_generics #where_clause {
+            fn type_info() -> #bevy_reflect_path::TypeInfo {
+                let info = #bevy_reflect_path::ValueInfo::new::<Self>();
+                #bevy_reflect_path::TypeInfo::Value(info)
+            }
+        }
     })
 }
 struct ReflectDef {

crates/bevy_reflect/src/fields.rs

@@ -0,0 +1,66 @@
+use crate::{Reflect, TypeIdentity};
+use std::borrow::Cow;
+
+/// The named field of a reflected struct
+#[derive(Clone, Debug)]
+pub struct NamedField {
+    name: Cow<'static, str>,
+    id: TypeIdentity,
+}
+
+impl NamedField {
+    /// Create a new [`NamedField`]
+    pub fn new<T: Reflect>(name: &str) -> Self {
+        Self {
+            name: Cow::Owned(name.into()),
+            id: TypeIdentity::of::<T>(),
+        }
+    }
+
+    /// Create a new [`NamedField`] using a static string
+    ///
+    /// This helps save an allocation when the string has a static lifetime, such
+    /// as when using [`std::any::type_name`].
+    pub fn static_new<T: Reflect>(name: &'static str) -> Self {
+        Self {
+            name: Cow::Borrowed(name),
+            id: TypeIdentity::of::<T>(),
+        }
+    }
+
+    /// The name of the field
+    pub fn name(&self) -> &Cow<'static, str> {
+        &self.name
+    }
+
+    /// The [`TypeIdentity`] of the field
+    pub fn id(&self) -> &TypeIdentity {
+        &self.id
+    }
+}
+
+/// The unnamed field of a reflected tuple or tuple struct
+#[derive(Clone, Debug)]
+pub struct UnnamedField {
+    index: usize,
+    id: TypeIdentity,
+}
+
+impl UnnamedField {
+    pub fn new<T: Reflect>(index: usize) -> Self {
+        Self {
+            index,
+            id: TypeIdentity::of::<T>(),
+        }
+    }
+
+    /// Returns the index of the field
+    pub fn index(&self) -> usize {
+        self.index
+    }
+
+    /// The [`TypeIdentity`] of the field
+    pub fn id(&self) -> &TypeIdentity {
+        &self.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, Typed,
+};
 
 impl<T: Array + Send + Sync + 'static> List for SmallVec<T>
 where
@@ -98,6 +101,15 @@ where
     }
 }
 
+impl<T: Array + Send + Sync + 'static> Typed for SmallVec<T>
+where
+    T::Item: FromReflect + Clone,
+{
+    fn type_info() -> TypeInfo {
+        TypeInfo::List(ListInfo::new::<Self, T::Item>(Some(T::size())))
+    }
+}
+
 impl<T: Array + Send + Sync + 'static> FromReflect for SmallVec<T>
 where
     T::Item: FromReflect + Clone,

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, Typed, ValueInfo,
 };
 
 use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value};
@@ -144,6 +144,12 @@ unsafe impl<T: FromReflect> Reflect for Vec<T> {
     }
 }
 
+impl<T: FromReflect> Typed for Vec<T> {
+    fn type_info() -> TypeInfo {
+        TypeInfo::List(ListInfo::new::<Self, T>(None))
+    }
+}
+
 impl<T: FromReflect + for<'de> Deserialize<'de>> GetTypeRegistration for Vec<T> {
     fn get_type_registration() -> TypeRegistration {
         let mut registration = TypeRegistration::of::<Vec<T>>();
@@ -262,6 +268,12 @@ unsafe impl<K: Reflect + Eq + Hash, V: Reflect> Reflect for HashMap<K, V> {
     }
 }
 
+impl<K: Reflect + Eq + Hash, V: Reflect> Typed for HashMap<K, V> {
+    fn type_info() -> TypeInfo {
+        TypeInfo::Map(MapInfo::new::<Self, K, V>())
+    }
+}
+
 impl<K, V> GetTypeRegistration for HashMap<K, V>
 where
     K: Reflect + Clone + Eq + Hash + for<'de> Deserialize<'de>,
@@ -351,6 +363,12 @@ unsafe impl Reflect for Cow<'static, str> {
     }
 }
 
+impl Typed for Cow<'static, str> {
+    fn type_info() -> TypeInfo {
+        TypeInfo::Value(ValueInfo::new::<Self>())
+    }
+}
+
 impl GetTypeRegistration for Cow<'static, str> {
     fn get_type_registration() -> TypeRegistration {
         let mut registration = TypeRegistration::of::<Cow<'static, str>>();