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

crates/bevy_reflect/Cargo.toml

@@ -22,6 +22,7 @@ erased-serde = "0.3"
 downcast-rs = "1.2"
 parking_lot = "0.11.0"
 thiserror = "1.0"
+once_cell = "1.11"
 serde = "1"
 smallvec = { version = "1.6", features = ["serde", "union", "const_generics"], optional = true }
 glam = { version = "0.20.0", features = ["serde"], optional = true }

crates/bevy_reflect/bevy_reflect_derive/src/impls.rs

@@ -32,6 +32,10 @@ pub(crate) fn impl_struct(derive_data: &ReflectDeriveData) -> TokenStream {
                 .unwrap_or_else(|| Member::Unnamed(Index::from(field.index)))
         })
         .collect::<Vec<_>>();
+    let field_types = derive_data
+        .active_fields()
+        .map(|field| field.data.ty.clone())
+        .collect::<Vec<_>>();
     let field_count = field_idents.len();
     let field_indices = (0..field_count).collect::<Vec<usize>>();
 
@@ -49,12 +53,27 @@ pub(crate) fn impl_struct(derive_data: &ReflectDeriveData) -> TokenStream {
         });
     let debug_fn = derive_data.traits().get_debug_impl();
 
+    let typed_impl = impl_typed(
+        struct_name,
+        derive_data.generics(),
+        quote! {
+           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)
+        },
+        bevy_reflect_path,
+    );
+
     let get_type_registration_impl = derive_data.get_type_registration();
     let (impl_generics, ty_generics, where_clause) = derive_data.generics().split_for_impl();
 
     TokenStream::from(quote! {
         #get_type_registration_impl
 
+        #typed_impl
+
         impl #impl_generics #bevy_reflect_path::Struct for #struct_name #ty_generics #where_clause {
             fn field(&self, name: &str) -> Option<&dyn #bevy_reflect_path::Reflect> {
                 match name {
@@ -114,6 +133,11 @@ pub(crate) fn impl_struct(derive_data: &ReflectDeriveData) -> TokenStream {
                 std::any::type_name::<Self>()
             }
 
+            #[inline]
+            fn get_type_info(&self) -> &'static #bevy_reflect_path::TypeInfo {
+                <Self as #bevy_reflect_path::Typed>::type_info()
+            }
+
             #[inline]
             fn any(&self) -> &dyn std::any::Any {
                 self
@@ -184,6 +208,10 @@ pub(crate) fn impl_tuple_struct(derive_data: &ReflectDeriveData) -> TokenStream
         .active_fields()
         .map(|field| Member::Unnamed(Index::from(field.index)))
         .collect::<Vec<_>>();
+    let field_types = derive_data
+        .active_fields()
+        .map(|field| field.data.ty.clone())
+        .collect::<Vec<_>>();
     let field_count = field_idents.len();
     let field_indices = (0..field_count).collect::<Vec<usize>>();
 
@@ -201,10 +229,25 @@ pub(crate) fn impl_tuple_struct(derive_data: &ReflectDeriveData) -> TokenStream
         });
     let debug_fn = derive_data.traits().get_debug_impl();
 
+    let typed_impl = impl_typed(
+        struct_name,
+        derive_data.generics(),
+        quote! {
+            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)
+        },
+        bevy_reflect_path,
+    );
+
     let (impl_generics, ty_generics, where_clause) = derive_data.generics().split_for_impl();
     TokenStream::from(quote! {
         #get_type_registration_impl
 
+        #typed_impl
+
         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 {
@@ -243,6 +286,11 @@ pub(crate) fn impl_tuple_struct(derive_data: &ReflectDeriveData) -> TokenStream
                 std::any::type_name::<Self>()
             }
 
+            #[inline]
+            fn get_type_info(&self) -> &'static #bevy_reflect_path::TypeInfo {
+                <Self as #bevy_reflect_path::Typed>::type_info()
+            }
+
             #[inline]
             fn any(&self) -> &dyn std::any::Any {
                 self
@@ -315,17 +363,34 @@ pub(crate) fn impl_value(
     let partial_eq_fn = reflect_traits.get_partial_eq_impl(bevy_reflect_path);
     let debug_fn = reflect_traits.get_debug_impl();
 
+    let typed_impl = impl_typed(
+        type_name,
+        generics,
+        quote! {
+            let info = #bevy_reflect_path::ValueInfo::new::<Self>();
+            #bevy_reflect_path::TypeInfo::Value(info)
+        },
+        bevy_reflect_path,
+    );
+
     let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
     TokenStream::from(quote! {
         #get_type_registration_impl
 
+        #typed_impl
+
         // SAFE: any and any_mut both return self
         unsafe impl #impl_generics #bevy_reflect_path::Reflect for #type_name #ty_generics #where_clause  {
             #[inline]
             fn type_name(&self) -> &str {
                 std::any::type_name::<Self>()
             }
 
+            #[inline]
+            fn get_type_info(&self) -> &'static #bevy_reflect_path::TypeInfo {
+                <Self as #bevy_reflect_path::Typed>::type_info()
+            }
+
             #[inline]
             fn any(&self) -> &dyn std::any::Any {
                 self
@@ -385,3 +450,38 @@ pub(crate) fn impl_value(
         }
     })
 }
+
+fn impl_typed(
+    type_name: &Ident,
+    generics: &Generics,
+    generator: proc_macro2::TokenStream,
+    bevy_reflect_path: &Path,
+) -> proc_macro2::TokenStream {
+    let is_generic = !generics.params.is_empty();
+
+    let static_generator = if is_generic {
+        quote! {
+            static CELL: #bevy_reflect_path::utility::GenericTypeInfoCell = #bevy_reflect_path::utility::GenericTypeInfoCell::new();
+            CELL.get_or_insert::<Self, _>(|| {
+                #generator
+            })
+        }
+    } else {
+        quote! {
+            static CELL: #bevy_reflect_path::utility::NonGenericTypeInfoCell = #bevy_reflect_path::utility::NonGenericTypeInfoCell::new();
+            CELL.get_or_set(|| {
+                #generator
+            })
+        }
+    };
+
+    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+
+    quote! {
+        impl #impl_generics #bevy_reflect_path::Typed for #type_name #ty_generics #where_clause {
+            fn type_info() -> &'static #bevy_reflect_path::TypeInfo {
+                #static_generator
+            }
+        }
+    }
+}

crates/bevy_reflect/src/array.rs

@@ -1,6 +1,9 @@
-use crate::{serde::Serializable, Reflect, ReflectMut, ReflectRef};
+use crate::{
+    serde::Serializable, utility::NonGenericTypeInfoCell, DynamicInfo, Reflect, ReflectMut,
+    ReflectRef, TypeInfo, Typed,
+};
 use std::{
-    any::Any,
+    any::{Any, TypeId},
     fmt::Debug,
     hash::{Hash, Hasher},
 };
@@ -37,6 +40,73 @@ pub trait Array: Reflect {
     }
 }
 
+/// A container for compile-time array info.
+#[derive(Clone, Debug)]
+pub struct ArrayInfo {
+    type_name: &'static str,
+    type_id: TypeId,
+    item_type_name: &'static str,
+    item_type_id: TypeId,
+    capacity: usize,
+}
+
+impl ArrayInfo {
+    /// Create a new [`ArrayInfo`].
+    ///
+    /// # Arguments
+    ///
+    /// * `capacity`: The maximum capacity of the underlying array.
+    ///
+    pub fn new<TArray: Array, TItem: Reflect>(capacity: usize) -> Self {
+        Self {
+            type_name: std::any::type_name::<TArray>(),
+            type_id: TypeId::of::<TArray>(),
+            item_type_name: std::any::type_name::<TItem>(),
+            item_type_id: TypeId::of::<TItem>(),
+            capacity,
+        }
+    }
+
+    /// The compile-time capacity of the array.
+    pub fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    /// The [type name] of the array.
+    ///
+    /// [type name]: std::any::type_name
+    pub fn type_name(&self) -> &'static str {
+        self.type_name
+    }
+
+    /// The [`TypeId`] of the array.
+    pub fn type_id(&self) -> TypeId {
+        self.type_id
+    }
+
+    /// Check if the given type matches the array type.
+    pub fn is<T: Any>(&self) -> bool {
+        TypeId::of::<T>() == self.type_id
+    }
+
+    /// The [type name] of the array item.
+    ///
+    /// [type name]: std::any::type_name
+    pub fn item_type_name(&self) -> &'static str {
+        self.item_type_name
+    }
+
+    /// The [`TypeId`] of the array item.
+    pub fn item_type_id(&self) -> TypeId {
+        self.item_type_id
+    }
+
+    /// Check if the given type matches the array item type.
+    pub fn item_is<T: Any>(&self) -> bool {
+        TypeId::of::<T>() == self.item_type_id
+    }
+}
+
 /// A fixed-size list of reflected values.
 ///
 /// This differs from [`DynamicList`] in that the size of the [`DynamicArray`]
@@ -89,6 +159,11 @@ unsafe impl Reflect for DynamicArray {
         self.name.as_str()
     }
 
+    #[inline]
+    fn get_type_info(&self) -> &'static TypeInfo {
+        <Self as Typed>::type_info()
+    }
+
     #[inline]
     fn any(&self) -> &dyn Any {
         self
@@ -185,6 +260,13 @@ impl Array for DynamicArray {
     }
 }
 
+impl Typed for DynamicArray {
+    fn type_info() -> &'static TypeInfo {
+        static CELL: NonGenericTypeInfoCell = NonGenericTypeInfoCell::new();
+        CELL.get_or_set(|| TypeInfo::Dynamic(DynamicInfo::new::<Self>()))
+    }
+}
+
 /// An iterator over an [`Array`].
 pub struct ArrayIter<'a> {
     pub(crate) array: &'a dyn Array,

crates/bevy_reflect/src/fields.rs

@@ -0,0 +1,84 @@
+use crate::Reflect;
+use std::any::{Any, TypeId};
+use std::borrow::Cow;
+
+/// The named field of a reflected struct.
+#[derive(Clone, Debug)]
+pub struct NamedField {
+    name: Cow<'static, str>,
+    type_name: &'static str,
+    type_id: TypeId,
+}
+
+impl NamedField {
+    /// Create a new [`NamedField`].
+    pub fn new<T: Reflect, TName: Into<Cow<'static, str>>>(name: TName) -> Self {
+        Self {
+            name: name.into(),
+            type_name: std::any::type_name::<T>(),
+            type_id: TypeId::of::<T>(),
+        }
+    }
+
+    /// The name of the field.
+    pub fn name(&self) -> &Cow<'static, str> {
+        &self.name
+    }
+
+    /// The [type name] of the field.
+    ///
+    /// [type name]: std::any::type_name
+    pub fn type_name(&self) -> &'static str {
+        self.type_name
+    }
+
+    /// The [`TypeId`] of the field.
+    pub fn type_id(&self) -> TypeId {
+        self.type_id
+    }
+
+    /// Check if the given type matches the field type.
+    pub fn is<T: Any>(&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: &'static str,
+    type_id: TypeId,
+}
+
+impl UnnamedField {
+    pub fn new<T: Reflect>(index: usize) -> Self {
+        Self {
+            index,
+            type_name: std::any::type_name::<T>(),
+            type_id: TypeId::of::<T>(),
+        }
+    }
+
+    /// Returns the index of the field.
+    pub fn index(&self) -> usize {
+        self.index
+    }
+
+    /// The [type name] of the field.
+    ///
+    /// [type name]: std::any::type_name
+    pub fn type_name(&self) -> &'static str {
+        self.type_name
+    }
+
+    /// The [`TypeId`] of the field.
+    pub fn type_id(&self) -> TypeId {
+        self.type_id
+    }
+
+    /// Check if the given type matches the field type.
+    pub fn is<T: Any>(&self) -> bool {
+        TypeId::of::<T>() == self.type_id
+    }
+}