stable reflect type name

crates/bevy_animation/src/lib.rs

@@ -17,7 +17,7 @@ use bevy_ecs::{
 };
 use bevy_hierarchy::Children;
 use bevy_math::{Quat, Vec3};
-use bevy_reflect::{Reflect, TypeUuid};
+use bevy_reflect::{Reflect, TypeName, TypeUuid};
 use bevy_time::Time;
 use bevy_transform::{prelude::Transform, TransformSystem};
 use bevy_utils::{tracing::warn, HashMap};
@@ -60,7 +60,7 @@ pub struct EntityPath {
 }
 
 /// A list of [`VariableCurve`], and the [`EntityPath`] to which they apply.
-#[derive(Clone, TypeUuid, Debug, Default)]
+#[derive(Clone, TypeUuid, Debug, Default, TypeName)]
 #[uuid = "d81b7179-0448-4eb0-89fe-c067222725bf"]
 pub struct AnimationClip {
     curves: HashMap<EntityPath, Vec<VariableCurve>>,

crates/bevy_asset/src/asset_server.rs

@@ -88,7 +88,7 @@ pub struct AssetServerInternal {
 /// use bevy_asset::{AssetServer, Handle};
 /// use bevy_ecs::prelude::{Commands, Res};
 ///
-/// # #[derive(Debug, bevy_reflect::TypeUuid)]
+/// # #[derive(Debug, bevy_reflect::TypeUuid, bevy_reflect::TypeName)]
 /// # #[uuid = "00000000-0000-0000-0000-000000000000"]
 /// # struct Image;
 ///
@@ -647,10 +647,11 @@ mod test {
     use crate::{loader::LoadedAsset, update_asset_storage_system};
     use bevy_app::App;
     use bevy_ecs::prelude::*;
-    use bevy_reflect::TypeUuid;
+    use bevy_reflect::{TypeName, TypeUuid};
     use bevy_utils::BoxedFuture;
 
-    #[derive(Debug, TypeUuid)]
+    // FIXME: reflect only the type name
+    #[derive(Debug, TypeUuid, TypeName)]
     #[uuid = "a5189b72-0572-4290-a2e0-96f73a491c44"]
     struct PngAsset;
 

crates/bevy_asset/src/assets.rs

@@ -420,12 +420,13 @@ macro_rules! load_internal_asset {
 #[cfg(test)]
 mod tests {
     use bevy_app::App;
+    use bevy_reflect::TypeName;
 
     use crate::{AddAsset, Assets};
 
     #[test]
     fn asset_overwriting() {
-        #[derive(bevy_reflect::TypeUuid)]
+        #[derive(bevy_reflect::TypeUuid, TypeName)]
         #[uuid = "44115972-f31b-46e5-be5c-2b9aece6a52f"]
         struct MyAsset;
         let mut app = App::new();

crates/bevy_asset/src/loader.rs

@@ -5,6 +5,7 @@ use crate::{
 use anyhow::Error;
 use anyhow::Result;
 use bevy_ecs::system::{Res, ResMut};
+use bevy_reflect::TypeName;
 use bevy_reflect::{TypeUuid, TypeUuidDynamic};
 use bevy_utils::{BoxedFuture, HashMap};
 use crossbeam_channel::{Receiver, Sender};
@@ -47,13 +48,13 @@ pub trait AssetLoader: Send + Sync + 'static {
 ///
 /// In order to load assets into your game you must either add them manually to an asset storage
 /// with [`Assets::add`] or load them from the filesystem with [`AssetServer::load`].
-pub trait Asset: TypeUuid + AssetDynamic {}
+pub trait Asset: TypeUuid + AssetDynamic + TypeName {}
 
 /// An untyped version of the [`Asset`] trait.
 pub trait AssetDynamic: Downcast + TypeUuidDynamic + Send + Sync + 'static {}
 impl_downcast!(AssetDynamic);
 
-impl<T> Asset for T where T: TypeUuid + AssetDynamic + TypeUuidDynamic {}
+impl<T> Asset for T where T: TypeUuid + AssetDynamic + TypeUuidDynamic + TypeName {}
 
 impl<T> AssetDynamic for T where T: Send + Sync + 'static + TypeUuidDynamic {}
 

crates/bevy_audio/src/audio_output.rs

@@ -1,7 +1,7 @@
 use crate::{Audio, AudioSource, Decodable};
 use bevy_asset::{Asset, Assets};
 use bevy_ecs::system::{NonSend, Res, ResMut};
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{TypeName, TypeUuid};
 use bevy_utils::tracing::warn;
 use rodio::{OutputStream, OutputStreamHandle, Sink, Source};
 use std::marker::PhantomData;
@@ -116,7 +116,7 @@ pub fn play_queued_audio_system<Source: Asset + Decodable>(
 /// }
 /// ```
 ///
-#[derive(TypeUuid)]
+#[derive(TypeUuid, TypeName)]
 #[uuid = "8BEE570C-57C2-4FC0-8CFB-983A22F7D981"]
 pub struct AudioSink {
     // This field is an Option in order to allow us to have a safe drop that will detach the sink.

crates/bevy_audio/src/audio_source.rs

@@ -1,11 +1,11 @@
 use anyhow::Result;
 use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{TypeName, TypeUuid};
 use bevy_utils::BoxedFuture;
 use std::{io::Cursor, sync::Arc};
 
 /// A source of audio data
-#[derive(Debug, Clone, TypeUuid)]
+#[derive(Debug, Clone, TypeUuid, TypeName)]
 #[uuid = "7a14806a-672b-443b-8d16-4f18afefa463"]
 pub struct AudioSource {
     /// Raw data of the audio source

crates/bevy_gltf/src/lib.rs

@@ -9,7 +9,7 @@ use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Handle};
 use bevy_ecs::{prelude::Component, reflect::ReflectComponent};
 use bevy_pbr::StandardMaterial;
-use bevy_reflect::{Reflect, TypeUuid};
+use bevy_reflect::{Reflect, TypeName, TypeUuid};
 use bevy_render::mesh::Mesh;
 use bevy_scene::Scene;
 
@@ -29,7 +29,7 @@ impl Plugin for GltfPlugin {
 }
 
 /// Representation of a loaded glTF file.
-#[derive(Debug, TypeUuid)]
+#[derive(Debug, TypeUuid, TypeName)]
 #[uuid = "5c7d5f8a-f7b0-4e45-a09e-406c0372fea2"]
 pub struct Gltf {
     pub scenes: Vec<Handle<Scene>>,
@@ -49,7 +49,7 @@ pub struct Gltf {
 
 /// A glTF node with all of its child nodes, its [`GltfMesh`] and
 /// [`Transform`](bevy_transform::prelude::Transform).
-#[derive(Debug, Clone, TypeUuid)]
+#[derive(Debug, Clone, TypeUuid, TypeName)]
 #[uuid = "dad74750-1fd6-460f-ac51-0a7937563865"]
 pub struct GltfNode {
     pub children: Vec<GltfNode>,
@@ -58,14 +58,14 @@ pub struct GltfNode {
 }
 
 /// A glTF mesh, which may consist of multiple [`GltfPrimitives`](GltfPrimitive).
-#[derive(Debug, Clone, TypeUuid)]
+#[derive(Debug, Clone, TypeUuid, TypeName)]
 #[uuid = "8ceaec9a-926a-4f29-8ee3-578a69f42315"]
 pub struct GltfMesh {
     pub primitives: Vec<GltfPrimitive>,
 }
 
 /// Part of a [`GltfMesh`] that consists of a [`Mesh`] and an optional [`StandardMaterial`].
-#[derive(Debug, Clone, TypeUuid)]
+#[derive(Debug, Clone, TypeUuid, TypeName)]
 #[uuid = "cbfca302-82fd-41cb-af77-cab6b3d50af1"]
 pub struct GltfPrimitive {
     pub mesh: Handle<Mesh>,

crates/bevy_pbr/src/material.rs

@@ -17,7 +17,7 @@ use bevy_ecs::{
     },
     world::FromWorld,
 };
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{TypeName, TypeUuid};
 use bevy_render::{
     extract_component::ExtractComponentPlugin,
     mesh::{Mesh, MeshVertexBufferLayout},
@@ -57,11 +57,11 @@ use std::marker::PhantomData;
 /// ```
 /// # use bevy_pbr::{Material, MaterialMeshBundle};
 /// # use bevy_ecs::prelude::*;
-/// # use bevy_reflect::TypeUuid;
+/// # use bevy_reflect::{TypeUuid, TypeName};
 /// # use bevy_render::{render_resource::{AsBindGroup, ShaderRef}, texture::Image, color::Color};
 /// # use bevy_asset::{Handle, AssetServer, Assets};
 ///
-/// #[derive(AsBindGroup, TypeUuid, Debug, Clone)]
+/// #[derive(AsBindGroup, TypeUuid, TypeName, Debug, Clone)]
 /// #[uuid = "f690fdae-d598-45ab-8225-97e2a3f056e0"]
 /// pub struct CustomMaterial {
 ///     // Uniform bindings must implement `ShaderType`, which will be used to convert the value to
@@ -108,7 +108,9 @@ use std::marker::PhantomData;
 /// @group(1) @binding(2)
 /// var color_sampler: sampler;
 /// ```
-pub trait Material: AsBindGroup + Send + Sync + Clone + TypeUuid + Sized + 'static {
+pub trait Material:
+    AsBindGroup + Send + Sync + Clone + TypeUuid + TypeName + Sized + 'static
+{
     /// Returns this material's vertex shader. If [`ShaderRef::Default`] is returned, the default mesh vertex shader
     /// will be used.
     fn vertex_shader() -> ShaderRef {

crates/bevy_pbr/src/pbr_material.rs

@@ -1,7 +1,7 @@
 use crate::{AlphaMode, Material, MaterialPipeline, MaterialPipelineKey, PBR_SHADER_HANDLE};
 use bevy_asset::Handle;
 use bevy_math::Vec4;
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{TypeName, TypeUuid};
 use bevy_render::{
     color::Color, mesh::MeshVertexBufferLayout, render_asset::RenderAssets, render_resource::*,
     texture::Image,
@@ -12,7 +12,7 @@ use bevy_render::{
 /// <https://google.github.io/filament/Material%20Properties.pdf>.
 ///
 /// May be created directly from a [`Color`] or an [`Image`].
-#[derive(AsBindGroup, Debug, Clone, TypeUuid)]
+#[derive(AsBindGroup, Debug, Clone, TypeUuid, TypeName)]
 #[uuid = "7494888b-c082-457b-aacf-517228cc0c22"]
 #[bind_group_data(StandardMaterialKey)]
 #[uniform(0, StandardMaterialUniform)]

crates/bevy_reflect/bevy_reflect_derive/src/derive_data.rs

@@ -1,11 +1,17 @@
 use crate::container_attributes::ReflectTraits;
 use crate::field_attributes::{parse_field_attrs, ReflectFieldAttr};
 use quote::quote;
+use syn::token::Comma;
 
-use crate::{utility, REFLECT_ATTRIBUTE_NAME, REFLECT_VALUE_ATTRIBUTE_NAME};
+use crate::{
+    utility, REFLECT_ATTRIBUTE_NAME, REFLECT_VALUE_ATTRIBUTE_NAME, TYPE_NAME_ATTRIBUTE_NAME,
+};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
-use syn::{Data, DeriveInput, Field, Fields, Generics, Ident, Meta, Path, Token, Type, Variant};
+use syn::{
+    Data, DeriveInput, Field, Fields, Generics, Ident, Lit, Meta, NestedMeta, Path, Token, Type,
+    Variant,
+};
 
 pub(crate) enum ReflectDerive<'a> {
     Struct(ReflectStruct<'a>),
@@ -35,6 +41,8 @@ pub(crate) struct ReflectMeta<'a> {
     type_name: &'a Ident,
     /// The generics defined on this type.
     generics: &'a Generics,
+    /// Override the default type name for `ReflectTypeName`.
+    reflected_type_name: Option<String>,
     /// A cached instance of the path to the `bevy_reflect` crate.
     bevy_reflect_path: Path,
 }
@@ -110,6 +118,8 @@ impl<'a> ReflectDerive<'a> {
         // Should indicate whether `#[reflect_value]` was used
         let mut force_reflect_value = false;
 
+        let mut reflected_type_name = None;
+
         for attribute in input.attrs.iter().filter_map(|attr| attr.parse_meta().ok()) {
             let meta_list = if let Meta::List(meta_list) = attribute {
                 meta_list
@@ -123,11 +133,14 @@ impl<'a> ReflectDerive<'a> {
                 } else if ident == REFLECT_VALUE_ATTRIBUTE_NAME {
                     force_reflect_value = true;
                     traits = ReflectTraits::from_nested_metas(&meta_list.nested);
+                } else if ident == TYPE_NAME_ATTRIBUTE_NAME {
+                    let type_name = get_type_name_attribute(&meta_list.nested).ok_or_else(||syn::Error::new(meta_list.span(), format!("The attribute `{TYPE_NAME_ATTRIBUTE_NAME}` require a single literal string. \n\n #[{TYPE_NAME_ATTRIBUTE_NAME}(\"my_lib::foo\")]")) )?;
+                    reflected_type_name = Some(type_name);
                 }
             }
         }
 
-        let meta = ReflectMeta::new(&input.ident, &input.generics, traits);
+        let meta = ReflectMeta::new(&input.ident, &input.generics, traits, reflected_type_name);
 
         if force_reflect_value {
             return Ok(Self::Value(meta));
@@ -211,11 +224,17 @@ impl<'a> ReflectDerive<'a> {
 }
 
 impl<'a> ReflectMeta<'a> {
-    pub fn new(type_name: &'a Ident, generics: &'a Generics, traits: ReflectTraits) -> Self {
+    pub fn new(
+        type_name: &'a Ident,
+        generics: &'a Generics,
+        traits: ReflectTraits,
+        reflected_type_name: Option<String>,
+    ) -> Self {
         Self {
             traits,
             type_name,
             generics,
+            reflected_type_name,
             bevy_reflect_path: utility::get_bevy_reflect_path(),
         }
     }
@@ -235,6 +254,11 @@ impl<'a> ReflectMeta<'a> {
         self.generics
     }
 
+    /// Override the default type name for `TypeName`.
+    pub fn reflected_type_name(&self) -> Option<&str> {
+        self.reflected_type_name.as_deref()
+    }
+
     /// The cached `bevy_reflect` path.
     pub fn bevy_reflect_path(&self) -> &Path {
         &self.bevy_reflect_path
@@ -310,3 +334,13 @@ impl<'a> ReflectEnum<'a> {
         &self.variants
     }
 }
+
+/// Extracts the type name attribute or returns [`None`].
+fn get_type_name_attribute(nested_metas: &Punctuated<NestedMeta, Comma>) -> Option<String> {
+    (nested_metas.len() == 1)
+        .then(|| match nested_metas.first().unwrap() {
+            NestedMeta::Lit(Lit::Str(s)) => Some(s.value()),
+            _ => None,
+        })
+        .flatten()
+}

crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs

@@ -51,7 +51,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
                 if let #bevy_reflect_path::ReflectRef::Enum(#ref_value) = #ref_value.reflect_ref() {
                     match #ref_value.variant_name() {
                         #(#variant_names => Some(#variant_constructors),)*
-                        name => panic!("variant with name `{}` does not exist on enum `{}`", name, std::any::type_name::<Self>()),
+                        name => panic!("variant with name `{}` does not exist on enum `{}`", name, <Self as #bevy_reflect_path::TypeName>::name()),
                     }
                 } else {
                     None

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

@@ -1,6 +1,6 @@
 use crate::derive_data::{EnumVariantFields, ReflectEnum, StructField};
 use crate::enum_utility::{get_variant_constructors, EnumVariantConstructors};
-use crate::impls::impl_typed;
+use crate::impls::{impl_type_name, impl_typed};
 use proc_macro::TokenStream;
 use proc_macro2::{Ident, Span};
 use quote::quote;
@@ -64,6 +64,13 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
         bevy_reflect_path,
     );
 
+    let type_name_impl = impl_type_name(
+        enum_name,
+        reflect_enum.meta().generics(),
+        reflect_enum.meta().reflected_type_name(),
+        bevy_reflect_path,
+    );
+
     let get_type_registration_impl = reflect_enum.meta().get_type_registration();
     let (impl_generics, ty_generics, where_clause) =
         reflect_enum.meta().generics().split_for_impl();
@@ -73,6 +80,8 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
 
         #typed_impl
 
+        #type_name_impl
+
         impl #impl_generics #bevy_reflect_path::Enum for #enum_name #ty_generics #where_clause {
             fn field(&self, #ref_name: &str) -> Option<&dyn #bevy_reflect_path::Reflect> {
                  match self {
@@ -150,11 +159,6 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
         }
 
         impl #impl_generics #bevy_reflect_path::Reflect for #enum_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()
@@ -198,6 +202,8 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
 
             #[inline]
             fn apply(&mut self, #ref_value: &dyn #bevy_reflect_path::Reflect) {
+                use #bevy_reflect_path::ReflectTypeName;
+
                 if let #bevy_reflect_path::ReflectRef::Enum(#ref_value) = #ref_value.reflect_ref() {
                     if #bevy_reflect_path::Enum::variant_name(self) == #ref_value.variant_name() {
                         // Same variant -> just update fields
@@ -221,7 +227,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
                             #(#variant_names => {
                                 *self = #variant_constructors
                             })*
-                            name => panic!("variant with name `{}` does not exist on enum `{}`", name, std::any::type_name::<Self>()),
+                            name => panic!("variant with name `{}` does not exist on enum `{}`", name, <Self as #bevy_reflect_path::TypeName>::name()),
                         }
                     }
                 } else {

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

@@ -1,11 +1,13 @@
 mod enums;
 mod structs;
 mod tuple_structs;
+mod type_name;
 mod typed;
 mod values;
 
 pub(crate) use enums::impl_enum;
 pub(crate) use structs::impl_struct;
 pub(crate) use tuple_structs::impl_tuple_struct;
+pub(crate) use type_name::impl_type_name;
 pub(crate) use typed::impl_typed;
 pub(crate) use values::impl_value;