reflect: stable type path v2 (#7184)

# Objective

- Introduce a stable alternative to
[`std::any::type_name`](https://doc.rust-lang.org/std/any/fn.type_name.html).
- Rewrite of #5805 with heavy inspiration in design.
- On the path to #5830.
- Part of solving #3327.


## Solution

- Add a `TypePath` trait for static stable type path/name information.
- Add a `TypePath` derive macro.
- Add a `impl_type_path` macro for implementing internal and foreign
types in `bevy_reflect`.

---

## Changelog

- Added `TypePath` trait.
- Added `DynamicTypePath` trait and `get_type_path` method to `Reflect`.
- Added a `TypePath` derive macro.
- Added a `bevy_reflect::impl_type_path` for implementing `TypePath` on
internal and foreign types in `bevy_reflect`.
- Changed `bevy_reflect::utility::(Non)GenericTypeInfoCell` to
`(Non)GenericTypedCell<T>` which allows us to be generic over both
`TypeInfo` and `TypePath`.
- `TypePath` is now a supertrait of `Asset`, `Material` and
`Material2d`.
- `impl_reflect_struct` needs a `#[type_path = "..."]` attribute to be
specified.
- `impl_reflect_value` needs to either specify path starting with a
double colon (`::core::option::Option`) or an `in my_crate::foo`
declaration.
- Added `bevy_reflect_derive::ReflectTypePath`.
- Most uses of `Ident` in `bevy_reflect_derive` changed to use
`ReflectTypePath`.

## Migration Guide

- Implementors of `Asset`, `Material` and `Material2d` now also need to
derive `TypePath`.
- Manual implementors of `Reflect` will need to implement the new
`get_type_path` method.

## Open Questions
- [x] ~This PR currently does not migrate any usages of
`std::any::type_name` to use `bevy_reflect::TypePath` to ease the review
process. Should it?~ Migration will be left to a follow-up PR.
- [ ] This PR adds a lot of `#[derive(TypePath)]` and `T: TypePath` to
satisfy new bounds, mostly when deriving `TypeUuid`. Should we make
`TypePath` a supertrait of `TypeUuid`? [Should we remove `TypeUuid` in
favour of
`TypePath`?](2afbd85532 (r961067892))

crates/bevy_asset/src/asset_server.rs

@@ -98,7 +98,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::TypePath)]
 /// # #[uuid = "00000000-0000-0000-0000-000000000000"]
 /// # struct Image;
 ///
@@ -647,10 +647,10 @@ mod test {
     use crate::{loader::LoadedAsset, update_asset_storage_system};
     use bevy_app::{App, Update};
     use bevy_ecs::prelude::*;
-    use bevy_reflect::TypeUuid;
+    use bevy_reflect::{TypePath, TypeUuid};
     use bevy_utils::BoxedFuture;
 
-    #[derive(Debug, TypeUuid)]
+    #[derive(Debug, TypeUuid, TypePath)]
     #[uuid = "a5189b72-0572-4290-a2e0-96f73a491c44"]
     struct PngAsset;
 

crates/bevy_asset/src/assets.rs

@@ -488,7 +488,7 @@ mod tests {
 
     #[test]
     fn asset_overwriting() {
-        #[derive(bevy_reflect::TypeUuid)]
+        #[derive(bevy_reflect::TypeUuid, bevy_reflect::TypePath)]
         #[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::TypePath;
 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 + TypePath + AssetDynamic {}
 
 /// 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 + TypePath + AssetDynamic + TypeUuidDynamic {}
 
 impl<T> AssetDynamic for T where T: Send + Sync + 'static + TypeUuidDynamic {}
 

crates/bevy_audio/src/audio_source.rs

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

crates/bevy_audio/src/sinks.rs

@@ -1,5 +1,5 @@
 use bevy_math::Vec3;
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{TypePath, TypeUuid};
 use bevy_transform::prelude::Transform;
 use rodio::{Sink, SpatialSink};
 
@@ -87,7 +87,7 @@ pub trait AudioSinkPlayback {
 /// }
 /// ```
 ///
-#[derive(TypeUuid)]
+#[derive(TypePath, TypeUuid)]
 #[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.
@@ -158,7 +158,7 @@ impl AudioSinkPlayback for AudioSink {
 /// }
 /// ```
 ///
-#[derive(TypeUuid)]
+#[derive(TypePath, TypeUuid)]
 #[uuid = "F3CA4C47-595E-453B-96A7-31C3DDF2A177"]
 pub struct SpatialAudioSink {
     // This field is an Option in order to allow us to have a safe drop that will detach the sink.

crates/bevy_ecs/src/reflect.rs

@@ -407,7 +407,7 @@ impl<C: Resource + Reflect + FromWorld> FromType<C> for ReflectResource {
     }
 }
 
-impl_reflect_value!(Entity(Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!((in bevy_ecs) Entity(Hash, PartialEq, Serialize, Deserialize));
 impl_from_reflect_value!(Entity);
 
 #[derive(Clone)]

crates/bevy_gltf/src/lib.rs

@@ -12,7 +12,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, TypePath, TypeUuid};
 use bevy_render::{
     mesh::{Mesh, MeshVertexAttribute},
     renderer::RenderDevice,
@@ -58,7 +58,7 @@ impl Plugin for GltfPlugin {
 }
 
 /// Representation of a loaded glTF file.
-#[derive(Debug, TypeUuid)]
+#[derive(Debug, TypeUuid, TypePath)]
 #[uuid = "5c7d5f8a-f7b0-4e45-a09e-406c0372fea2"]
 pub struct Gltf {
     pub scenes: Vec<Handle<Scene>>,
@@ -78,7 +78,7 @@ pub struct Gltf {
 
 /// A glTF node with all of its child nodes, its [`GltfMesh`],
 /// [`Transform`](bevy_transform::prelude::Transform) and an optional [`GltfExtras`].
-#[derive(Debug, Clone, TypeUuid)]
+#[derive(Debug, Clone, TypeUuid, TypePath)]
 #[uuid = "dad74750-1fd6-460f-ac51-0a7937563865"]
 pub struct GltfNode {
     pub children: Vec<GltfNode>,
@@ -89,7 +89,7 @@ pub struct GltfNode {
 
 /// A glTF mesh, which may consist of multiple [`GltfPrimitives`](GltfPrimitive)
 /// and an optional [`GltfExtras`].
-#[derive(Debug, Clone, TypeUuid)]
+#[derive(Debug, Clone, TypeUuid, TypePath)]
 #[uuid = "8ceaec9a-926a-4f29-8ee3-578a69f42315"]
 pub struct GltfMesh {
     pub primitives: Vec<GltfPrimitive>,
@@ -97,7 +97,7 @@ pub struct GltfMesh {
 }
 
 /// Part of a [`GltfMesh`] that consists of a [`Mesh`], an optional [`StandardMaterial`] and [`GltfExtras`].
-#[derive(Debug, Clone, TypeUuid)]
+#[derive(Debug, Clone, TypeUuid, TypePath)]
 #[uuid = "cbfca302-82fd-41cb-af77-cab6b3d50af1"]
 pub struct GltfPrimitive {
     pub mesh: Handle<Mesh>,

crates/bevy_input/src/input.rs

@@ -174,10 +174,12 @@ where
 
 #[cfg(test)]
 mod test {
+    use bevy_reflect::TypePath;
+
     use crate::Input;
 
     /// Used for testing the functionality of [`Input`].
-    #[derive(Copy, Clone, Eq, PartialEq, Hash)]
+    #[derive(TypePath, Copy, Clone, Eq, PartialEq, Hash)]
     enum DummyInput {
         Input1,
         Input2,

crates/bevy_pbr/src/material.rs

@@ -19,7 +19,7 @@ use bevy_ecs::{
         SystemParamItem,
     },
 };
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{TypePath, TypeUuid};
 use bevy_render::{
     extract_component::ExtractComponentPlugin,
     mesh::{Mesh, MeshVertexBufferLayout},
@@ -59,11 +59,11 @@ use std::marker::PhantomData;
 /// ```
 /// # use bevy_pbr::{Material, MaterialMeshBundle};
 /// # use bevy_ecs::prelude::*;
-/// # use bevy_reflect::TypeUuid;
+/// # use bevy_reflect::{TypeUuid, TypePath};
 /// # 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, TypePath, 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
@@ -106,7 +106,7 @@ 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 + TypePath + Sized {
     /// 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_reflect/bevy_reflect_derive/src/derive_data.rs

@@ -1,15 +1,22 @@
 use crate::container_attributes::ReflectTraits;
 use crate::field_attributes::{parse_field_attrs, ReflectFieldAttr};
 use crate::fq_std::{FQAny, FQDefault, FQSend, FQSync};
-use crate::utility::{members_to_serialization_denylist, WhereClauseOptions};
+use crate::type_path::parse_path_no_leading_colon;
+use crate::utility::{members_to_serialization_denylist, StringExpr, WhereClauseOptions};
 use bit_set::BitSet;
-use quote::quote;
+use quote::{quote, ToTokens};
 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,
+    TYPE_PATH_ATTRIBUTE_NAME,
+};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
-use syn::{Data, DeriveInput, Field, Fields, Generics, Ident, Meta, Path, Variant};
+use syn::{
+    parse_str, Data, DeriveInput, Field, Fields, GenericParam, Generics, Ident, LitStr, Meta, Path,
+    PathSegment, Type, TypeParam, Variant,
+};
 
 pub(crate) enum ReflectDerive<'a> {
     Struct(ReflectStruct<'a>),
@@ -36,9 +43,7 @@ pub(crate) struct ReflectMeta<'a> {
     /// The registered traits for this type.
     traits: ReflectTraits,
     /// The name of this type.
-    type_name: &'a Ident,
+    type_path: ReflectTypePath<'a>,
-    /// The generics defined on this type.
-    generics: &'a Generics,
     /// A cached instance of the path to the `bevy_reflect` crate.
     bevy_reflect_path: Path,
     /// The documentation for this type, if any
@@ -131,8 +136,12 @@ enum ReflectMode {
 impl<'a> ReflectDerive<'a> {
     pub fn from_input(input: &'a DeriveInput) -> Result<Self, syn::Error> {
         let mut traits = ReflectTraits::default();
-        // Should indicate whether `#[reflect_value]` was used
+        // Should indicate whether `#[reflect_value]` was used.
         let mut reflect_mode = None;
+        // Should indicate whether `#[type_path = "..."]` was used.
+        let mut custom_path: Option<Path> = None;
+        // Should indicate whether `#[type_name = "..."]` was used.
+        let mut custom_type_name: Option<Ident> = None;
 
         #[cfg(feature = "documentation")]
         let mut doc = crate::documentation::Documentation::default();
@@ -177,6 +186,35 @@ impl<'a> ReflectDerive<'a> {
 
                     reflect_mode = Some(ReflectMode::Value);
                 }
+                Meta::NameValue(pair) if pair.path.is_ident(TYPE_PATH_ATTRIBUTE_NAME) => {
+                    let syn::Expr::Lit(syn::ExprLit {
+                        lit: syn::Lit::Str(lit),
+                        ..
+                    }) = &pair.value else {
+                        return Err(syn::Error::new(
+                            pair.span(),
+                            format_args!("`#[{TYPE_PATH_ATTRIBUTE_NAME} = \"...\"]` must be a string literal"),
+                        ));
+                    };
+
+                    custom_path = Some(syn::parse::Parser::parse_str(
+                        parse_path_no_leading_colon,
+                        &lit.value(),
+                    )?);
+                }
+                Meta::NameValue(pair) if pair.path.is_ident(TYPE_NAME_ATTRIBUTE_NAME) => {
+                    let syn::Expr::Lit(syn::ExprLit {
+                        lit: syn::Lit::Str(lit),
+                        ..
+                    }) = &pair.value else {
+                        return Err(syn::Error::new(
+                            pair.span(),
+                            format_args!("`#[{TYPE_NAME_ATTRIBUTE_NAME} = \"...\"]` must be a string literal"),
+                        ));
+                    };
+
+                    custom_type_name = Some(parse_str(&lit.value())?);
+                }
                 #[cfg(feature = "documentation")]
                 Meta::NameValue(pair) if pair.path.is_ident("doc") => {
                     if let syn::Expr::Lit(syn::ExprLit {
@@ -190,8 +228,27 @@ impl<'a> ReflectDerive<'a> {
                 _ => continue,
             }
         }
+        match (&mut custom_path, custom_type_name) {
+            (Some(path), custom_type_name) => {
+                let ident = custom_type_name.unwrap_or_else(|| input.ident.clone());
+                path.segments.push(PathSegment::from(ident));
+            }
+            (None, Some(name)) => {
+                return Err(syn::Error::new(
+                    name.span(),
+                    format!("cannot use `#[{TYPE_NAME_ATTRIBUTE_NAME} = \"...\"]` without a `#[{TYPE_PATH_ATTRIBUTE_NAME} = \"...\"]` attribute."),
+                ));
+            }
+            _ => (),
+        }
 
-        let meta = ReflectMeta::new(&input.ident, &input.generics, traits);
+        let type_path = ReflectTypePath::Internal {
+            ident: &input.ident,
+            custom_path,
+            generics: &input.generics,
+        };
+
+        let meta = ReflectMeta::new(type_path, traits);
 
         #[cfg(feature = "documentation")]
         let meta = meta.with_docs(doc);
@@ -233,6 +290,16 @@ impl<'a> ReflectDerive<'a> {
         };
     }
 
+    pub fn meta(&self) -> &ReflectMeta<'a> {
+        match self {
+            ReflectDerive::Struct(data)
+            | ReflectDerive::TupleStruct(data)
+            | ReflectDerive::UnitStruct(data) => data.meta(),
+            ReflectDerive::Enum(data) => data.meta(),
+            ReflectDerive::Value(meta) => meta,
+        }
+    }
+
     fn collect_struct_fields(fields: &'a Fields) -> Result<Vec<StructField<'a>>, syn::Error> {
         let sifter: utility::ResultSifter<StructField<'a>> = fields
             .iter()
@@ -288,11 +355,10 @@ 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_path: ReflectTypePath<'a>, traits: ReflectTraits) -> Self {
         Self {
             traits,
-            type_name,
+            type_path,
-            generics,
             bevy_reflect_path: utility::get_bevy_reflect_path(),
             #[cfg(feature = "documentation")]
             docs: Default::default(),
@@ -311,13 +377,8 @@ impl<'a> ReflectMeta<'a> {
     }
 
     /// The name of this struct.
-    pub fn type_name(&self) -> &'a Ident {
+    pub fn type_path(&self) -> &ReflectTypePath<'a> {
-        self.type_name
+        &self.type_path
-    }
-
-    /// The generics associated with this struct.
-    pub fn generics(&self) -> &'a Generics {
-        self.generics
     }
 
     /// The cached `bevy_reflect` path.
@@ -330,14 +391,7 @@ impl<'a> ReflectMeta<'a> {
         &self,
         where_clause_options: &WhereClauseOptions,
     ) -> proc_macro2::TokenStream {
-        crate::registration::impl_get_type_registration(
+        crate::registration::impl_get_type_registration(self, where_clause_options, None)
-            self.type_name,
-            &self.bevy_reflect_path,
-            self.traits.idents(),
-            self.generics,
-            where_clause_options,
-            None,
-        )
     }
 
     /// The collection of docstrings for this type, if any.
@@ -368,13 +422,8 @@ impl<'a> ReflectStruct<'a> {
         &self,
         where_clause_options: &WhereClauseOptions,
     ) -> proc_macro2::TokenStream {
-        let reflect_path = self.meta.bevy_reflect_path();
-
         crate::registration::impl_get_type_registration(
-            self.meta.type_name(),
+            self.meta(),
-            reflect_path,
-            self.meta.traits().idents(),
-            self.meta.generics(),
             where_clause_options,
             Some(&self.serialization_denylist),
         )
@@ -421,6 +470,7 @@ impl<'a> ReflectStruct<'a> {
             active_trait_bounds: quote! { #bevy_reflect_path::Reflect },
             ignored_types: self.ignored_types().into(),
             ignored_trait_bounds: quote! { #FQAny + #FQSend + #FQSync },
+            ..WhereClauseOptions::type_path_bounds(self.meta())
         }
     }
 }
@@ -433,7 +483,7 @@ impl<'a> ReflectEnum<'a> {
 
     /// Returns the given ident as a qualified unit variant of this enum.
     pub fn get_unit(&self, variant: &Ident) -> proc_macro2::TokenStream {
-        let name = self.meta.type_name;
+        let name = self.meta.type_path();
         quote! {
             #name::#variant
         }
@@ -479,6 +529,7 @@ impl<'a> ReflectEnum<'a> {
             active_trait_bounds: quote! { #bevy_reflect_path::FromReflect },
             ignored_types: self.ignored_types().into(),
             ignored_trait_bounds: quote! { #FQAny + #FQSend + #FQSync + #FQDefault },
+            ..WhereClauseOptions::type_path_bounds(self.meta())
         }
     }
 }
@@ -509,3 +560,355 @@ impl<'a> EnumVariant<'a> {
         }
     }
 }
+
+/// Represents a path to a type.
+///
+/// This is used over [`struct@Ident`] or [`Path`]
+/// to have the correct semantics for [deriving `TypePath`].
+///
+/// The type can always be reached with its [`ToTokens`] implementation.
+///
+/// The [`short_type_path`], [`type_ident`], [`crate_name`], and [`module_path`] methods
+/// have corresponding methods on the `TypePath` trait.
+/// [`long_type_path`] corresponds to the `type_path` method on `TypePath`.
+///
+/// [deriving `TypePath`]: crate::derive_type_path
+/// [`long_type_path`]: ReflectTypePath::long_type_path
+/// [`short_type_path`]: ReflectTypePath::short_type_path
+/// [`type_ident`]: ReflectTypePath::type_ident
+/// [`crate_name`]: ReflectTypePath::crate_name
+/// [`module_path`]: ReflectTypePath::module_path
+///
+/// # Example
+///
+/// ```rust,ignore
+/// # use syn::parse_quote;
+/// # use bevy_reflect_derive::ReflectTypePath;
+/// let path: syn::Path = parse_quote!(::core::marker::PhantomData)?;
+///
+/// let type_path = ReflectTypePath::External {
+///     path,
+///     custom_path: None,
+/// };
+///
+/// // Eqivalent to "core::marker".
+/// let module_path = type_path.module_path();
+/// # Ok::<(), syn::Error>(())
+/// ```
+///
+pub(crate) enum ReflectTypePath<'a> {
+    /// Types without a crate/module that can be named from any scope (e.g. `bool`).
+    Primitive(&'a Ident),
+    /// Using `::my_crate::foo::Bar` syntax.
+    ///
+    /// May have a seperate custom path used for the `TypePath` implementation.
+    External {
+        path: &'a Path,
+        custom_path: Option<Path>,
+        generics: &'a Generics,
+    },
+    /// The name of a type relative to its scope.
+    ///
+    /// The type must be able to be reached with just its name.
+    ///
+    /// May have a seperate alias path used for the `TypePath` implementation.
+    ///
+    /// Module and crate are found with [`module_path!()`](core::module_path),
+    /// if there is no custom path specified.
+    Internal {
+        ident: &'a Ident,
+        custom_path: Option<Path>,
+        generics: &'a Generics,
+    },
+    /// Any [`syn::Type`] with only a defined `type_path` and `short_type_path`.
+    #[allow(dead_code)]
+    // Not currently used but may be useful in the future due to its generality.
+    Anonymous {
+        qualified_type: Type,
+        long_type_path: StringExpr,
+        short_type_path: StringExpr,
+    },
+}
+
+impl<'a> ReflectTypePath<'a> {
+    /// Returns the path interpreted as an [`struct@Ident`].
+    ///
+    /// Returns [`None`] if [anonymous].
+    ///
+    /// [anonymous]: ReflectTypePath::Anonymous
+    pub fn get_ident(&self) -> Option<&Ident> {
+        match self {
+            Self::Internal {
+                ident, custom_path, ..
+            } => Some(
+                custom_path
+                    .as_ref()
+                    .map(|path| &path.segments.last().unwrap().ident)
+                    .unwrap_or(ident),
+            ),
+            Self::External {
+                path, custom_path, ..
+            } => Some(
+                &custom_path
+                    .as_ref()
+                    .unwrap_or(path)
+                    .segments
+                    .last()
+                    .unwrap()
+                    .ident,
+            ),
+            Self::Primitive(ident) => Some(ident),
+            _ => None,
+        }
+    }
+
+    /// The generics associated with the type.
+    ///
+    /// Empty if [anonymous] or [primitive].
+    ///
+    /// [primitive]: ReflectTypePath::Primitive
+    /// [anonymous]: ReflectTypePath::Anonymous
+    pub fn generics(&self) -> &'a Generics {
+        // Use a constant because we need to return a reference of at least 'a.
+        const EMPTY_GENERICS: &Generics = &Generics {
+            gt_token: None,
+            lt_token: None,
+            where_clause: None,
+            params: Punctuated::new(),
+        };
+        match self {
+            Self::Internal { generics, .. } | Self::External { generics, .. } => generics,
+            _ => EMPTY_GENERICS,
+        }
+    }
+
+    /// Whether an implementation of `Typed` or `TypePath` should be generic.
+    ///
+    /// Returning true that it should use a `GenericTypeCell` in its implementation.
+    pub fn impl_is_generic(&self) -> bool {
+        // Whether to use `GenericTypeCell` is not dependent on lifetimes
+        // (which all have to be 'static anyway).
+        !self
+            .generics()
+            .params
+            .iter()
+            .all(|param| matches!(param, GenericParam::Lifetime(_)))
+    }
+
+    /// Returns the path interpreted as a [`Path`].
+    ///
+    /// Returns [`None`] if [anonymous], [primitive],
+    /// or a [`ReflectTypePath::Internal`] without a custom path.
+    ///
+    /// [primitive]: ReflectTypePath::Primitive
+    /// [anonymous]: ReflectTypePath::Anonymous
+    pub fn get_path(&self) -> Option<&Path> {
+        match self {
+            Self::Internal { custom_path, .. } => custom_path.as_ref(),
+            Self::External {
+                path, custom_path, ..
+            } => Some(custom_path.as_ref().unwrap_or(path)),
+            _ => None,
+        }
+    }
+
+    /// Returns whether this [internal] or [external] path has a custom path.
+    ///
+    /// [internal]: ReflectTypePath::Internal
+    /// [external]: ReflectTypePath::External
+    pub fn has_custom_path(&self) -> bool {
+        match self {
+            Self::Internal { custom_path, .. } | Self::External { custom_path, .. } => {
+                custom_path.is_some()
+            }
+            _ => false,
+        }
+    }
+
+    /// Returns a [`StringExpr`] representing the name of the type's crate.
+    ///
+    /// Returns [`None`] if the type is [primitive] or [anonymous].
+    ///
+    /// For non-customised [internal] paths this is created from [`module_path`].
+    ///
+    /// For `Option<PhantomData>`, this is `"core"`.
+    ///
+    /// [primitive]: ReflectTypePath::Primitive
+    /// [anonymous]: ReflectTypePath::Anonymous
+    /// [internal]: ReflectTypePath::Internal
+    pub fn crate_name(&self) -> Option<StringExpr> {
+        if let Some(path) = self.get_path() {
+            let crate_name = &path.segments.first().unwrap().ident;
+            return Some(StringExpr::from(crate_name));
+        }
+
+        match self {
+            Self::Internal { .. } => Some(StringExpr::Borrowed(quote! {
+                ::core::module_path!()
+                    .split(':')
+                    .next()
+                    .unwrap()
+            })),
+            Self::External { .. } => unreachable!(),
+            _ => None,
+        }
+    }
+
+    /// Combines type generics and const generics into one [`StringExpr`].
+    ///
+    /// This string can be used with a `GenericTypePathCell` in a `TypePath` implementation.
+    ///
+    /// The `ty_generic_fn` param maps [`TypeParam`]s to [`StringExpr`]s.
+    fn reduce_generics(
+        generics: &Generics,
+        mut ty_generic_fn: impl FnMut(&TypeParam) -> StringExpr,
+    ) -> StringExpr {
+        let mut params = generics.params.iter().filter_map(|param| match param {
+            GenericParam::Type(type_param) => Some(ty_generic_fn(type_param)),
+            GenericParam::Const(const_param) => {
+                let ident = &const_param.ident;
+                let ty = &const_param.ty;
+
+                Some(StringExpr::Owned(quote! {
+                    <#ty as ::std::string::ToString>::to_string(&#ident)
+                }))
+            }
+            GenericParam::Lifetime(_) => None,
+        });
+
+        params
+            .next()
+            .into_iter()
+            .chain(params.flat_map(|x| [StringExpr::from_str(", "), x]))
+            .collect()
+    }
+
+    /// Returns a [`StringExpr`] representing the "type path" of the type.
+    ///
+    /// For `Option<PhantomData>`, this is `"core::option::Option<core::marker::PhantomData>"`.
+    pub fn long_type_path(&self, bevy_reflect_path: &Path) -> StringExpr {
+        match self {
+            Self::Primitive(ident) => StringExpr::from(ident),
+            Self::Anonymous { long_type_path, .. } => long_type_path.clone(),
+            Self::Internal { generics, .. } | Self::External { generics, .. } => {
+                let ident = self.type_ident().unwrap();
+                let module_path = self.module_path().unwrap();
+
+                if self.impl_is_generic() {
+                    let generics = ReflectTypePath::reduce_generics(
+                        generics,
+                        |TypeParam { ident, .. }| {
+                            StringExpr::Borrowed(quote! {
+                                <#ident as #bevy_reflect_path::TypePath>::type_path()
+                            })
+                        },
+                    );
+
+                    StringExpr::from_iter([
+                        module_path,
+                        StringExpr::from_str("::"),
+                        ident,
+                        StringExpr::from_str("<"),
+                        generics,
+                        StringExpr::from_str(">"),
+                    ])
+                } else {
+                    StringExpr::from_iter([module_path, StringExpr::from_str("::"), ident])
+                }
+            }
+        }
+    }
+
+    /// Returns a [`StringExpr`] representing the "short path" of the type.
+    ///
+    /// For `Option<PhantomData>`, this is `"Option<PhantomData>"`.
+    pub fn short_type_path(&self, bevy_reflect_path: &Path) -> StringExpr {
+        match self {
+            Self::Anonymous {
+                short_type_path, ..
+            } => short_type_path.clone(),
+            Self::Primitive(ident) => StringExpr::from(ident),
+            Self::External { generics, .. } | Self::Internal { generics, .. } => {
+                let ident = self.type_ident().unwrap();
+
+                if self.impl_is_generic() {
+                    let generics = ReflectTypePath::reduce_generics(
+                        generics,
+                        |TypeParam { ident, .. }| {
+                            StringExpr::Borrowed(quote! {
+                                <#ident as #bevy_reflect_path::TypePath>::short_type_path()
+                            })
+                        },
+                    );
+
+                    StringExpr::from_iter([
+                        ident,
+                        StringExpr::from_str("<"),
+                        generics,
+                        StringExpr::from_str(">"),
+                    ])
+                } else {
+                    ident
+                }
+            }
+        }
+    }
+
+    /// Returns a [`StringExpr`] representing the path to the module
+    /// that the type is in.
+    ///
+    /// Returns [`None`] if the type is [primitive] or [anonymous].
+    ///
+    /// For non-customised [internal] paths this is created from [`module_path`].
+    ///
+    /// For `Option<PhantomData>`, this is `"core::option"`.
+    ///
+    /// [primitive]: ReflectTypePath::Primitive
+    /// [anonymous]: ReflectTypePath::Anonymous
+    /// [internal]: ReflectTypePath::Internal
+    pub fn module_path(&self) -> Option<StringExpr> {
+        if let Some(path) = self.get_path() {
+            let path_string = path
+                .segments
+                .pairs()
+                .take(path.segments.len() - 1)
+                .map(|pair| pair.value().ident.to_string())
+                .reduce(|path, ident| path + "::" + &ident)
+                .unwrap();
+
+            let path_lit = LitStr::new(&path_string, path.span());
+            return Some(StringExpr::from_lit(&path_lit));
+        }
+
+        match self {
+            Self::Internal { .. } => Some(StringExpr::Const(quote! {
+                ::core::module_path!()
+            })),
+            Self::External { .. } => unreachable!(),
+            _ => None,
+        }
+    }
+
+    /// Returns a [`StringExpr`] representing the type's final ident.
+    ///
+    /// Returns [`None`] if the type is [anonymous].
+    ///
+    /// This is not necessarily a valid qualified path to the type.
+    ///
+    /// For `Option<PhantomData>`, this is `"Option"`.
+    ///
+    /// [anonymous]: ReflectTypePath::Anonymous
+    pub fn type_ident(&self) -> Option<StringExpr> {
+        self.get_ident().map(StringExpr::from)
+    }
+}
+
+impl<'a> ToTokens for ReflectTypePath<'a> {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        match self {
+            Self::Internal { ident, .. } | Self::Primitive(ident) => ident.to_tokens(tokens),
+            Self::External { path, .. } => path.to_tokens(tokens),
+            Self::Anonymous { qualified_type, .. } => qualified_type.to_tokens(tokens),
+        }
+    }
+}

crates/bevy_reflect/bevy_reflect_derive/src/from_reflect.rs

@@ -22,13 +22,13 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> TokenStream {
 
 /// Implements `FromReflect` for the given value type
 pub(crate) fn impl_value(meta: &ReflectMeta) -> TokenStream {
-    let type_name = meta.type_name();
+    let type_path = meta.type_path();
     let bevy_reflect_path = meta.bevy_reflect_path();
-    let (impl_generics, ty_generics, where_clause) = meta.generics().split_for_impl();
+    let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
     TokenStream::from(quote! {
-        impl #impl_generics #bevy_reflect_path::FromReflect for #type_name #ty_generics #where_clause  {
+        impl #impl_generics #bevy_reflect_path::FromReflect for #type_path #ty_generics #where_clause  {
             fn from_reflect(reflect: &dyn #bevy_reflect_path::Reflect) -> #FQOption<Self> {
-                #FQOption::Some(#FQClone::clone(<dyn #FQAny>::downcast_ref::<#type_name #ty_generics>(<dyn #bevy_reflect_path::Reflect>::as_any(reflect))?))
+                #FQOption::Some(#FQClone::clone(<dyn #FQAny>::downcast_ref::<#type_path #ty_generics>(<dyn #bevy_reflect_path::Reflect>::as_any(reflect))?))
             }
         }
     })
@@ -38,7 +38,7 @@ pub(crate) fn impl_value(meta: &ReflectMeta) -> TokenStream {
 pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
     let fqoption = FQOption.into_token_stream();
 
-    let type_name = reflect_enum.meta().type_name();
+    let enum_path = reflect_enum.meta().type_path();
     let bevy_reflect_path = reflect_enum.meta().bevy_reflect_path();
 
     let ref_value = Ident::new("__param0", Span::call_site());
@@ -47,8 +47,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
         variant_constructors,
     } = get_variant_constructors(reflect_enum, &ref_value, false);
 
-    let (impl_generics, ty_generics, where_clause) =
+    let (impl_generics, ty_generics, where_clause) = enum_path.generics().split_for_impl();
-        reflect_enum.meta().generics().split_for_impl();
 
     // Add FromReflect bound for each active field
     let where_from_reflect_clause = extend_where_clause(
@@ -58,11 +57,12 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
             ignored_types: reflect_enum.ignored_types().into_boxed_slice(),
             active_trait_bounds: quote!(#bevy_reflect_path::FromReflect),
             ignored_trait_bounds: quote!(#FQDefault),
+            ..WhereClauseOptions::type_path_bounds(reflect_enum.meta())
         },
     );
 
     TokenStream::from(quote! {
-        impl #impl_generics #bevy_reflect_path::FromReflect for #type_name #ty_generics #where_from_reflect_clause  {
+        impl #impl_generics #bevy_reflect_path::FromReflect for #enum_path #ty_generics #where_from_reflect_clause  {
             fn from_reflect(#ref_value: &dyn #bevy_reflect_path::Reflect) -> #FQOption<Self> {
                 if let #bevy_reflect_path::ReflectRef::Enum(#ref_value) = #bevy_reflect_path::Reflect::reflect_ref(#ref_value) {
                     match #bevy_reflect_path::Enum::variant_name(#ref_value) {
@@ -90,8 +90,7 @@ impl MemberValuePair {
 fn impl_struct_internal(reflect_struct: &ReflectStruct, is_tuple: bool) -> TokenStream {
     let fqoption = FQOption.into_token_stream();
 
-    let struct_name = reflect_struct.meta().type_name();
+    let struct_path = reflect_struct.meta().type_path();
-    let generics = reflect_struct.meta().generics();
     let bevy_reflect_path = reflect_struct.meta().bevy_reflect_path();
 
     let ref_struct = Ident::new("__ref_struct", Span::call_site());
@@ -129,7 +128,11 @@ fn impl_struct_internal(reflect_struct: &ReflectStruct, is_tuple: bool) -> Token
         )
     };
 
-    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+    let (impl_generics, ty_generics, where_clause) = reflect_struct
+        .meta()
+        .type_path()
+        .generics()
+        .split_for_impl();
 
     // Add FromReflect bound for each active field
     let where_from_reflect_clause = extend_where_clause(
@@ -143,11 +146,12 @@ fn impl_struct_internal(reflect_struct: &ReflectStruct, is_tuple: bool) -> Token
             } else {
                 quote!(#FQDefault)
             },
+            ..WhereClauseOptions::type_path_bounds(reflect_struct.meta())
         },
     );
 
     TokenStream::from(quote! {
-        impl #impl_generics #bevy_reflect_path::FromReflect for #struct_name #ty_generics #where_from_reflect_clause
+        impl #impl_generics #bevy_reflect_path::FromReflect for #struct_path #ty_generics #where_from_reflect_clause
         {
             fn from_reflect(reflect: &dyn #bevy_reflect_path::Reflect) -> #FQOption<Self> {
                 if let #bevy_reflect_path::ReflectRef::#ref_struct_type(#ref_struct) = #bevy_reflect_path::Reflect::reflect_ref(reflect) {

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

@@ -1,7 +1,7 @@
 use crate::derive_data::{EnumVariant, EnumVariantFields, ReflectEnum, StructField};
 use crate::enum_utility::{get_variant_constructors, EnumVariantConstructors};
 use crate::fq_std::{FQAny, FQBox, FQOption, FQResult};
-use crate::impls::impl_typed;
+use crate::impls::{impl_type_path, impl_typed};
 use crate::utility::extend_where_clause;
 use proc_macro::TokenStream;
 use proc_macro2::{Ident, Span};
@@ -10,7 +10,7 @@ use syn::Fields;
 
 pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
     let bevy_reflect_path = reflect_enum.meta().bevy_reflect_path();
-    let enum_name = reflect_enum.meta().type_name();
+    let enum_path = reflect_enum.meta().type_path();
 
     let ref_name = Ident::new("__name_param", Span::call_site());
     let ref_index = Ident::new("__index_param", Span::call_site());
@@ -59,7 +59,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
             }
         });
 
-    let string_name = enum_name.to_string();
+    let string_name = enum_path.get_ident().unwrap().to_string();
 
     #[cfg(feature = "documentation")]
     let info_generator = {
@@ -77,22 +77,23 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
     };
 
     let typed_impl = impl_typed(
-        enum_name,
+        reflect_enum.meta(),
-        reflect_enum.meta().generics(),
         &where_clause_options,
         quote! {
             let variants = [#(#variant_info),*];
             let info = #info_generator;
             #bevy_reflect_path::TypeInfo::Enum(info)
         },
-        bevy_reflect_path,
     );
 
+    let type_path_impl = impl_type_path(reflect_enum.meta(), &where_clause_options);
+
     let get_type_registration_impl = reflect_enum
         .meta()
         .get_type_registration(&where_clause_options);
+
     let (impl_generics, ty_generics, where_clause) =
-        reflect_enum.meta().generics().split_for_impl();
+        reflect_enum.meta().type_path().generics().split_for_impl();
 
     let where_reflect_clause = extend_where_clause(where_clause, &where_clause_options);
 
@@ -101,7 +102,9 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
 
         #typed_impl
 
-        impl #impl_generics #bevy_reflect_path::Enum for #enum_name #ty_generics #where_reflect_clause {
+        #type_path_impl
+
+        impl #impl_generics #bevy_reflect_path::Enum for #enum_path #ty_generics #where_reflect_clause {
             fn field(&self, #ref_name: &str) -> #FQOption<&dyn #bevy_reflect_path::Reflect> {
                  match self {
                     #(#enum_field,)*
@@ -185,7 +188,7 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
             }
         }
 
-        impl #impl_generics #bevy_reflect_path::Reflect for #enum_name #ty_generics #where_reflect_clause {
+        impl #impl_generics #bevy_reflect_path::Reflect for #enum_path #ty_generics #where_reflect_clause {
             #[inline]
             fn type_name(&self) -> &str {
                 ::core::any::type_name::<Self>()
@@ -196,6 +199,11 @@ pub(crate) fn impl_enum(reflect_enum: &ReflectEnum) -> TokenStream {
                 #FQOption::Some(<Self as #bevy_reflect_path::Typed>::type_info())
             }
 
+            #[inline]
+            fn get_type_path(&self) -> &dyn #bevy_reflect_path::DynamicTypePath {
+                self
+            }
+
             #[inline]
             fn into_any(self: #FQBox<Self>) -> #FQBox<dyn #FQAny> {
                 self

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

@@ -7,5 +7,6 @@ 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 typed::impl_type_path;
 pub(crate) use typed::impl_typed;
 pub(crate) use values::impl_value;

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

@@ -1,5 +1,5 @@
 use crate::fq_std::{FQAny, FQBox, FQDefault, FQOption, FQResult};
-use crate::impls::impl_typed;
+use crate::impls::{impl_type_path, impl_typed};
 use crate::utility::{extend_where_clause, ident_or_index};
 use crate::ReflectStruct;
 use proc_macro::TokenStream;
@@ -10,7 +10,7 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> TokenStream {
     let fqoption = FQOption.into_token_stream();
 
     let bevy_reflect_path = reflect_struct.meta().bevy_reflect_path();
-    let struct_name = reflect_struct.meta().type_name();
+    let struct_path = reflect_struct.meta().type_path();
 
     let field_names = reflect_struct
         .active_fields()
@@ -64,7 +64,7 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> TokenStream {
         }
     };
 
-    let string_name = struct_name.to_string();
+    let string_name = struct_path.get_ident().unwrap().to_string();
 
     #[cfg(feature = "documentation")]
     let info_generator = {
@@ -83,20 +83,24 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> TokenStream {
 
     let where_clause_options = reflect_struct.where_clause_options();
     let typed_impl = impl_typed(
-        struct_name,
+        reflect_struct.meta(),
-        reflect_struct.meta().generics(),
         &where_clause_options,
         quote! {
             let fields = [#field_generator];
             let info = #info_generator;
             #bevy_reflect_path::TypeInfo::Struct(info)
         },
-        bevy_reflect_path,
     );
 
+    let type_path_impl = impl_type_path(reflect_struct.meta(), &where_clause_options);
+
     let get_type_registration_impl = reflect_struct.get_type_registration(&where_clause_options);
-    let (impl_generics, ty_generics, where_clause) =
+
-        reflect_struct.meta().generics().split_for_impl();
+    let (impl_generics, ty_generics, where_clause) = reflect_struct
+        .meta()
+        .type_path()
+        .generics()
+        .split_for_impl();
 
     let where_reflect_clause = extend_where_clause(where_clause, &where_clause_options);
 
@@ -105,7 +109,9 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> TokenStream {
 
         #typed_impl
 
-        impl #impl_generics #bevy_reflect_path::Struct for #struct_name #ty_generics #where_reflect_clause {
+        #type_path_impl
+
+        impl #impl_generics #bevy_reflect_path::Struct for #struct_path #ty_generics #where_reflect_clause {
             fn field(&self, name: &str) -> #FQOption<&dyn #bevy_reflect_path::Reflect> {
                 match name {
                     #(#field_names => #fqoption::Some(&self.#field_idents),)*
@@ -157,7 +163,7 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> TokenStream {
             }
         }
 
-        impl #impl_generics #bevy_reflect_path::Reflect for #struct_name #ty_generics #where_reflect_clause {
+        impl #impl_generics #bevy_reflect_path::Reflect for #struct_path #ty_generics #where_reflect_clause {
             #[inline]
             fn type_name(&self) -> &str {
                 ::core::any::type_name::<Self>()
@@ -168,6 +174,11 @@ pub(crate) fn impl_struct(reflect_struct: &ReflectStruct) -> TokenStream {
                 #FQOption::Some(<Self as #bevy_reflect_path::Typed>::type_info())
             }
 
+            #[inline]
+            fn get_type_path(&self) -> &dyn #bevy_reflect_path::DynamicTypePath {
+                self
+            }
+
             #[inline]
             fn into_any(self: #FQBox<Self>) -> #FQBox<dyn #FQAny> {
                 self

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

@@ -1,5 +1,5 @@
 use crate::fq_std::{FQAny, FQBox, FQDefault, FQOption, FQResult};
-use crate::impls::impl_typed;
+use crate::impls::{impl_type_path, impl_typed};
 use crate::utility::extend_where_clause;
 use crate::ReflectStruct;
 use proc_macro::TokenStream;
@@ -11,7 +11,7 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> TokenStream {
     let fqoption = FQOption.into_token_stream();
 
     let bevy_reflect_path = reflect_struct.meta().bevy_reflect_path();
-    let struct_name = reflect_struct.meta().type_name();
+    let struct_path = reflect_struct.meta().type_path();
 
     let field_idents = reflect_struct
         .active_fields()
@@ -58,7 +58,7 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> TokenStream {
         }
     };
 
-    let string_name = struct_name.to_string();
+    let string_name = struct_path.get_ident().unwrap().to_string();
 
     #[cfg(feature = "documentation")]
     let info_generator = {
@@ -76,19 +76,22 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> TokenStream {
     };
 
     let typed_impl = impl_typed(
-        struct_name,
+        reflect_struct.meta(),
-        reflect_struct.meta().generics(),
         &where_clause_options,
         quote! {
             let fields = [#field_generator];
             let info = #info_generator;
             #bevy_reflect_path::TypeInfo::TupleStruct(info)
         },
-        bevy_reflect_path,
     );
 
-    let (impl_generics, ty_generics, where_clause) =
+    let type_path_impl = impl_type_path(reflect_struct.meta(), &where_clause_options);
-        reflect_struct.meta().generics().split_for_impl();
+
+    let (impl_generics, ty_generics, where_clause) = reflect_struct
+        .meta()
+        .type_path()
+        .generics()
+        .split_for_impl();
 
     let where_reflect_clause = extend_where_clause(where_clause, &where_clause_options);
 
@@ -97,7 +100,9 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> TokenStream {
 
         #typed_impl
 
-        impl #impl_generics #bevy_reflect_path::TupleStruct for #struct_name #ty_generics #where_reflect_clause {
+        #type_path_impl
+
+        impl #impl_generics #bevy_reflect_path::TupleStruct for #struct_path #ty_generics #where_reflect_clause {
             fn field(&self, index: usize) -> #FQOption<&dyn #bevy_reflect_path::Reflect> {
                 match index {
                     #(#field_indices => #fqoption::Some(&self.#field_idents),)*
@@ -128,7 +133,7 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> TokenStream {
             }
         }
 
-        impl #impl_generics #bevy_reflect_path::Reflect for #struct_name #ty_generics #where_reflect_clause {
+        impl #impl_generics #bevy_reflect_path::Reflect for #struct_path #ty_generics #where_reflect_clause {
             #[inline]
             fn type_name(&self) -> &str {
                 ::core::any::type_name::<Self>()
@@ -139,6 +144,11 @@ pub(crate) fn impl_tuple_struct(reflect_struct: &ReflectStruct) -> TokenStream {
                 #FQOption::Some(<Self as #bevy_reflect_path::Typed>::type_info())
             }
 
+            #[inline]
+            fn get_type_path(&self) -> &dyn #bevy_reflect_path::DynamicTypePath {
+                self
+            }
+
             #[inline]
             fn into_any(self: #FQBox<Self>) -> #FQBox<dyn #FQAny> {
                 self

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

@@ -1,43 +1,149 @@
-use crate::utility::{extend_where_clause, WhereClauseOptions};
+use crate::utility::{extend_where_clause, StringExpr, WhereClauseOptions};
-use proc_macro2::Ident;
+use quote::{quote, ToTokens};
-use quote::quote;
-use syn::{Generics, Path};
 
-#[allow(clippy::too_many_arguments)]
+use crate::{
-pub(crate) fn impl_typed(
+    derive_data::{ReflectMeta, ReflectTypePath},
-    type_name: &Ident,
+    utility::wrap_in_option,
-    generics: &Generics,
+};
-    where_clause_options: &WhereClauseOptions,
+
+/// Returns an expression for a `NonGenericTypeCell` or `GenericTypeCell`  to generate `'static` references.
+fn static_type_cell(
+    meta: &ReflectMeta,
+    property: TypedProperty,
     generator: proc_macro2::TokenStream,
-    bevy_reflect_path: &Path,
 ) -> proc_macro2::TokenStream {
-    let is_generic = !generics.params.is_empty();
+    let bevy_reflect_path = meta.bevy_reflect_path();
+    if meta.type_path().impl_is_generic() {
+        let cell_type = match property {
+            TypedProperty::TypePath => quote!(GenericTypePathCell),
+            TypedProperty::TypeInfo => quote!(GenericTypeInfoCell),
+        };
 
-    let static_generator = if is_generic {
         quote! {
-            static CELL: #bevy_reflect_path::utility::GenericTypeInfoCell = #bevy_reflect_path::utility::GenericTypeInfoCell::new();
+            static CELL: #bevy_reflect_path::utility::#cell_type = #bevy_reflect_path::utility::#cell_type::new();
             CELL.get_or_insert::<Self, _>(|| {
                 #generator
             })
         }
     } else {
+        let cell_type = match property {
+            TypedProperty::TypePath => unreachable!(
+                "Cannot have a non-generic type path cell. Use string literals and core::concat instead."
+            ),
+            TypedProperty::TypeInfo => quote!(NonGenericTypeInfoCell),
+        };
+
         quote! {
-            static CELL: #bevy_reflect_path::utility::NonGenericTypeInfoCell = #bevy_reflect_path::utility::NonGenericTypeInfoCell::new();
+            static CELL: #bevy_reflect_path::utility::#cell_type = #bevy_reflect_path::utility::#cell_type::new();
             CELL.get_or_set(|| {
                 #generator
             })
         }
+    }
+}
+
+#[derive(Clone, Copy)]
+pub(crate) enum TypedProperty {
+    TypeInfo,
+    TypePath,
+}
+
+pub(crate) fn impl_type_path(
+    meta: &ReflectMeta,
+    where_clause_options: &WhereClauseOptions,
+) -> proc_macro2::TokenStream {
+    let type_path = meta.type_path();
+    let bevy_reflect_path = meta.bevy_reflect_path();
+
+    let (long_type_path, short_type_path) = if type_path.impl_is_generic() {
+        let long_path_cell = static_type_cell(
+            meta,
+            TypedProperty::TypePath,
+            type_path.long_type_path(bevy_reflect_path).into_owned(),
+        );
+        let short_path_cell = static_type_cell(
+            meta,
+            TypedProperty::TypePath,
+            type_path.short_type_path(bevy_reflect_path).into_owned(),
+        );
+        (
+            long_path_cell.to_token_stream(),
+            short_path_cell.to_token_stream(),
+        )
+    } else {
+        (
+            type_path.long_type_path(bevy_reflect_path).into_borrowed(),
+            type_path.short_type_path(bevy_reflect_path).into_borrowed(),
+        )
     };
 
-    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+    let type_ident = wrap_in_option(type_path.type_ident().map(StringExpr::into_borrowed));
+    let module_path = wrap_in_option(type_path.module_path().map(StringExpr::into_borrowed));
+    let crate_name = wrap_in_option(type_path.crate_name().map(StringExpr::into_borrowed));
+
+    let primitive_assert = if let ReflectTypePath::Primitive(_) = type_path {
+        Some(quote! {
+            const _: () = {
+                mod private_scope {
+                    // Compiles if it can be named when there are no imports.
+                    type AssertIsPrimitive = #type_path;
+                }
+            };
+        })
+    } else {
+        None
+    };
+
+    let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
 
     // Add Typed bound for each active field
     let where_reflect_clause = extend_where_clause(where_clause, where_clause_options);
 
     quote! {
-        impl #impl_generics #bevy_reflect_path::Typed for #type_name #ty_generics #where_reflect_clause {
+        #primitive_assert
-            fn type_info() -> &'static #bevy_reflect_path::TypeInfo {
+
-                #static_generator
+        impl #impl_generics #bevy_reflect_path::TypePath for #type_path #ty_generics #where_reflect_clause {
+            fn type_path() -> &'static str {
+                #long_type_path
+            }
+
+            fn short_type_path() -> &'static str {
+                #short_type_path
+            }
+
+            fn type_ident() -> Option<&'static str> {
+                #type_ident
+            }
+
+            fn crate_name() -> Option<&'static str> {
+                #crate_name
+            }
+
+            fn module_path() -> Option<&'static str> {
+                #module_path
+            }
+        }
+    }
+}
+
+pub(crate) fn impl_typed(
+    meta: &ReflectMeta,
+    where_clause_options: &WhereClauseOptions,
+    type_info_generator: proc_macro2::TokenStream,
+) -> proc_macro2::TokenStream {
+    let type_path = meta.type_path();
+    let bevy_reflect_path = meta.bevy_reflect_path();
+
+    let type_info_cell = static_type_cell(meta, TypedProperty::TypeInfo, type_info_generator);
+
+    let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
+
+    let where_reflect_clause = extend_where_clause(where_clause, where_clause_options);
+
+    quote! {
+        impl #impl_generics #bevy_reflect_path::Typed for #type_path #ty_generics #where_reflect_clause {
+            fn type_info() -> &'static #bevy_reflect_path::TypeInfo {
+                #type_info_cell
             }
         }
     }

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

@@ -1,6 +1,6 @@
 use crate::fq_std::{FQAny, FQBox, FQClone, FQOption, FQResult};
-use crate::impls::impl_typed;
+use crate::impls::{impl_type_path, impl_typed};
-use crate::utility::WhereClauseOptions;
+use crate::utility::{extend_where_clause, WhereClauseOptions};
 use crate::ReflectMeta;
 use proc_macro::TokenStream;
 use quote::quote;
@@ -8,7 +8,7 @@ use quote::quote;
 /// Implements `GetTypeRegistration` and `Reflect` for the given type data.
 pub(crate) fn impl_value(meta: &ReflectMeta) -> TokenStream {
     let bevy_reflect_path = meta.bevy_reflect_path();
-    let type_name = meta.type_name();
+    let type_path = meta.type_path();
 
     let hash_fn = meta.traits().get_hash_impl(bevy_reflect_path);
     let partial_eq_fn = meta.traits().get_partial_eq_impl(bevy_reflect_path);
@@ -22,27 +22,30 @@ pub(crate) fn impl_value(meta: &ReflectMeta) -> TokenStream {
     #[cfg(not(feature = "documentation"))]
     let with_docs: Option<proc_macro2::TokenStream> = None;
 
-    let where_clause_options = WhereClauseOptions::default();
+    let where_clause_options = WhereClauseOptions::type_path_bounds(meta);
     let typed_impl = impl_typed(
-        type_name,
+        meta,
-        meta.generics(),
         &where_clause_options,
         quote! {
             let info = #bevy_reflect_path::ValueInfo::new::<Self>() #with_docs;
             #bevy_reflect_path::TypeInfo::Value(info)
         },
-        bevy_reflect_path,
     );
 
-    let (impl_generics, ty_generics, where_clause) = meta.generics().split_for_impl();
+    let type_path_impl = impl_type_path(meta, &where_clause_options);
+
+    let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
+    let where_reflect_clause = extend_where_clause(where_clause, &where_clause_options);
     let get_type_registration_impl = meta.get_type_registration(&where_clause_options);
 
     TokenStream::from(quote! {
         #get_type_registration_impl
 
+        #type_path_impl
+
         #typed_impl
 
-        impl #impl_generics #bevy_reflect_path::Reflect for #type_name #ty_generics #where_clause  {
+        impl #impl_generics #bevy_reflect_path::Reflect for #type_path #ty_generics #where_reflect_clause  {
             #[inline]
             fn type_name(&self) -> &str {
                 ::core::any::type_name::<Self>()
@@ -53,6 +56,11 @@ pub(crate) fn impl_value(meta: &ReflectMeta) -> TokenStream {
                 #FQOption::Some(<Self as #bevy_reflect_path::Typed>::type_info())
             }
 
+            #[inline]
+            fn get_type_path(&self) -> &dyn #bevy_reflect_path::DynamicTypePath {
+                self
+            }
+
             #[inline]
             fn into_any(self: #FQBox<Self>) -> #FQBox<dyn #FQAny> {
                 self

crates/bevy_reflect/bevy_reflect_derive/src/lib.rs

@@ -26,20 +26,27 @@ mod impls;
 mod reflect_value;
 mod registration;
 mod trait_reflection;
+mod type_path;
 mod type_uuid;
 mod utility;
 
 use crate::derive_data::{ReflectDerive, ReflectMeta, ReflectStruct};
 use crate::type_uuid::gen_impl_type_uuid;
+use container_attributes::ReflectTraits;
+use derive_data::ReflectTypePath;
 use proc_macro::TokenStream;
 use quote::quote;
 use reflect_value::ReflectValueDef;
 use syn::spanned::Spanned;
 use syn::{parse_macro_input, DeriveInput};
+use type_path::NamedTypePathDef;
 use type_uuid::TypeUuidDef;
+use utility::WhereClauseOptions;
 
 pub(crate) static REFLECT_ATTRIBUTE_NAME: &str = "reflect";
 pub(crate) static REFLECT_VALUE_ATTRIBUTE_NAME: &str = "reflect_value";
+pub(crate) static TYPE_PATH_ATTRIBUTE_NAME: &str = "type_path";
+pub(crate) static TYPE_NAME_ATTRIBUTE_NAME: &str = "type_name";
 
 /// The main derive macro used by `bevy_reflect` for deriving its `Reflect` trait.
 ///
@@ -52,6 +59,8 @@ pub(crate) static REFLECT_VALUE_ATTRIBUTE_NAME: &str = "reflect_value";
 /// This macro comes with some helper attributes that can be added to the container item
 /// in order to provide additional functionality or alter the generated implementations.
 ///
+/// In addition to those listed, this macro can also use the attributes for [`TypePath`] derives.
+///
 /// ## `#[reflect(Ident)]`
 ///
 /// The `#[reflect(Ident)]` attribute is used to add type data registrations to the `GetTypeRegistration`
@@ -124,7 +133,7 @@ pub(crate) static REFLECT_VALUE_ATTRIBUTE_NAME: &str = "reflect_value";
 /// which will be used by the reflection serializers to determine whether or not the field is serializable.
 ///
 /// [`reflect_trait`]: macro@reflect_trait
-#[proc_macro_derive(Reflect, attributes(reflect, reflect_value))]
+#[proc_macro_derive(Reflect, attributes(reflect, reflect_value, type_path, type_name))]
 pub fn derive_reflect(input: TokenStream) -> TokenStream {
     let ast = parse_macro_input!(input as DeriveInput);
 
@@ -188,6 +197,36 @@ pub fn derive_from_reflect(input: TokenStream) -> TokenStream {
     }
 }
 
+/// Derives the `TypePath` trait, providing a stable alternative to [`std::any::type_name`].
+///
+/// # Container Attributes
+///
+/// ## `#[type_path = "my_crate::foo"]`
+///
+/// Optionally specifies a custom module path to use instead of [`module_path`].
+///
+/// This path does not include the final identifier.
+///
+/// ## `#[type_name = "RenamedType"]`
+///
+/// Optionally specifies a new terminating identifier for `TypePath`.
+///
+/// To use this attribute, `#[type_path = "..."]` must also be specified.
+#[proc_macro_derive(TypePath, attributes(type_path, type_name))]
+pub fn derive_type_path(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+    let derive_data = match ReflectDerive::from_input(&ast) {
+        Ok(data) => data,
+        Err(err) => return err.into_compile_error().into(),
+    };
+
+    impls::impl_type_path(
+        derive_data.meta(),
+        &WhereClauseOptions::type_path_bounds(derive_data.meta()),
+    )
+    .into()
+}
+
 // From https://github.com/randomPoison/type-uuid
 #[proc_macro_derive(TypeUuid, attributes(uuid))]
 pub fn derive_type_uuid(input: TokenStream) -> TokenStream {
@@ -254,30 +293,47 @@ pub fn reflect_trait(args: TokenStream, input: TokenStream) -> TokenStream {
 /// The only reason for this macro's existence is so that `bevy_reflect` can easily implement the reflection traits
 /// on primitives and other Rust types internally.
 ///
+/// Since this macro also implements `TypePath`, the type path must be explicit.
+/// See [`impl_type_path!`] for the exact syntax.
+///
 /// # Examples
 ///
 /// Types can be passed with or without registering type data:
 ///
 /// ```ignore
-/// impl_reflect_value!(foo);
+/// impl_reflect_value!(::my_crate::Foo);
-/// impl_reflect_value!(bar(Debug, Default, Serialize, Deserialize));
+/// impl_reflect_value!(::my_crate::Bar(Debug, Default, Serialize, Deserialize));
 /// ```
 ///
 /// Generic types can also specify their parameters and bounds:
 ///
 /// ```ignore
-/// impl_reflect_value!(foo<T1, T2: Baz> where T1: Bar (Default, Serialize, Deserialize));
+/// impl_reflect_value!(::my_crate::Foo<T1, T2: Baz> where T1: Bar (Default, Serialize, Deserialize));
+/// ```
+///
+/// Custom type paths can be specified:
+///
+/// ```ignore
+/// impl_reflect_value!((in not_my_crate as NotFoo) Foo(Debug, Default));
 /// ```
 ///
 /// [deriving `Reflect`]: Reflect
 #[proc_macro]
 pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
     let def = parse_macro_input!(input as ReflectValueDef);
-    let meta = ReflectMeta::new(
+
-        &def.type_name,
+    let default_name = &def.type_path.segments.last().unwrap().ident;
-        &def.generics,
+    let type_path = if def.type_path.leading_colon.is_none() && def.custom_path.is_none() {
-        def.traits.unwrap_or_default(),
+        ReflectTypePath::Primitive(default_name)
-    );
+    } else {
+        ReflectTypePath::External {
+            path: &def.type_path,
+            custom_path: def.custom_path.map(|path| path.into_path(default_name)),
+            generics: &def.generics,
+        }
+    };
+
+    let meta = ReflectMeta::new(type_path, def.traits.unwrap_or_default());
 
     #[cfg(feature = "documentation")]
     let meta = meta.with_docs(documentation::Documentation::from_attributes(&def.attrs));
@@ -294,23 +350,27 @@ pub fn impl_reflect_value(input: TokenStream) -> TokenStream {
 /// which have greater functionality. The type being reflected must be in scope, as you cannot
 /// qualify it in the macro as e.g. `bevy::prelude::Vec3`.
 ///
+/// It is necessary to add a `#[type_path = "my_crate::foo"]` attribute to all types.
+///
 /// It may be necessary to add `#[reflect(Default)]` for some types, specifically non-constructible
 /// foreign types. Without `Default` reflected for such types, you will usually get an arcane
 /// error message and fail to compile. If the type does not implement `Default`, it may not
 /// be possible to reflect without extending the macro.
 ///
+///
 /// # Example
 /// Implementing `Reflect` for `bevy::prelude::Vec3` as a struct type:
 /// ```ignore
 /// use bevy::prelude::Vec3;
 ///
 /// impl_reflect_struct!(
-///    #[reflect(PartialEq, Serialize, Deserialize, Default)]
+///     #[reflect(PartialEq, Serialize, Deserialize, Default)]
-///    struct Vec3 {
+///     #[type_path = "bevy::prelude"]
-///        x: f32,
+///     struct Vec3 {
-///        y: f32,
+///         x: f32,
-///        z: f32
+///         y: f32,
-///    }
+///         z: f32
+///     }
 /// );
 /// ```
 #[proc_macro]
@@ -323,6 +383,15 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
 
     match derive_data {
         ReflectDerive::Struct(struct_data) => {
+            if !struct_data.meta().type_path().has_custom_path() {
+                return syn::Error::new(
+                    struct_data.meta().type_path().span(),
+                    format!("a #[{TYPE_PATH_ATTRIBUTE_NAME} = \"...\"] attribute must be specified when using `impl_reflect_struct`")
+                )
+                    .into_compile_error()
+                    .into();
+            }
+
             let impl_struct: proc_macro2::TokenStream = impls::impl_struct(&struct_data).into();
             let impl_from_struct: proc_macro2::TokenStream =
                 from_reflect::impl_struct(&struct_data).into();
@@ -370,11 +439,84 @@ pub fn impl_reflect_struct(input: TokenStream) -> TokenStream {
 #[proc_macro]
 pub fn impl_from_reflect_value(input: TokenStream) -> TokenStream {
     let def = parse_macro_input!(input as ReflectValueDef);
-    from_reflect::impl_value(&ReflectMeta::new(
+
-        &def.type_name,
+    let default_name = &def.type_path.segments.last().unwrap().ident;
-        &def.generics,
+    let type_path = if def.type_path.leading_colon.is_none()
-        def.traits.unwrap_or_default(),
+        && def.custom_path.is_none()
-    ))
+        && def.generics.params.is_empty()
+    {
+        ReflectTypePath::Primitive(default_name)
+    } else {
+        ReflectTypePath::External {
+            path: &def.type_path,
+            custom_path: def.custom_path.map(|alias| alias.into_path(default_name)),
+            generics: &def.generics,
+        }
+    };
+
+    from_reflect::impl_value(&ReflectMeta::new(type_path, def.traits.unwrap_or_default()))
+}
+
+/// A replacement for [deriving `TypePath`] for use on foreign types.
+///
+/// Since (unlike the derive) this macro may be invoked in a different module to where the type is defined,
+/// it requires an 'absolute' path definition.
+///
+/// Specifically, a leading `::` denoting a global path must be specified
+/// or a preceeding `(in my_crate::foo)` to specify the custom path must be used.
+///
+/// # Examples
+///
+/// Implementing `TypePath` on a foreign type:
+/// ```rust,ignore
+/// impl_type_path!(::foreign_crate::foo::bar::Baz);
+/// ```
+///
+/// On a generic type:
+/// ```rust,ignore
+/// impl_type_path!(::foreign_crate::Foo<T>);
+/// ```
+///
+/// On a primitive (note this will not compile for a non-primitive type):
+/// ```rust,ignore
+/// impl_type_path!(bool);
+/// ```
+///
+/// With a custom type path:
+/// ```rust,ignore
+/// impl_type_path!((in other_crate::foo::bar) Baz);
+/// ```
+///
+/// With a custom type path and a custom type name:
+/// ```rust,ignore
+/// impl_type_path!((in other_crate::foo as Baz) Bar);
+/// ```
+///
+/// [deriving `TypePath`]: TypePath
+#[proc_macro]
+pub fn impl_type_path(input: TokenStream) -> TokenStream {
+    let def = parse_macro_input!(input as NamedTypePathDef);
+
+    let type_path = match def {
+        NamedTypePathDef::External {
+            ref path,
+            custom_path,
+            ref generics,
+        } => {
+            let default_name = &path.segments.last().unwrap().ident;
+
+            ReflectTypePath::External {
+                path,
+                custom_path: custom_path.map(|path| path.into_path(default_name)),
+                generics,
+            }
+        }
+        NamedTypePathDef::Primtive(ref ident) => ReflectTypePath::Primitive(ident),
+    };
+
+    let meta = ReflectMeta::new(type_path, ReflectTraits::default());
+
+    impls::impl_type_path(&meta, &WhereClauseOptions::type_path_bounds(&meta)).into()
 }
 
 /// Derives `TypeUuid` for the given type. This is used internally to implement `TypeUuid` on foreign types, such as those in the std. This macro should be used in the format of `<[Generic Params]> [Type (Path)], [Uuid (String Literal)]`.

crates/bevy_reflect/bevy_reflect_derive/src/reflect_value.rs

@@ -1,58 +1,59 @@
 use crate::container_attributes::ReflectTraits;
-use proc_macro2::Ident;
+use crate::type_path::CustomPathDef;
 use syn::parse::{Parse, ParseStream};
-use syn::token::{Paren, Where};
+use syn::token::Paren;
-use syn::{parenthesized, Attribute, Generics};
+use syn::{parenthesized, Attribute, Generics, Path};
 
 /// A struct used to define a simple reflected value type (such as primitives).
 ///
+///
+///
 /// This takes the form:
 ///
 /// ```ignore
 /// // Standard
-/// foo(TraitA, TraitB)
+/// ::my_crate::foo::Bar(TraitA, TraitB)
 ///
 /// // With generics
-/// foo<T1: Bar, T2>(TraitA, TraitB)
+/// ::my_crate::foo::Bar<T1: Bar, T2>(TraitA, TraitB)
 ///
 /// // With generics and where clause
-/// foo<T1, T2> where T1: Bar (TraitA, TraitB)
+/// ::my_crate::foo::Bar<T1, T2> where T1: Bar (TraitA, TraitB)
+///
+/// // With a custom path (not with impl_from_reflect_value)
+/// (in my_crate::bar) Bar(TraitA, TraitB)
 /// ```
 pub(crate) struct ReflectValueDef {
     #[allow(dead_code)]
     pub attrs: Vec<Attribute>,
-    pub type_name: Ident,
+    pub type_path: Path,
     pub generics: Generics,
     pub traits: Option<ReflectTraits>,
+    pub custom_path: Option<CustomPathDef>,
 }
 
 impl Parse for ReflectValueDef {
     fn parse(input: ParseStream) -> syn::Result<Self> {
         let attrs = input.call(Attribute::parse_outer)?;
-        let type_ident = input.parse::<Ident>()?;
+
-        let generics = input.parse::<Generics>()?;
+        let custom_path = CustomPathDef::parse_parenthesized(input)?;
-        let mut lookahead = input.lookahead1();
+
-        let mut where_clause = None;
+        let type_path = Path::parse_mod_style(input)?;
-        if lookahead.peek(Where) {
+        let mut generics = input.parse::<Generics>()?;
-            where_clause = Some(input.parse()?);
+        generics.where_clause = input.parse()?;
-            lookahead = input.lookahead1();
-        }
 
         let mut traits = None;
-        if lookahead.peek(Paren) {
+        if input.peek(Paren) {
             let content;
             parenthesized!(content in input);
             traits = Some(content.parse::<ReflectTraits>()?);
         }
-
         Ok(ReflectValueDef {
             attrs,
-            type_name: type_ident,
+            type_path,
-            generics: Generics {
+            generics,
-                where_clause,
-                ..generics
-            },
             traits,
+            custom_path,
         })
     }
 }

crates/bevy_reflect/bevy_reflect_derive/src/registration.rs

@@ -2,21 +2,21 @@
 
 use crate::utility::{extend_where_clause, WhereClauseOptions};
 use bit_set::BitSet;
-use proc_macro2::Ident;
 use quote::quote;
-use syn::{Generics, Path};
+
+use crate::derive_data::ReflectMeta;
 
 /// Creates the `GetTypeRegistration` impl for the given type data.
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn impl_get_type_registration(
-    type_name: &Ident,
+    meta: &ReflectMeta,
-    bevy_reflect_path: &Path,
-    registration_data: &[Ident],
-    generics: &Generics,
     where_clause_options: &WhereClauseOptions,
     serialization_denylist: Option<&BitSet<u32>>,
 ) -> proc_macro2::TokenStream {
-    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
+    let type_path = meta.type_path();
+    let bevy_reflect_path = meta.bevy_reflect_path();
+    let registration_data = meta.traits().idents();
+    let (impl_generics, ty_generics, where_clause) = type_path.generics().split_for_impl();
     let serialization_data = serialization_denylist.map(|denylist| {
         let denylist = denylist.into_iter();
         quote! {
@@ -29,12 +29,12 @@ pub(crate) fn impl_get_type_registration(
 
     quote! {
         #[allow(unused_mut)]
-        impl #impl_generics #bevy_reflect_path::GetTypeRegistration for #type_name #ty_generics #where_reflect_clause {
+        impl #impl_generics #bevy_reflect_path::GetTypeRegistration for #type_path #ty_generics #where_reflect_clause {
             fn get_type_registration() -> #bevy_reflect_path::TypeRegistration {
-                let mut registration = #bevy_reflect_path::TypeRegistration::of::<#type_name #ty_generics>();
+                let mut registration = #bevy_reflect_path::TypeRegistration::of::<Self>();
-                registration.insert::<#bevy_reflect_path::ReflectFromPtr>(#bevy_reflect_path::FromType::<#type_name #ty_generics>::from_type());
+                registration.insert::<#bevy_reflect_path::ReflectFromPtr>(#bevy_reflect_path::FromType::<Self>::from_type());
                 #serialization_data
-                #(registration.insert::<#registration_data>(#bevy_reflect_path::FromType::<#type_name #ty_generics>::from_type());)*
+                #(registration.insert::<#registration_data>(#bevy_reflect_path::FromType::<Self>::from_type());)*
                 registration
             }
         }

crates/bevy_reflect/bevy_reflect_derive/src/type_path.rs

@@ -0,0 +1,102 @@
+use proc_macro2::Ident;
+use syn::{
+    parenthesized,
+    parse::{Parse, ParseStream},
+    token::Paren,
+    Generics, Path, PathSegment, Token,
+};
+
+pub(crate) fn parse_path_no_leading_colon(input: ParseStream) -> syn::Result<Path> {
+    if input.peek(Token![::]) {
+        return Err(input.error("did not expect a leading double colon (`::`)"));
+    }
+
+    let path = Path::parse_mod_style(input)?;
+
+    if path.segments.is_empty() {
+        Err(input.error("expected a path"))
+    } else {
+        Ok(path)
+    }
+}
+
+/// An alias for a `TypePath`.
+///
+/// This is the parenthesized part of `(in my_crate::foo as MyType) SomeType`.
+pub(crate) struct CustomPathDef {
+    path: Path,
+    name: Option<Ident>,
+}
+
+impl CustomPathDef {
+    pub fn into_path(mut self, default_name: &Ident) -> Path {
+        let name = PathSegment::from(self.name.unwrap_or_else(|| default_name.clone()));
+        self.path.segments.push(name);
+        self.path
+    }
+
+    pub fn parse_parenthesized(input: ParseStream) -> syn::Result<Option<Self>> {
+        if input.peek(Paren) {
+            let path;
+            parenthesized!(path in input);
+            Ok(Some(path.call(Self::parse)?))
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        input.parse::<Token![in]>()?;
+
+        let custom_path = parse_path_no_leading_colon(input)?;
+
+        if !input.peek(Token![as]) {
+            return Ok(Self {
+                path: custom_path,
+                name: None,
+            });
+        }
+
+        input.parse::<Token![as]>()?;
+        let custom_name: Ident = input.parse()?;
+
+        Ok(Self {
+            path: custom_path,
+            name: Some(custom_name),
+        })
+    }
+}
+
+pub(crate) enum NamedTypePathDef {
+    External {
+        path: Path,
+        generics: Generics,
+        custom_path: Option<CustomPathDef>,
+    },
+    Primtive(Ident),
+}
+
+impl Parse for NamedTypePathDef {
+    fn parse(input: ParseStream) -> syn::Result<Self> {
+        let custom_path = CustomPathDef::parse_parenthesized(input)?;
+
+        let path = Path::parse_mod_style(input)?;
+        let mut generics = input.parse::<Generics>()?;
+        generics.where_clause = input.parse()?;
+
+        if path.leading_colon.is_none() && custom_path.is_none() {
+            if path.segments.len() == 1 {
+                let ident = path.segments.into_iter().next().unwrap().ident;
+                Ok(NamedTypePathDef::Primtive(ident))
+            } else {
+                Err(input.error("non-customized paths must start with a double colon (`::`)"))
+            }
+        } else {
+            Ok(NamedTypePathDef::External {
+                path,
+                generics,
+                custom_path,
+            })
+        }
+    }
+}

crates/bevy_reflect/bevy_reflect_derive/src/utility.rs

@@ -1,11 +1,11 @@
 //! General-purpose utility functions for internal usage within this crate.
 
-use crate::field_attributes::ReflectIgnoreBehavior;
+use crate::{derive_data::ReflectMeta, field_attributes::ReflectIgnoreBehavior, fq_std::FQOption};
 use bevy_macro_utils::BevyManifest;
 use bit_set::BitSet;
 use proc_macro2::{Ident, Span};
-use quote::quote;
+use quote::{quote, ToTokens};
-use syn::{Member, Path, Type, WhereClause};
+use syn::{spanned::Spanned, LitStr, Member, Path, Type, WhereClause};
 
 /// Returns the correct path for `bevy_reflect`.
 pub(crate) fn get_bevy_reflect_path() -> Path {
@@ -60,6 +60,10 @@ pub(crate) fn ident_or_index(ident: Option<&Ident>, index: usize) -> Member {
 
 /// Options defining how to extend the `where` clause in reflection with any additional bounds needed.
 pub(crate) struct WhereClauseOptions {
+    /// Type parameters that need extra trait bounds.
+    pub(crate) parameter_types: Box<[Ident]>,
+    /// Trait bounds to add to the type parameters.
+    pub(crate) parameter_trait_bounds: proc_macro2::TokenStream,
     /// Any types that will be reflected and need an extra trait bound
     pub(crate) active_types: Box<[Type]>,
     /// Trait bounds to add to the active types
@@ -70,12 +74,31 @@ pub(crate) struct WhereClauseOptions {
     pub(crate) ignored_trait_bounds: proc_macro2::TokenStream,
 }
 
+impl WhereClauseOptions {
+    /// Extends a where clause, adding a `TypePath` bound to each type parameter.
+    pub fn type_path_bounds(meta: &ReflectMeta) -> Self {
+        let bevy_reflect_path = meta.bevy_reflect_path();
+        Self {
+            parameter_types: meta
+                .type_path()
+                .generics()
+                .type_params()
+                .map(|ty| ty.ident.clone())
+                .collect(),
+            parameter_trait_bounds: quote! { #bevy_reflect_path::TypePath },
+            ..Default::default()
+        }
+    }
+}
+
 impl Default for WhereClauseOptions {
     /// By default, don't add any additional bounds to the `where` clause
     fn default() -> Self {
         Self {
+            parameter_types: Box::new([]),
             active_types: Box::new([]),
             ignored_types: Box::new([]),
+            parameter_trait_bounds: quote! {},
             active_trait_bounds: quote! {},
             ignored_trait_bounds: quote! {},
         }
@@ -117,22 +140,26 @@ pub(crate) fn extend_where_clause(
     where_clause: Option<&WhereClause>,
     where_clause_options: &WhereClauseOptions,
 ) -> proc_macro2::TokenStream {
+    let parameter_types = &where_clause_options.parameter_types;
     let active_types = &where_clause_options.active_types;
     let ignored_types = &where_clause_options.ignored_types;
+    let parameter_trait_bounds = &where_clause_options.parameter_trait_bounds;
     let active_trait_bounds = &where_clause_options.active_trait_bounds;
     let ignored_trait_bounds = &where_clause_options.ignored_trait_bounds;
 
     let mut generic_where_clause = if let Some(where_clause) = where_clause {
         let predicates = where_clause.predicates.iter();
         quote! {where #(#predicates,)*}
-    } else if !(active_types.is_empty() && ignored_types.is_empty()) {
+    } else if !(parameter_types.is_empty() && active_types.is_empty() && ignored_types.is_empty()) {
         quote! {where}
     } else {
-        quote! {}
+        quote!()
     };
     generic_where_clause.extend(quote! {
         #(#active_types: #active_trait_bounds,)*
         #(#ignored_types: #ignored_trait_bounds,)*
+        // Leave parameter bounds to the end for more sane error messages.
+        #(#parameter_types: #parameter_trait_bounds,)*
     });
     generic_where_clause
 }
@@ -212,3 +239,118 @@ where
 
     bitset
 }
+
+/// Turns an `Option<TokenStream>` into a `TokenStream` for an `Option`.
+pub(crate) fn wrap_in_option(tokens: Option<proc_macro2::TokenStream>) -> proc_macro2::TokenStream {
+    match tokens {
+        Some(tokens) => quote! {
+            #FQOption::Some(#tokens)
+        },
+        None => quote! {
+            #FQOption::None
+        },
+    }
+}
+
+/// Contains tokens representing different kinds of string.
+#[derive(Clone)]
+pub(crate) enum StringExpr {
+    /// A string that is valid at compile time.
+    ///
+    /// This is either a string literal like `"mystring"`,
+    /// or a string created by a macro like [`module_path`]
+    /// or [`concat`].
+    Const(proc_macro2::TokenStream),
+    /// A [string slice](str) that is borrowed for a `'static` lifetime.
+    Borrowed(proc_macro2::TokenStream),
+    /// An [owned string](String).
+    Owned(proc_macro2::TokenStream),
+}
+
+impl<T: ToString + Spanned> From<T> for StringExpr {
+    fn from(value: T) -> Self {
+        Self::from_lit(&LitStr::new(&value.to_string(), value.span()))
+    }
+}
+
+impl StringExpr {
+    /// Creates a [constant] [`StringExpr`] from a [`struct@LitStr`].
+    ///
+    /// [constant]: StringExpr::Const
+    pub fn from_lit(lit: &LitStr) -> Self {
+        Self::Const(lit.to_token_stream())
+    }
+
+    /// Creates a [constant] [`StringExpr`] by interpreting a [string slice][str] as a [`struct@LitStr`].
+    ///
+    /// [constant]: StringExpr::Const
+    pub fn from_str(string: &str) -> Self {
+        Self::Const(string.into_token_stream())
+    }
+
+    /// Returns tokens for an [owned string](String).
+    ///
+    /// The returned expression will allocate unless the [`StringExpr`] is [already owned].
+    ///
+    /// [already owned]: StringExpr::Owned
+    pub fn into_owned(self) -> proc_macro2::TokenStream {
+        match self {
+            Self::Const(tokens) | Self::Borrowed(tokens) => quote! {
+                ::std::string::ToString::to_string(#tokens)
+            },
+            Self::Owned(owned) => owned,
+        }
+    }
+
+    /// Returns tokens for a statically borrowed [string slice](str).
+    pub fn into_borrowed(self) -> proc_macro2::TokenStream {
+        match self {
+            Self::Const(tokens) | Self::Borrowed(tokens) => tokens,
+            Self::Owned(owned) => quote! {
+                &#owned
+            },
+        }
+    }
+
+    /// Appends a [`StringExpr`] to another.
+    ///
+    /// If both expressions are [`StringExpr::Const`] this will use [`concat`] to merge them.
+    pub fn appended_by(mut self, other: StringExpr) -> Self {
+        if let Self::Const(tokens) = self {
+            if let Self::Const(more) = other {
+                return Self::Const(quote! {
+                    ::core::concat!(#tokens, #more)
+                });
+            }
+            self = Self::Const(tokens);
+        }
+
+        let owned = self.into_owned();
+        let borrowed = other.into_borrowed();
+        Self::Owned(quote! {
+            #owned + #borrowed
+        })
+    }
+}
+
+impl Default for StringExpr {
+    fn default() -> Self {
+        StringExpr::from_str("")
+    }
+}
+
+impl FromIterator<StringExpr> for StringExpr {
+    fn from_iter<T: IntoIterator<Item = StringExpr>>(iter: T) -> Self {
+        let mut iter = iter.into_iter();
+        match iter.next() {
+            Some(mut expr) => {
+                for next in iter {
+                    expr = expr.appended_by(next);
+                }
+
+                expr
+            }
+            None => Default::default(),
+        }
+    }
+}

crates/bevy_reflect/src/array.rs

@@ -1,4 +1,9 @@
-use crate::{utility::reflect_hasher, Reflect, ReflectMut, ReflectOwned, ReflectRef, TypeInfo};
+use bevy_reflect_derive::impl_type_path;
+
+use crate::{
+    self as bevy_reflect, utility::reflect_hasher, DynamicTypePath, Reflect, ReflectMut,
+    ReflectOwned, ReflectRef, TypeInfo,
+};
 use std::{
     any::{Any, TypeId},
     fmt::Debug,
@@ -221,6 +226,11 @@ impl Reflect for DynamicArray {
         self.represented_type
     }
 
+    #[inline]
+    fn get_type_path(&self) -> &dyn DynamicTypePath {
+        self
+    }
+
     #[inline]
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
@@ -335,6 +345,7 @@ impl Array for DynamicArray {
     }
 }
 
+impl_type_path!((in bevy_reflect) DynamicArray);
 /// An iterator over an [`Array`].
 pub struct ArrayIter<'a> {
     array: &'a dyn Array,

crates/bevy_reflect/src/enums/dynamic_enum.rs

@@ -1,6 +1,9 @@
+use bevy_reflect_derive::impl_type_path;
+
 use crate::{
-    enum_debug, enum_hash, enum_partial_eq, DynamicStruct, DynamicTuple, Enum, Reflect, ReflectMut,
+    self as bevy_reflect, enum_debug, enum_hash, enum_partial_eq, DynamicStruct, DynamicTuple,
-    ReflectOwned, ReflectRef, Struct, Tuple, TypeInfo, VariantFieldIter, VariantType,
+    DynamicTypePath, Enum, Reflect, ReflectMut, ReflectOwned, ReflectRef, Struct, Tuple, TypeInfo,
+    VariantFieldIter, VariantType,
 };
 use std::any::Any;
 use std::fmt::Formatter;
@@ -297,6 +300,11 @@ impl Reflect for DynamicEnum {
         self.represented_type
     }
 
+    #[inline]
+    fn get_type_path(&self) -> &dyn DynamicTypePath {
+        self
+    }
+
     #[inline]
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
@@ -420,3 +428,5 @@ impl Reflect for DynamicEnum {
         write!(f, ")")
     }
 }
+
+impl_type_path!((in bevy_reflect) DynamicEnum);

crates/bevy_reflect/src/impls/glam.rs

@@ -6,6 +6,7 @@ use glam::*;
 
 impl_reflect_struct!(
     #[reflect(Debug, Hash, PartialEq, Default)]
+    #[type_path = "glam"]
     struct IVec2 {
         x: i32,
         y: i32,
@@ -13,6 +14,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, Hash, PartialEq, Default)]
+    #[type_path = "glam"]
     struct IVec3 {
         x: i32,
         y: i32,
@@ -21,6 +23,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, Hash, PartialEq, Default)]
+    #[type_path = "glam"]
     struct IVec4 {
         x: i32,
         y: i32,
@@ -31,6 +34,7 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(Debug, Hash, PartialEq, Default)]
+    #[type_path = "glam"]
     struct UVec2 {
         x: u32,
         y: u32,
@@ -38,6 +42,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, Hash, PartialEq, Default)]
+    #[type_path = "glam"]
     struct UVec3 {
         x: u32,
         y: u32,
@@ -46,6 +51,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, Hash, PartialEq, Default)]
+    #[type_path = "glam"]
     struct UVec4 {
         x: u32,
         y: u32,
@@ -53,9 +59,9 @@ impl_reflect_struct!(
         w: u32,
     }
 );
-
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct Vec2 {
         x: f32,
         y: f32,
@@ -63,6 +69,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct Vec3 {
         x: f32,
         y: f32,
@@ -71,6 +78,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct Vec3A {
         x: f32,
         y: f32,
@@ -79,6 +87,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct Vec4 {
         x: f32,
         y: f32,
@@ -89,6 +98,7 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct BVec2 {
         x: bool,
         y: bool,
@@ -96,6 +106,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct BVec3 {
         x: bool,
         y: bool,
@@ -104,6 +115,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct BVec4 {
         x: bool,
         y: bool,
@@ -114,6 +126,7 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct DVec2 {
         x: f64,
         y: f64,
@@ -121,6 +134,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct DVec3 {
         x: f64,
         y: f64,
@@ -129,6 +143,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct DVec4 {
         x: f64,
         y: f64,
@@ -139,6 +154,7 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct Mat2 {
         x_axis: Vec2,
         y_axis: Vec2,
@@ -146,6 +162,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct Mat3 {
         x_axis: Vec3,
         y_axis: Vec3,
@@ -154,6 +171,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct Mat3A {
         x_axis: Vec3A,
         y_axis: Vec3A,
@@ -162,6 +180,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct Mat4 {
         x_axis: Vec4,
         y_axis: Vec4,
@@ -172,6 +191,7 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct DMat2 {
         x_axis: DVec2,
         y_axis: DVec2,
@@ -179,6 +199,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct DMat3 {
         x_axis: DVec3,
         y_axis: DVec3,
@@ -187,6 +208,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct DMat4 {
         x_axis: DVec4,
         y_axis: DVec4,
@@ -197,6 +219,7 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct Affine2 {
         matrix2: Mat2,
         translation: Vec2,
@@ -204,6 +227,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct Affine3A {
         matrix3: Mat3A,
         translation: Vec3A,
@@ -212,6 +236,7 @@ impl_reflect_struct!(
 
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct DAffine2 {
         matrix2: DMat2,
         translation: DVec2,
@@ -219,6 +244,7 @@ impl_reflect_struct!(
 );
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Default)]
+    #[type_path = "glam"]
     struct DAffine3 {
         matrix3: DMat3,
         translation: DVec3,
@@ -229,12 +255,24 @@ impl_reflect_struct!(
 // mechanisms for read-only fields. I doubt those mechanisms would be added,
 // so for now quaternions will remain as values. They are represented identically
 // to Vec4 and DVec4, so you may use those instead and convert between.
-impl_reflect_value!(Quat(Debug, PartialEq, Serialize, Deserialize, Default));
+impl_reflect_value!(::glam::Quat(
-impl_reflect_value!(DQuat(Debug, PartialEq, Serialize, Deserialize, Default));
+    Debug,
+    PartialEq,
+    Serialize,
+    Deserialize,
+    Default
+));
+impl_reflect_value!(::glam::DQuat(
+    Debug,
+    PartialEq,
+    Serialize,
+    Deserialize,
+    Default
+));
 
 impl_from_reflect_value!(Quat);
 impl_from_reflect_value!(DQuat);
 
-impl_reflect_value!(EulerRot(Debug, Default));
+impl_reflect_value!(::glam::EulerRot(Debug, Default));
-impl_reflect_value!(BVec3A(Debug, Default));
+impl_reflect_value!(::glam::BVec3A(Debug, Default));
-impl_reflect_value!(BVec4A(Debug, Default));
+impl_reflect_value!(::glam::BVec4A(Debug, Default));

crates/bevy_reflect/src/impls/rect.rs

@@ -6,6 +6,7 @@ use bevy_reflect_derive::impl_reflect_struct;
 
 impl_reflect_struct!(
     #[reflect(Debug, PartialEq, Serialize, Deserialize, Default)]
+    #[type_path = "bevy_math"]
     struct Rect {
         min: Vec2,
         max: Vec2,

crates/bevy_reflect/src/impls/smallvec.rs

@@ -1,13 +1,15 @@
+use bevy_reflect_derive::impl_type_path;
 use smallvec::SmallVec;
 use std::any::Any;
 
 use crate::utility::GenericTypeInfoCell;
 use crate::{
-    FromReflect, FromType, GetTypeRegistration, List, ListInfo, ListIter, Reflect, ReflectFromPtr,
+    self as bevy_reflect, DynamicTypePath, FromReflect, FromType, GetTypeRegistration, List,
-    ReflectMut, ReflectOwned, ReflectRef, TypeInfo, TypeRegistration, Typed,
+    ListInfo, ListIter, Reflect, ReflectFromPtr, ReflectMut, ReflectOwned, ReflectRef, TypeInfo,
+    TypePath, TypeRegistration, Typed,
 };
 
-impl<T: smallvec::Array + Send + Sync + 'static> List for SmallVec<T>
+impl<T: smallvec::Array + TypePath + Send + Sync> List for SmallVec<T>
 where
     T::Item: FromReflect,
 {
@@ -74,7 +76,7 @@ where
     }
 }
 
-impl<T: smallvec::Array + Send + Sync + 'static> Reflect for SmallVec<T>
+impl<T: smallvec::Array + TypePath + Send + Sync> Reflect for SmallVec<T>
 where
     T::Item: FromReflect,
 {
@@ -86,6 +88,11 @@ where
         Some(<Self as Typed>::type_info())
     }
 
+    #[inline]
+    fn get_type_path(&self) -> &dyn DynamicTypePath {
+        self
+    }
+
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
     }
@@ -140,7 +147,7 @@ where
     }
 }
 
-impl<T: smallvec::Array + Send + Sync + 'static> Typed for SmallVec<T>
+impl<T: smallvec::Array + TypePath + Send + Sync + 'static> Typed for SmallVec<T>
 where
     T::Item: FromReflect,
 {
@@ -150,7 +157,9 @@ where
     }
 }
 
-impl<T: smallvec::Array + Send + Sync + 'static> FromReflect for SmallVec<T>
+impl_type_path!(::smallvec::SmallVec<T: smallvec::Array + TypePath + Send + Sync>);
+
+impl<T: smallvec::Array + TypePath + Send + Sync> FromReflect for SmallVec<T>
 where
     T::Item: FromReflect,
 {
@@ -167,7 +176,7 @@ where
     }
 }
 
-impl<T: smallvec::Array + Send + Sync + 'static> GetTypeRegistration for SmallVec<T>
+impl<T: smallvec::Array + TypePath + Send + Sync> GetTypeRegistration for SmallVec<T>
 where
     T::Item: FromReflect,
 {

crates/bevy_reflect/src/impls/std.rs

@@ -1,14 +1,16 @@
 use crate::std_traits::ReflectDefault;
 use crate::{self as bevy_reflect, ReflectFromPtr, ReflectFromReflect, ReflectOwned};
 use crate::{
-    map_apply, map_partial_eq, Array, ArrayInfo, ArrayIter, DynamicEnum, DynamicMap, Enum,
+    impl_type_path, map_apply, map_partial_eq, Array, ArrayInfo, ArrayIter, DynamicEnum,
-    EnumInfo, FromReflect, FromType, GetTypeRegistration, List, ListInfo, Map, MapInfo, MapIter,
+    DynamicMap, DynamicTypePath, Enum, EnumInfo, FromReflect, FromType, GetTypeRegistration, List,
-    Reflect, ReflectDeserialize, ReflectMut, ReflectRef, ReflectSerialize, TupleVariantInfo,
+    ListInfo, ListIter, Map, MapInfo, MapIter, Reflect, ReflectDeserialize, ReflectMut, ReflectRef,
-    TypeInfo, TypeRegistration, Typed, UnitVariantInfo, UnnamedField, ValueInfo, VariantFieldIter,
+    ReflectSerialize, TupleVariantInfo, TypeInfo, TypePath, TypeRegistration, Typed,
-    VariantInfo, VariantType,
+    UnitVariantInfo, UnnamedField, ValueInfo, VariantFieldIter, VariantInfo, VariantType,
 };
 
-use crate::utility::{reflect_hasher, GenericTypeInfoCell, NonGenericTypeInfoCell};
+use crate::utility::{
+    reflect_hasher, GenericTypeInfoCell, GenericTypePathCell, NonGenericTypeInfoCell,
+};
 use bevy_reflect_derive::{impl_from_reflect_value, impl_reflect_value};
 use bevy_utils::HashSet;
 use bevy_utils::{Duration, Instant};
@@ -93,7 +95,7 @@ impl_reflect_value!(String(
     Deserialize,
     Default
 ));
-impl_reflect_value!(PathBuf(
+impl_reflect_value!(::std::path::PathBuf(
     Debug,
     Hash,
     PartialEq,
@@ -101,15 +103,18 @@ impl_reflect_value!(PathBuf(
     Deserialize,
     Default
 ));
-impl_reflect_value!(Result<T: Clone + Reflect + 'static, E: Clone + Reflect + 'static>());
+impl_reflect_value!(
-impl_reflect_value!(HashSet<T: Hash + Eq + Clone + Send + Sync + 'static>());
+    ::core::result::Result < T: Clone + Reflect + TypePath,
-impl_reflect_value!(Range<T: Clone + Send + Sync + 'static>());
+    E: Clone + Reflect + TypePath > ()
-impl_reflect_value!(RangeInclusive<T: Clone + Send + Sync + 'static>());
+);
-impl_reflect_value!(RangeFrom<T: Clone + Send + Sync + 'static>());
+impl_reflect_value!(::bevy_utils::HashSet<T: Hash + Eq + Clone + Send + Sync>());
-impl_reflect_value!(RangeTo<T: Clone + Send + Sync + 'static>());
+impl_reflect_value!(::core::ops::Range<T: Clone + Send + Sync>());
-impl_reflect_value!(RangeToInclusive<T: Clone + Send + Sync + 'static>());
+impl_reflect_value!(::core::ops::RangeInclusive<T: Clone + Send + Sync>());
-impl_reflect_value!(RangeFull());
+impl_reflect_value!(::core::ops::RangeFrom<T: Clone + Send + Sync>());
-impl_reflect_value!(Duration(
+impl_reflect_value!(::core::ops::RangeTo<T: Clone + Send + Sync>());
+impl_reflect_value!(::core::ops::RangeToInclusive<T: Clone + Send + Sync>());
+impl_reflect_value!(::core::ops::RangeFull());
+impl_reflect_value!(::bevy_utils::Duration(
     Debug,
     Hash,
     PartialEq,
@@ -117,26 +122,104 @@ impl_reflect_value!(Duration(
     Deserialize,
     Default
 ));
-impl_reflect_value!(Instant(Debug, Hash, PartialEq));
+impl_reflect_value!(::bevy_utils::Instant(Debug, Hash, PartialEq));
-impl_reflect_value!(NonZeroI128(Debug, Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(::core::num::NonZeroI128(
-impl_reflect_value!(NonZeroU128(Debug, Hash, PartialEq, Serialize, Deserialize));
+    Debug,
-impl_reflect_value!(NonZeroIsize(Debug, Hash, PartialEq, Serialize, Deserialize));
+    Hash,
-impl_reflect_value!(NonZeroUsize(Debug, Hash, PartialEq, Serialize, Deserialize));
+    PartialEq,
-impl_reflect_value!(NonZeroI64(Debug, Hash, PartialEq, Serialize, Deserialize));
+    Serialize,
-impl_reflect_value!(NonZeroU64(Debug, Hash, PartialEq, Serialize, Deserialize));
+    Deserialize
-impl_reflect_value!(NonZeroU32(Debug, Hash, PartialEq, Serialize, Deserialize));
+));
-impl_reflect_value!(NonZeroI32(Debug, Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(::core::num::NonZeroU128(
-impl_reflect_value!(NonZeroI16(Debug, Hash, PartialEq, Serialize, Deserialize));
+    Debug,
-impl_reflect_value!(NonZeroU16(Debug, Hash, PartialEq, Serialize, Deserialize));
+    Hash,
-impl_reflect_value!(NonZeroU8(Debug, Hash, PartialEq, Serialize, Deserialize));
+    PartialEq,
-impl_reflect_value!(NonZeroI8(Debug, Hash, PartialEq, Serialize, Deserialize));
+    Serialize,
+    Deserialize
+));
+impl_reflect_value!(::core::num::NonZeroIsize(
+    Debug,
+    Hash,
+    PartialEq,
+    Serialize,
+    Deserialize
+));
+impl_reflect_value!(::core::num::NonZeroUsize(
+    Debug,
+    Hash,
+    PartialEq,
+    Serialize,
+    Deserialize
+));
+impl_reflect_value!(::core::num::NonZeroI64(
+    Debug,
+    Hash,
+    PartialEq,
+    Serialize,
+    Deserialize
+));
+impl_reflect_value!(::core::num::NonZeroU64(
+    Debug,
+    Hash,
+    PartialEq,
+    Serialize,
+    Deserialize
+));
+impl_reflect_value!(::core::num::NonZeroU32(
+    Debug,
+    Hash,
+    PartialEq,
+    Serialize,
+    Deserialize
+));
+impl_reflect_value!(::core::num::NonZeroI32(
+    Debug,
+    Hash,
+    PartialEq,
+    Serialize,
+    Deserialize
+));
+impl_reflect_value!(::core::num::NonZeroI16(
+    Debug,
+    Hash,
+    PartialEq,
+    Serialize,
+    Deserialize
+));
+impl_reflect_value!(::core::num::NonZeroU16(
+    Debug,
+    Hash,
+    PartialEq,
+    Serialize,
+    Deserialize
+));
+impl_reflect_value!(::core::num::NonZeroU8(
+    Debug,
+    Hash,
+    PartialEq,
+    Serialize,
+    Deserialize
+));
+impl_reflect_value!(::core::num::NonZeroI8(
+    Debug,
+    Hash,
+    PartialEq,
+    Serialize,
+    Deserialize
+));
 
 // `Serialize` and `Deserialize` only for platforms supported by serde:
 // https://github.com/serde-rs/serde/blob/3ffb86fc70efd3d329519e2dddfa306cc04f167c/serde/src/de/impls.rs#L1732
 #[cfg(any(unix, windows))]
-impl_reflect_value!(OsString(Debug, Hash, PartialEq, Serialize, Deserialize));
+impl_reflect_value!(::std::ffi::OsString(
+    Debug,
+    Hash,
+    PartialEq,
+    Serialize,
+    Deserialize
+));
 #[cfg(not(any(unix, windows)))]
-impl_reflect_value!(OsString(Debug, Hash, PartialEq));
+impl_reflect_value!(::std::ffi::OsString(Debug, Hash, PartialEq));
 
 impl_from_reflect_value!(bool);
 impl_from_reflect_value!(char);
@@ -157,12 +240,12 @@ impl_from_reflect_value!(f64);
 impl_from_reflect_value!(String);
 impl_from_reflect_value!(PathBuf);
 impl_from_reflect_value!(OsString);
-impl_from_reflect_value!(HashSet<T: Hash + Eq + Clone + Send + Sync + 'static>);
+impl_from_reflect_value!(HashSet<T: TypePath + Hash + Eq + Clone + Send + Sync>);
-impl_from_reflect_value!(Range<T: Clone + Send + Sync + 'static>);
+impl_from_reflect_value!(Range<T: TypePath + Clone + Send + Sync>);
-impl_from_reflect_value!(RangeInclusive<T: Clone + Send + Sync + 'static>);
+impl_from_reflect_value!(RangeInclusive<T: TypePath + Clone + Send + Sync>);
-impl_from_reflect_value!(RangeFrom<T: Clone + Send + Sync + 'static>);
+impl_from_reflect_value!(RangeFrom<T: TypePath + Clone + Send + Sync>);
-impl_from_reflect_value!(RangeTo<T: Clone + Send + Sync + 'static>);
+impl_from_reflect_value!(RangeTo<T: TypePath + Clone + Send + Sync>);
-impl_from_reflect_value!(RangeToInclusive<T: Clone + Send + Sync + 'static>);
+impl_from_reflect_value!(RangeToInclusive<T: TypePath + Clone + Send + Sync>);
 impl_from_reflect_value!(RangeFull);
 impl_from_reflect_value!(Duration);
 impl_from_reflect_value!(Instant);
@@ -180,8 +263,8 @@ impl_from_reflect_value!(NonZeroU8);
 impl_from_reflect_value!(NonZeroI8);
 
 macro_rules! impl_reflect_for_veclike {
-    ($ty:ty, $insert:expr, $remove:expr, $push:expr, $pop:expr, $sub:ty) => {
+    ($ty:path, $insert:expr, $remove:expr, $push:expr, $pop:expr, $sub:ty) => {
-        impl<T: FromReflect> List for $ty {
+        impl<T: FromReflect + TypePath> List for $ty {
             #[inline]
             fn get(&self, index: usize) -> Option<&dyn Reflect> {
                 <$sub>::get(self, index).map(|value| value as &dyn Reflect)
@@ -228,8 +311,8 @@ macro_rules! impl_reflect_for_veclike {
             }
 
             #[inline]
-            fn iter(&self) -> $crate::ListIter {
+            fn iter(&self) -> ListIter {
-                $crate::ListIter::new(self)
+                ListIter::new(self)
             }
 
             #[inline]
@@ -240,7 +323,7 @@ macro_rules! impl_reflect_for_veclike {
             }
         }
 
-        impl<T: FromReflect> Reflect for $ty {
+        impl<T: FromReflect + TypePath> Reflect for $ty {
             fn type_name(&self) -> &str {
                 std::any::type_name::<Self>()
             }
@@ -249,6 +332,11 @@ macro_rules! impl_reflect_for_veclike {
                 Some(<Self as Typed>::type_info())
             }
 
+            #[inline]
+            fn get_type_path(&self) -> &dyn DynamicTypePath {
+                self
+            }
+
             fn into_any(self: Box<Self>) -> Box<dyn Any> {
                 self
             }
@@ -307,14 +395,16 @@ macro_rules! impl_reflect_for_veclike {
             }
         }
 
-        impl<T: FromReflect> Typed for $ty {
+        impl<T: FromReflect + TypePath> Typed for $ty {
             fn type_info() -> &'static TypeInfo {
                 static CELL: GenericTypeInfoCell = GenericTypeInfoCell::new();
                 CELL.get_or_insert::<Self, _>(|| TypeInfo::List(ListInfo::new::<Self, T>()))
             }
         }
 
-        impl<T: FromReflect> GetTypeRegistration for $ty {
+        impl_type_path!($ty where T: FromReflect);
+
+        impl<T: FromReflect + TypePath> GetTypeRegistration for $ty {
             fn get_type_registration() -> TypeRegistration {
                 let mut registration = TypeRegistration::of::<$ty>();
                 registration.insert::<ReflectFromPtr>(FromType::<$ty>::from_type());
@@ -322,7 +412,7 @@ macro_rules! impl_reflect_for_veclike {
             }
         }
 
-        impl<T: FromReflect> FromReflect for $ty {
+        impl<T: FromReflect + TypePath> FromReflect for $ty {
             fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
                 if let ReflectRef::List(ref_list) = reflect.reflect_ref() {
                     let mut new_list = Self::with_capacity(ref_list.len());
@@ -338,9 +428,16 @@ macro_rules! impl_reflect_for_veclike {
     };
 }
 
-impl_reflect_for_veclike!(Vec<T>, Vec::insert, Vec::remove, Vec::push, Vec::pop, [T]);
 impl_reflect_for_veclike!(
-    VecDeque<T>,
+    ::alloc::vec::Vec<T>,
+    Vec::insert,
+    Vec::remove,
+    Vec::push,
+    Vec::pop,
+    [T]
+);
+impl_reflect_for_veclike!(
+    ::alloc::collections::VecDeque<T>,
     VecDeque::insert,
     VecDeque::remove,
     VecDeque::push_back,
@@ -349,12 +446,12 @@ impl_reflect_for_veclike!(
 );
 
 macro_rules! impl_reflect_for_hashmap {
-    ($ty:ty) => {
+    ($ty:path) => {
         impl<K, V, S> Map for $ty
         where
-            K: FromReflect + Eq + Hash,
+            K: FromReflect + TypePath + Eq + Hash,
-            V: FromReflect,
+            V: FromReflect + TypePath,
-            S: BuildHasher + Send + Sync + 'static,
+            S: TypePath + BuildHasher + Send + Sync,
         {
             fn get(&self, key: &dyn Reflect) -> Option<&dyn Reflect> {
                 key.downcast_ref::<K>()
@@ -446,9 +543,9 @@ macro_rules! impl_reflect_for_hashmap {
 
         impl<K, V, S> Reflect for $ty
         where
-            K: FromReflect + Eq + Hash,
+            K: FromReflect + TypePath + Eq + Hash,
-            V: FromReflect,
+            V: FromReflect + TypePath,
-            S: BuildHasher + Send + Sync + 'static,
+            S: TypePath + BuildHasher + Send + Sync,
         {
             fn type_name(&self) -> &str {
                 std::any::type_name::<Self>()
@@ -458,6 +555,10 @@ macro_rules! impl_reflect_for_hashmap {
                 Some(<Self as Typed>::type_info())
             }
 
+            fn get_type_path(&self) -> &dyn DynamicTypePath {
+                self
+            }
+
             fn into_any(self: Box<Self>) -> Box<dyn Any> {
                 self
             }
@@ -515,9 +616,9 @@ macro_rules! impl_reflect_for_hashmap {
 
         impl<K, V, S> Typed for $ty
         where
-            K: FromReflect + Eq + Hash,
+            K: FromReflect + TypePath + Eq + Hash,
-            V: FromReflect,
+            V: FromReflect + TypePath,
-            S: BuildHasher + Send + Sync + 'static,
+            S: TypePath + BuildHasher + Send + Sync,
         {
             fn type_info() -> &'static TypeInfo {
                 static CELL: GenericTypeInfoCell = GenericTypeInfoCell::new();
@@ -527,9 +628,9 @@ macro_rules! impl_reflect_for_hashmap {
 
         impl<K, V, S> GetTypeRegistration for $ty
         where
-            K: FromReflect + Eq + Hash,
+            K: FromReflect + TypePath + Eq + Hash,
-            V: FromReflect,
+            V: FromReflect + TypePath,
-            S: BuildHasher + Send + Sync + 'static,
+            S: TypePath + BuildHasher + Send + Sync,
         {
             fn get_type_registration() -> TypeRegistration {
                 let mut registration = TypeRegistration::of::<Self>();
@@ -540,9 +641,9 @@ macro_rules! impl_reflect_for_hashmap {
 
         impl<K, V, S> FromReflect for $ty
         where
-            K: FromReflect + Eq + Hash,
+            K: FromReflect + TypePath + Eq + Hash,
-            V: FromReflect,
+            V: FromReflect + TypePath,
-            S: BuildHasher + Default + Send + Sync + 'static,
+            S: TypePath + BuildHasher + Default + Send + Sync,
         {
             fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
                 if let ReflectRef::Map(ref_map) = reflect.reflect_ref() {
@@ -561,10 +662,27 @@ macro_rules! impl_reflect_for_hashmap {
     };
 }
 
-impl_reflect_for_hashmap!(bevy_utils::hashbrown::HashMap<K, V, S>);
+impl_reflect_for_hashmap!(::std::collections::HashMap<K, V, S>);
-impl_reflect_for_hashmap!(std::collections::HashMap<K, V, S>);
+impl_type_path!(::std::collections::hash_map::RandomState);
+impl_type_path!(
+    ::std::collections::HashMap<K, V, S>
+    where
+        K: FromReflect + Eq + Hash + ?Sized,
+        V: FromReflect + ?Sized,
+        S: BuildHasher + Send + Sync + 'static,
+);
 
-impl<T: Reflect, const N: usize> Array for [T; N] {
+impl_reflect_for_hashmap!(bevy_utils::hashbrown::HashMap<K, V, S>);
+impl_type_path!(::bevy_utils::hashbrown::hash_map::DefaultHashBuilder);
+impl_type_path!(
+    ::bevy_utils::hashbrown::HashMap<K, V, S>
+    where
+        K: FromReflect + Eq + Hash + ?Sized,
+        V: FromReflect + ?Sized,
+        S: BuildHasher + Send + Sync + 'static,
+);
+
+impl<T: Reflect + TypePath, const N: usize> Array for [T; N] {
     #[inline]
     fn get(&self, index: usize) -> Option<&dyn Reflect> {
         <[T]>::get(self, index).map(|value| value as &dyn Reflect)
@@ -593,7 +711,7 @@ impl<T: Reflect, const N: usize> Array for [T; N] {
     }
 }
 
-impl<T: Reflect, const N: usize> Reflect for [T; N] {
+impl<T: Reflect + TypePath, const N: usize> Reflect for [T; N] {
     #[inline]
     fn type_name(&self) -> &str {
         std::any::type_name::<Self>()
@@ -603,6 +721,11 @@ impl<T: Reflect, const N: usize> Reflect for [T; N] {
         Some(<Self as Typed>::type_info())
     }
 
+    #[inline]
+    fn get_type_path(&self) -> &dyn DynamicTypePath {
+        self
+    }
+
     #[inline]
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
@@ -675,7 +798,7 @@ impl<T: Reflect, const N: usize> Reflect for [T; N] {
     }
 }
 
-impl<T: FromReflect, const N: usize> FromReflect for [T; N] {
+impl<T: FromReflect + TypePath, const N: usize> FromReflect for [T; N] {
     fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
         if let ReflectRef::Array(ref_array) = reflect.reflect_ref() {
             let mut temp_vec = Vec::with_capacity(ref_array.len());
@@ -689,13 +812,25 @@ impl<T: FromReflect, const N: usize> FromReflect for [T; N] {
     }
 }
 
-impl<T: Reflect, const N: usize> Typed for [T; N] {
+impl<T: Reflect + TypePath, const N: usize> Typed for [T; N] {
     fn type_info() -> &'static TypeInfo {
         static CELL: GenericTypeInfoCell = GenericTypeInfoCell::new();
         CELL.get_or_insert::<Self, _>(|| TypeInfo::Array(ArrayInfo::new::<Self, T>(N)))
     }
 }
 
+impl<T: Reflect + TypePath, const N: usize> TypePath for [T; N] {
+    fn type_path() -> &'static str {
+        static CELL: GenericTypePathCell = GenericTypePathCell::new();
+        CELL.get_or_insert::<Self, _>(|| format!("[{t}; {N}]", t = T::type_path()))
+    }
+
+    fn short_type_path() -> &'static str {
+        static CELL: GenericTypePathCell = GenericTypePathCell::new();
+        CELL.get_or_insert::<Self, _>(|| format!("[{t}; {N}]", t = T::short_type_path()))
+    }
+}
+
 // TODO:
 // `FromType::from_type` requires `Deserialize<'de>` to be implemented for `T`.
 // Currently serde only supports `Deserialize<'de>` for arrays up to size 32.
@@ -704,7 +839,7 @@ impl<T: Reflect, const N: usize> Typed for [T; N] {
 macro_rules! impl_array_get_type_registration {
     ($($N:expr)+) => {
         $(
-            impl<T: Reflect > GetTypeRegistration for [T; $N] {
+            impl<T: Reflect + TypePath> GetTypeRegistration for [T; $N] {
                 fn get_type_registration() -> TypeRegistration {
                     TypeRegistration::of::<[T; $N]>()
                 }
@@ -720,13 +855,13 @@ impl_array_get_type_registration! {
     30 31 32
 }
 
-impl<T: FromReflect> GetTypeRegistration for Option<T> {
+impl<T: FromReflect + TypePath> GetTypeRegistration for Option<T> {
     fn get_type_registration() -> TypeRegistration {
         TypeRegistration::of::<Option<T>>()
     }
 }
 
-impl<T: FromReflect> Enum for Option<T> {
+impl<T: FromReflect + TypePath> Enum for Option<T> {
     fn field(&self, _name: &str) -> Option<&dyn Reflect> {
         None
     }
@@ -797,7 +932,7 @@ impl<T: FromReflect> Enum for Option<T> {
     }
 }
 
-impl<T: FromReflect> Reflect for Option<T> {
+impl<T: FromReflect + TypePath> Reflect for Option<T> {
     #[inline]
     fn type_name(&self) -> &str {
         std::any::type_name::<Self>()
@@ -808,6 +943,11 @@ impl<T: FromReflect> Reflect for Option<T> {
         Some(<Self as Typed>::type_info())
     }
 
+    #[inline]
+    fn get_type_path(&self) -> &dyn DynamicTypePath {
+        self
+    }
+
     #[inline]
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
@@ -911,7 +1051,7 @@ impl<T: FromReflect> Reflect for Option<T> {
     }
 }
 
-impl<T: FromReflect> FromReflect for Option<T> {
+impl<T: FromReflect + TypePath> FromReflect for Option<T> {
     fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
         if let ReflectRef::Enum(dyn_enum) = reflect.reflect_ref() {
             match dyn_enum.variant_name() {
@@ -949,7 +1089,7 @@ impl<T: FromReflect> FromReflect for Option<T> {
     }
 }
 
-impl<T: FromReflect> Typed for Option<T> {
+impl<T: FromReflect + TypePath> Typed for Option<T> {
     fn type_info() -> &'static TypeInfo {
         static CELL: GenericTypeInfoCell = GenericTypeInfoCell::new();
         CELL.get_or_insert::<Self, _>(|| {
@@ -964,6 +1104,8 @@ impl<T: FromReflect> Typed for Option<T> {
     }
 }
 
+impl_type_path!(::core::option::Option<T: FromReflect + TypePath>);
+
 impl Reflect for Cow<'static, str> {
     fn type_name(&self) -> &str {
         std::any::type_name::<Self>()
@@ -973,6 +1115,11 @@ impl Reflect for Cow<'static, str> {
         Some(<Self as Typed>::type_info())
     }
 
+    #[inline]
+    fn get_type_path(&self) -> &dyn DynamicTypePath {
+        self
+    }
+
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
     }
@@ -1051,6 +1198,30 @@ impl Typed for Cow<'static, str> {
     }
 }
 
+impl TypePath for Cow<'static, str> {
+    fn type_path() -> &'static str {
+        static CELL: GenericTypePathCell = GenericTypePathCell::new();
+        CELL.get_or_insert::<Self, _>(|| "std::borrow::Cow::<str>".to_owned())
+    }
+
+    fn short_type_path() -> &'static str {
+        static CELL: GenericTypePathCell = GenericTypePathCell::new();
+        CELL.get_or_insert::<Self, _>(|| "Cow<str>".to_owned())
+    }
+
+    fn type_ident() -> Option<&'static str> {
+        Some("Cow")
+    }
+
+    fn crate_name() -> Option<&'static str> {
+        Some("std")
+    }
+
+    fn module_path() -> Option<&'static str> {
+        Some("std::borrow")
+    }
+}
+
 impl GetTypeRegistration for Cow<'static, str> {
     fn get_type_registration() -> TypeRegistration {
         let mut registration = TypeRegistration::of::<Cow<'static, str>>();
@@ -1081,6 +1252,11 @@ impl Reflect for &'static Path {
         Some(<Self as Typed>::type_info())
     }
 
+    #[inline]
+    fn get_type_path(&self) -> &dyn DynamicTypePath {
+        self
+    }
+
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
     }
@@ -1159,6 +1335,18 @@ impl Typed for &'static Path {
     }
 }
 
+impl TypePath for &'static Path {
+    fn type_path() -> &'static str {
+        static CELL: GenericTypePathCell = GenericTypePathCell::new();
+        CELL.get_or_insert::<Self, _>(|| "&std::path::Path".to_owned())
+    }
+
+    fn short_type_path() -> &'static str {
+        static CELL: GenericTypePathCell = GenericTypePathCell::new();
+        CELL.get_or_insert::<Self, _>(|| "&Path".to_owned())
+    }
+}
+
 impl GetTypeRegistration for &'static Path {
     fn get_type_registration() -> TypeRegistration {
         let mut registration = TypeRegistration::of::<Self>();
@@ -1178,6 +1366,11 @@ impl Reflect for Cow<'static, Path> {
         std::any::type_name::<Self>()
     }
 
+    #[inline]
+    fn get_type_path(&self) -> &dyn DynamicTypePath {
+        self
+    }
+
     fn get_represented_type_info(&self) -> Option<&'static TypeInfo> {
         Some(<Self as Typed>::type_info())
     }
@@ -1264,6 +1457,11 @@ impl Typed for Cow<'static, Path> {
     }
 }
 
+trait PathOnly: ToOwned {}
+impl PathOnly for Path {}
+impl_type_path!(::alloc::borrow::Cow<'a: 'static, T: PathOnly + ?Sized>);
+impl_type_path!(::std::path::Path);
+
 impl FromReflect for Cow<'static, Path> {
     fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
         Some(reflect.as_any().downcast_ref::<Self>()?.clone())

crates/bevy_reflect/src/lib.rs

@@ -448,6 +448,7 @@ mod struct_trait;
 mod tuple;
 mod tuple_struct;
 mod type_info;
+mod type_path;
 mod type_registry;
 mod type_uuid;
 mod type_uuid_impl;
@@ -496,12 +497,15 @@ pub use struct_trait::*;
 pub use tuple::*;
 pub use tuple_struct::*;
 pub use type_info::*;
+pub use type_path::*;
 pub use type_registry::*;
 pub use type_uuid::*;
 
 pub use bevy_reflect_derive::*;
 pub use erased_serde;
 
+extern crate alloc;
+
 #[doc(hidden)]
 pub mod __macro_exports {
     use crate::Uuid;
@@ -543,8 +547,8 @@ mod tests {
         ser::{to_string_pretty, PrettyConfig},
         Deserializer,
     };
-    use std::any::TypeId;
     use std::fmt::{Debug, Formatter};
+    use std::{any::TypeId, marker::PhantomData};
 
     use super::prelude::*;
     use super::*;
@@ -1118,6 +1122,98 @@ mod tests {
         );
     }
 
+    #[test]
+    fn reflect_type_path() {
+        #[derive(TypePath)]
+        struct Param;
+
+        #[derive(TypePath)]
+        struct Derive;
+
+        #[derive(TypePath)]
+        #[type_path = "my_alias"]
+        struct DerivePath;
+
+        #[derive(TypePath)]
+        #[type_path = "my_alias"]
+        #[type_name = "MyDerivePathName"]
+        struct DerivePathName;
+
+        #[derive(TypePath)]
+        struct DeriveG<T>(PhantomData<T>);
+
+        #[derive(TypePath)]
+        #[type_path = "my_alias"]
+        struct DerivePathG<T, const N: usize>(PhantomData<T>);
+
+        #[derive(TypePath)]
+        #[type_path = "my_alias"]
+        #[type_name = "MyDerivePathNameG"]
+        struct DerivePathNameG<T>(PhantomData<T>);
+
+        struct Macro;
+        impl_type_path!((in my_alias) Macro);
+
+        struct MacroName;
+        impl_type_path!((in my_alias as MyMacroName) MacroName);
+
+        struct MacroG<T, const N: usize>(PhantomData<T>);
+        impl_type_path!((in my_alias) MacroG<T, const N: usize>);
+
+        struct MacroNameG<T>(PhantomData<T>);
+        impl_type_path!((in my_alias as MyMacroNameG) MacroNameG<T>);
+
+        assert_eq!(Derive::type_path(), "bevy_reflect::tests::Derive");
+        assert_eq!(DerivePath::type_path(), "my_alias::DerivePath");
+        assert_eq!(DerivePathName::type_path(), "my_alias::MyDerivePathName");
+
+        assert_eq!(
+            DeriveG::<Param>::type_path(),
+            "bevy_reflect::tests::DeriveG<bevy_reflect::tests::Param>"
+        );
+        assert_eq!(
+            DerivePathG::<Param, 10>::type_path(),
+            "my_alias::DerivePathG<bevy_reflect::tests::Param, 10>"
+        );
+        assert_eq!(
+            DerivePathNameG::<Param>::type_path(),
+            "my_alias::MyDerivePathNameG<bevy_reflect::tests::Param>"
+        );
+
+        assert_eq!(Macro::type_path(), "my_alias::Macro");
+        assert_eq!(MacroName::type_path(), "my_alias::MyMacroName");
+        assert_eq!(
+            MacroG::<Param, 10>::type_path(),
+            "my_alias::MacroG<bevy_reflect::tests::Param, 10>"
+        );
+        assert_eq!(
+            MacroNameG::<Param>::type_path(),
+            "my_alias::MyMacroNameG<bevy_reflect::tests::Param>"
+        );
+
+        assert_eq!(Derive::short_type_path(), "Derive");
+        assert_eq!(DerivePath::short_type_path(), "DerivePath");
+        assert_eq!(DerivePathName::short_type_path(), "MyDerivePathName");
+
+        assert_eq!(DeriveG::<Param>::short_type_path(), "DeriveG<Param>");
+        assert_eq!(
+            DerivePathG::<Param, 10>::short_type_path(),
+            "DerivePathG<Param, 10>"
+        );
+        assert_eq!(
+            DerivePathNameG::<Param>::short_type_path(),
+            "MyDerivePathNameG<Param>"
+        );
+
+        assert_eq!(Macro::short_type_path(), "Macro");
+        assert_eq!(MacroName::short_type_path(), "MyMacroName");
+        assert_eq!(MacroG::<Param, 10>::short_type_path(), "MacroG<Param, 10>");
+        assert_eq!(
+            MacroNameG::<Param>::short_type_path(),
+            "MyMacroNameG<Param>"
+        );
+    }
+
     #[test]
     fn reflect_type_info() {
         // TypeInfo
@@ -1171,7 +1267,7 @@ mod tests {
 
         // Struct (generic)
         #[derive(Reflect)]
-        struct MyGenericStruct<T: Reflect> {
+        struct MyGenericStruct<T: Reflect + TypePath> {
             foo: T,
             bar: usize,
         }
@@ -1420,7 +1516,7 @@ mod tests {
             struct SomePrimitive;
             impl_reflect_value!(
                 /// Some primitive for which we have attributed custom documentation.
-                SomePrimitive
+                (in bevy_reflect::tests) SomePrimitive
             );
 
             let info = <SomePrimitive as Typed>::type_info();

crates/bevy_reflect/src/list.rs

@@ -2,8 +2,13 @@ use std::any::{Any, TypeId};
 use std::fmt::{Debug, Formatter};
 use std::hash::{Hash, Hasher};
 
+use bevy_reflect_derive::impl_type_path;
+
 use crate::utility::reflect_hasher;
-use crate::{FromReflect, Reflect, ReflectMut, ReflectOwned, ReflectRef, TypeInfo};
+use crate::{
+    self as bevy_reflect, DynamicTypePath, FromReflect, Reflect, ReflectMut, ReflectOwned,
+    ReflectRef, TypeInfo,
+};
 
 /// A trait used to power [list-like] operations via [reflection].
 ///
@@ -271,6 +276,11 @@ impl Reflect for DynamicList {
         self.represented_type
     }
 
+    #[inline]
+    fn get_type_path(&self) -> &dyn DynamicTypePath {
+        self
+    }
+
     #[inline]
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
@@ -352,6 +362,8 @@ impl Reflect for DynamicList {
     }
 }
 
+impl_type_path!((in bevy_reflect) DynamicList);
+
 impl Debug for DynamicList {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         self.debug(f)

crates/bevy_reflect/src/map.rs

@@ -2,9 +2,12 @@ use std::any::{Any, TypeId};
 use std::fmt::{Debug, Formatter};
 use std::hash::Hash;
 
+use bevy_reflect_derive::impl_type_path;
 use bevy_utils::{Entry, HashMap};
 
-use crate::{Reflect, ReflectMut, ReflectOwned, ReflectRef, TypeInfo};
+use crate::{
+    self as bevy_reflect, DynamicTypePath, Reflect, ReflectMut, ReflectOwned, ReflectRef, TypeInfo,
+};
 
 /// A trait used to power [map-like] operations via [reflection].
 ///
@@ -307,6 +310,11 @@ impl Reflect for DynamicMap {
         self.represented_type
     }
 
+    #[inline]
+    fn get_type_path(&self) -> &dyn DynamicTypePath {
+        self
+    }
+
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
     }
@@ -375,6 +383,8 @@ impl Reflect for DynamicMap {
     }
 }
 
+impl_type_path!((in bevy_reflect) DynamicMap);
+
 impl Debug for DynamicMap {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         self.debug(f)

crates/bevy_reflect/src/reflect.rs

@@ -1,7 +1,7 @@
 use crate::{
     array_debug, enum_debug, list_debug, map_debug, serde::Serializable, struct_debug, tuple_debug,
-    tuple_struct_debug, Array, Enum, List, Map, Struct, Tuple, TupleStruct, TypeInfo, Typed,
+    tuple_struct_debug, Array, DynamicTypePath, Enum, List, Map, Struct, Tuple, TupleStruct,
-    ValueInfo,
+    TypeInfo, Typed, ValueInfo,
 };
 use std::{
     any::{self, Any, TypeId},
@@ -93,6 +93,14 @@ pub trait Reflect: Any + Send + Sync {
     /// [`TypeRegistry::get_type_info`]: crate::TypeRegistry::get_type_info
     fn get_represented_type_info(&self) -> Option<&'static TypeInfo>;
 
+    /// Returns the [`TypePath`] implementation for the underlying type.
+    ///
+    /// Methods on [`DynamicTypePath`] suffer the same performance concerns as [`get_represented_type_info`].
+    ///
+    /// [`TypePath`]: crate::TypePath
+    /// [`get_represented_type_info`]: Reflect::get_represented_type_info
+    fn get_type_path(&self) -> &dyn DynamicTypePath;
+
     /// Returns the value as a [`Box<dyn Any>`][std::any::Any].
     fn into_any(self: Box<Self>) -> Box<dyn Any>;
 

crates/bevy_reflect/src/struct_trait.rs

@@ -1,4 +1,8 @@
-use crate::{NamedField, Reflect, ReflectMut, ReflectOwned, ReflectRef, TypeInfo};
+use crate::{
+    self as bevy_reflect, DynamicTypePath, NamedField, Reflect, ReflectMut, ReflectOwned,
+    ReflectRef, TypeInfo,
+};
+use bevy_reflect_derive::impl_type_path;
 use bevy_utils::{Entry, HashMap};
 use std::fmt::{Debug, Formatter};
 use std::{
@@ -401,6 +405,11 @@ impl Reflect for DynamicStruct {
         self.represented_type
     }
 
+    #[inline]
+    fn get_type_path(&self) -> &dyn DynamicTypePath {
+        self
+    }
+
     #[inline]
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
@@ -485,6 +494,8 @@ impl Reflect for DynamicStruct {
     }
 }
 
+impl_type_path!((in bevy_reflect) DynamicStruct);
+
 impl Debug for DynamicStruct {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         self.debug(f)

crates/bevy_reflect/src/tuple.rs

@@ -1,5 +1,8 @@
+use bevy_reflect_derive::impl_type_path;
+
 use crate::{
-    FromReflect, GetTypeRegistration, Reflect, ReflectMut, ReflectOwned, ReflectRef, TypeInfo,
+    self as bevy_reflect, utility::GenericTypePathCell, DynamicTypePath, FromReflect,
+    GetTypeRegistration, Reflect, ReflectMut, ReflectOwned, ReflectRef, TypeInfo, TypePath,
     TypeRegistration, Typed, UnnamedField,
 };
 use std::any::{Any, TypeId};
@@ -318,6 +321,11 @@ impl Reflect for DynamicTuple {
         self.represented_type
     }
 
+    #[inline]
+    fn get_type_path(&self) -> &dyn DynamicTypePath {
+        self
+    }
+
     #[inline]
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
@@ -393,6 +401,8 @@ impl Reflect for DynamicTuple {
     }
 }
 
+impl_type_path!((in bevy_reflect) DynamicTuple);
+
 /// Applies the elements of `b` to the corresponding elements of `a`.
 ///
 /// # Panics
@@ -467,7 +477,7 @@ pub fn tuple_debug(dyn_tuple: &dyn Tuple, f: &mut std::fmt::Formatter<'_>) -> st
 
 macro_rules! impl_reflect_tuple {
     {$($index:tt : $name:tt),*} => {
-        impl<$($name: Reflect),*> Tuple for ($($name,)*) {
+        impl<$($name: Reflect + TypePath),*> Tuple for ($($name,)*) {
             #[inline]
             fn field(&self, index: usize) -> Option<&dyn Reflect> {
                 match index {
@@ -519,7 +529,7 @@ macro_rules! impl_reflect_tuple {
             }
         }
 
-        impl<$($name: Reflect),*> Reflect for ($($name,)*) {
+        impl<$($name: Reflect + TypePath),*> Reflect for ($($name,)*) {
             fn type_name(&self) -> &str {
                 std::any::type_name::<Self>()
             }
@@ -528,6 +538,11 @@ macro_rules! impl_reflect_tuple {
                 Some(<Self as Typed>::type_info())
             }
 
+            #[inline]
+            fn get_type_path(&self) -> &dyn DynamicTypePath {
+                self
+            }
+
             fn into_any(self: Box<Self>) -> Box<dyn Any> {
                 self
             }
@@ -582,7 +597,7 @@ macro_rules! impl_reflect_tuple {
             }
         }
 
-        impl <$($name: Reflect),*> Typed for ($($name,)*) {
+        impl <$($name: Reflect + TypePath),*> Typed for ($($name,)*) {
             fn type_info() -> &'static TypeInfo {
                 static CELL: $crate::utility::GenericTypeInfoCell = $crate::utility::GenericTypeInfoCell::new();
                 CELL.get_or_insert::<Self, _>(|| {
@@ -595,13 +610,30 @@ macro_rules! impl_reflect_tuple {
             }
         }
 
-        impl<$($name: Reflect + Typed),*> GetTypeRegistration for ($($name,)*) {
+        impl <$($name: Reflect + TypePath),*> TypePath for ($($name,)*) {
+            fn type_path() -> &'static str {
+                static CELL: GenericTypePathCell = GenericTypePathCell::new();
+                CELL.get_or_insert::<Self, _>(|| {
+                    "(".to_owned() $(+ <$name as TypePath>::type_path())* + ")"
+                })
+            }
+
+            fn short_type_path() -> &'static str {
+                static CELL: GenericTypePathCell = GenericTypePathCell::new();
+                CELL.get_or_insert::<Self, _>(|| {
+                    "(".to_owned() $(+ <$name as TypePath>::short_type_path())* + ")"
+                })
+            }
+        }
+
+
+        impl<$($name: Reflect + TypePath),*> GetTypeRegistration for ($($name,)*) {
             fn get_type_registration() -> TypeRegistration {
                 TypeRegistration::of::<($($name,)*)>()
             }
         }
 
-        impl<$($name: FromReflect),*> FromReflect for ($($name,)*)
+        impl<$($name: FromReflect + TypePath),*> FromReflect for ($($name,)*)
         {
             fn from_reflect(reflect: &dyn Reflect) -> Option<Self> {
                 if let ReflectRef::Tuple(_ref_tuple) = reflect.reflect_ref() {

crates/bevy_reflect/src/tuple_struct.rs

@@ -1,4 +1,9 @@
-use crate::{Reflect, ReflectMut, ReflectOwned, ReflectRef, TypeInfo, UnnamedField};
+use bevy_reflect_derive::impl_type_path;
+
+use crate::{
+    self as bevy_reflect, DynamicTypePath, Reflect, ReflectMut, ReflectOwned, ReflectRef, TypeInfo,
+    UnnamedField,
+};
 use std::any::{Any, TypeId};
 use std::fmt::{Debug, Formatter};
 use std::slice::Iter;
@@ -303,6 +308,11 @@ impl Reflect for DynamicTupleStruct {
         self.represented_type
     }
 
+    #[inline]
+    fn get_type_path(&self) -> &dyn DynamicTypePath {
+        self
+    }
+
     #[inline]
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
@@ -386,6 +396,8 @@ impl Reflect for DynamicTupleStruct {
     }
 }
 
+impl_type_path!((in bevy_reflect) DynamicTupleStruct);
+
 impl Debug for DynamicTupleStruct {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         self.debug(f)

crates/bevy_reflect/src/type_info.rs

@@ -24,7 +24,7 @@ use std::fmt::Debug;
 ///
 /// ```
 /// # use std::any::Any;
-/// # use bevy_reflect::{NamedField, Reflect, ReflectMut, ReflectOwned, ReflectRef, StructInfo, TypeInfo, ValueInfo};
+/// # use bevy_reflect::{DynamicTypePath, NamedField, Reflect, ReflectMut, ReflectOwned, ReflectRef, StructInfo, TypeInfo, ValueInfo};
 /// # use bevy_reflect::utility::NonGenericTypeInfoCell;
 /// use bevy_reflect::Typed;
 ///
@@ -51,6 +51,7 @@ use std::fmt::Debug;
 /// # impl Reflect for MyStruct {
 /// #   fn type_name(&self) -> &str { todo!() }
 /// #   fn get_represented_type_info(&self) -> Option<&'static TypeInfo> { todo!() }
+/// #   fn get_type_path(&self) -> &dyn DynamicTypePath { todo!() }
 /// #   fn into_any(self: Box<Self>) -> Box<dyn Any> { todo!() }
 /// #   fn as_any(&self) -> &dyn Any { todo!() }
 /// #   fn as_any_mut(&mut self) -> &mut dyn Any { todo!() }

crates/bevy_reflect/src/type_path.rs

@@ -0,0 +1,167 @@
+/// A static accessor to type paths and names.
+///
+/// The engine uses this trait over [`std::any::type_name`] for stability and flexibility.
+///
+/// This trait is automatically implemented by the `#[derive(Reflect)]` macro
+/// and allows type path information to be processed without an instance of that type.
+///
+/// Implementors may have difficulty in generating references with static
+/// lifetimes. Luckily, this crate comes with some [utility] structs, to make generating these
+/// statics much simpler.
+///
+/// # Stability
+///
+/// Certain parts of the engine, e.g. [(de)serialization], rely on type paths as identifiers
+/// for matching dynamic values to concrete types.
+///
+/// Using [`std::any::type_name`], a scene containing `my_crate::foo::MyComponent` would break,
+/// failing to deserialize if the component was moved from the `foo` module to the `bar` module,
+/// becoming `my_crate::bar::MyComponent`.
+/// This trait, through attributes when deriving itself or [`Reflect`], can ensure breaking changes are avoidable.
+///
+/// The only external factor we rely on for stability when deriving is the [`module_path!`] macro,
+/// only if the derive does not provide a `#[type_path = "..."]` attribute.
+///
+/// # Anonymity
+///
+/// Some methods on this trait return `Option<&'static str>` over `&'static str`
+/// because not all types define all parts of a type path, for example the array type `[T; N]`.
+///
+/// Such types are 'anonymous' in that they have only a defined [`type_path`] and [`short_type_path`]
+/// and the methods [`crate_name`], [`module_path`] and [`type_ident`] all return `None`.
+///
+/// Primitives are treated like anonymous types, except they also have a defined [`type_ident`].
+///
+/// # Example
+///
+/// ```rust
+/// use bevy_reflect::TypePath;
+///
+/// // This type path will not change with compiler versions or recompiles,
+/// // although it will not be the same if the definition is moved.
+/// #[derive(TypePath)]
+/// struct NonStableTypePath;
+///
+/// // This type path will never change, even if the definition is moved.
+/// #[derive(TypePath)]
+/// #[type_path = "my_crate::foo"]
+/// struct StableTypePath;
+///
+/// // Type paths can have any number of path segments.
+/// #[derive(TypePath)]
+/// #[type_path = "my_crate::foo::bar::baz"]
+/// struct DeeplyNestedStableTypePath;
+///
+/// // Including just a crate name!
+/// #[derive(TypePath)]
+/// #[type_path = "my_crate"]
+/// struct ShallowStableTypePath;
+///
+/// // We can also rename the identifier/name of types.
+/// #[derive(TypePath)]
+/// #[type_path = "my_crate::foo"]
+/// #[type_name = "RenamedStableTypePath"]
+/// struct NamedStableTypePath;
+///
+/// // Generics are also supported.
+/// #[derive(TypePath)]
+/// #[type_path = "my_crate::foo"]
+/// struct StableGenericTypePath<T, const N: usize>([T; N]);
+/// ```
+///
+/// [utility]: crate::utility
+/// [(de)serialization]: crate::serde::UntypedReflectDeserializer
+/// [`Reflect`]: crate::Reflect
+/// [`type_path`]: TypePath::type_path
+/// [`short_type_path`]: TypePath::short_type_path
+/// [`crate_name`]: TypePath::crate_name
+/// [`module_path`]: TypePath::module_path
+/// [`type_ident`]: TypePath::type_ident
+pub trait TypePath: 'static {
+    /// Returns the fully qualified path of the underlying type.
+    ///
+    /// Generic parameter types are also fully expanded.
+    ///
+    /// For `Option<PhantomData>`, this is `"core::option::Option<core::marker::PhantomData>"`.
+    fn type_path() -> &'static str;
+
+    /// Returns a short, pretty-print enabled path to the type.
+    ///
+    /// Generic parameter types are also shortened.
+    ///
+    /// For `Option<PhantomData>`, this is `"Option<PhantomData>"`.
+    fn short_type_path() -> &'static str;
+
+    /// Returns the name of the type, or [`None`] if it is [anonymous].
+    ///
+    /// Primitive types will return [`Some`].
+    ///
+    /// For `Option<PhantomData>`, this is `"Option"`.
+    ///
+    /// [anonymous]: TypePath#anonymity
+    fn type_ident() -> Option<&'static str> {
+        None
+    }
+
+    /// Returns the name of the crate the type is in, or [`None`] if it is [anonymous].
+    ///
+    /// For `Option<PhantomData>`, this is `"core"`.
+    ///
+    /// [anonymous]: TypePath#anonymity
+    fn crate_name() -> Option<&'static str> {
+        None
+    }
+
+    /// Returns the path to the moudle the type is in, or [`None`] if it is [anonymous].
+    ///
+    /// For `Option<PhantomData>`, this is `"core::option"`.
+    ///
+    /// [anonymous]: TypePath#anonymity
+    fn module_path() -> Option<&'static str> {
+        None
+    }
+}
+
+/// Dynamic dispatch for [`TypePath`].
+///
+/// Retrieved using [`Reflect::get_type_path`].
+///
+/// [`Reflect::get_type_path`]: crate::Reflect::get_type_path
+pub trait DynamicTypePath {
+    /// See [`TypePath::type_path`].
+    fn reflect_type_path(&self) -> &str;
+
+    /// See [`TypePath::short_type_path`].
+    fn reflect_short_type_path(&self) -> &str;
+
+    /// See [`TypePath::type_ident`].
+    fn reflect_type_ident(&self) -> Option<&str>;
+
+    /// See [`TypePath::crate_name`].
+    fn reflect_crate_name(&self) -> Option<&str>;
+
+    /// See [`TypePath::module_path`].
+    fn reflect_module_path(&self) -> Option<&str>;
+}
+
+impl<T: TypePath> DynamicTypePath for T {
+    fn reflect_type_path(&self) -> &str {
+        Self::type_path()
+    }
+
+    fn reflect_short_type_path(&self) -> &str {
+        Self::short_type_path()
+    }
+
+    fn reflect_type_ident(&self) -> Option<&str> {
+        Self::type_ident()
+    }
+
+    fn reflect_crate_name(&self) -> Option<&str> {
+        Self::crate_name()
+    }
+
+    fn reflect_module_path(&self) -> Option<&str> {
+        Self::module_path()
+    }
+}

crates/bevy_reflect/src/utility.rs

@@ -9,132 +9,220 @@ use std::{
     hash::BuildHasher,
 };
 
+/// A type that can be stored in a ([`Non`])[`GenericTypeCell`].
+///
+/// [`Non`]: NonGenericTypeCell
+pub trait TypedProperty: sealed::Sealed {
+    type Stored: 'static;
+}
+
+/// Used to store a [`String`] in a [`GenericTypePathCell`] as part of a [`TypePath`] implementation.
+///
+/// [`TypePath`]: crate::TypePath
+pub struct TypePathComponent;
+
+mod sealed {
+    use super::{TypeInfo, TypePathComponent, TypedProperty};
+
+    pub trait Sealed {}
+
+    impl Sealed for TypeInfo {}
+    impl Sealed for TypePathComponent {}
+
+    impl TypedProperty for TypeInfo {
+        type Stored = Self;
+    }
+
+    impl TypedProperty for TypePathComponent {
+        type Stored = String;
+    }
+}
+
 /// A container for [`TypeInfo`] over non-generic types, allowing instances to be stored statically.
 ///
 /// This is specifically meant for use with _non_-generic types. If your type _is_ generic,
-/// then use [`GenericTypeInfoCell`] instead. Otherwise, it will not take into account all
+/// then use [`GenericTypeCell`] instead. Otherwise, it will not take into account all
 /// monomorphizations of your type.
 ///
+/// Non-generic [`TypePath`]s should be trivially generated with string literals and [`concat!`].
+///
 /// ## Example
 ///
 /// ```
 /// # use std::any::Any;
-/// # use bevy_reflect::{NamedField, Reflect, ReflectMut, ReflectOwned, ReflectRef, StructInfo, Typed, TypeInfo};
+/// # use bevy_reflect::{DynamicTypePath, NamedField, Reflect, ReflectMut, ReflectOwned, ReflectRef, StructInfo, Typed, TypeInfo};
 /// use bevy_reflect::utility::NonGenericTypeInfoCell;
 ///
 /// struct Foo {
-///   bar: i32
+///     bar: i32
 /// }
 ///
 /// impl Typed for Foo {
-///   fn type_info() -> &'static TypeInfo {
+///     fn type_info() -> &'static TypeInfo {
-///     static CELL: NonGenericTypeInfoCell = NonGenericTypeInfoCell::new();
+///         static CELL: NonGenericTypeInfoCell = NonGenericTypeInfoCell::new();
-///     CELL.get_or_set(|| {
+///         CELL.get_or_set(|| {
-///       let fields = [NamedField::new::<i32>("bar")];
+///             let fields = [NamedField::new::<i32>("bar")];
-///       let info = StructInfo::new::<Self>("Foo", &fields);
+///             let info = StructInfo::new::<Self>("Foo", &fields);
-///       TypeInfo::Struct(info)
+///             TypeInfo::Struct(info)
-///     })
+///         })
-///   }
+///     }
 /// }
 /// #
 /// # impl Reflect for Foo {
-/// #   fn type_name(&self) -> &str { todo!() }
+/// #     fn type_name(&self) -> &str { todo!() }
-/// #   fn get_represented_type_info(&self) -> Option<&'static TypeInfo> { todo!() }
+/// #     fn get_type_path(&self) -> &dyn DynamicTypePath { todo!() }
-/// #   fn into_any(self: Box<Self>) -> Box<dyn Any> { todo!() }
+/// #     fn get_represented_type_info(&self) -> Option<&'static TypeInfo> { todo!() }
-/// #   fn as_any(&self) -> &dyn Any { todo!() }
+/// #     fn into_any(self: Box<Self>) -> Box<dyn Any> { todo!() }
-/// #   fn as_any_mut(&mut self) -> &mut dyn Any { todo!() }
+/// #     fn as_any(&self) -> &dyn Any { todo!() }
-/// #   fn into_reflect(self: Box<Self>) -> Box<dyn Reflect> { todo!() }
+/// #     fn as_any_mut(&mut self) -> &mut dyn Any { todo!() }
-/// #   fn as_reflect(&self) -> &dyn Reflect { todo!() }
+/// #     fn into_reflect(self: Box<Self>) -> Box<dyn Reflect> { todo!() }
-/// #   fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() }
+/// #     fn as_reflect(&self) -> &dyn Reflect { todo!() }
-/// #   fn apply(&mut self, value: &dyn Reflect) { todo!() }
+/// #     fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() }
-/// #   fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> { todo!() }
+/// #     fn apply(&mut self, value: &dyn Reflect) { todo!() }
-/// #   fn reflect_ref(&self) -> ReflectRef { todo!() }
+/// #     fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> { todo!() }
-/// #   fn reflect_mut(&mut self) -> ReflectMut { todo!() }
+/// #     fn reflect_ref(&self) -> ReflectRef { todo!() }
-/// #   fn reflect_owned(self: Box<Self>) -> ReflectOwned { todo!() }
+/// #     fn reflect_mut(&mut self) -> ReflectMut { todo!() }
-/// #   fn clone_value(&self) -> Box<dyn Reflect> { todo!() }
+/// #     fn reflect_owned(self: Box<Self>) -> ReflectOwned { todo!() }
+/// #     fn clone_value(&self) -> Box<dyn Reflect> { todo!() }
 /// # }
 /// ```
-pub struct NonGenericTypeInfoCell(OnceBox<TypeInfo>);
+///
+/// [`TypePath`]: crate::TypePath
+pub struct NonGenericTypeCell<T: TypedProperty>(OnceBox<T::Stored>);
 
-impl NonGenericTypeInfoCell {
+/// See [`NonGenericTypeCell`].
-    /// Initialize a [`NonGenericTypeInfoCell`] for non-generic types.
+pub type NonGenericTypeInfoCell = NonGenericTypeCell<TypeInfo>;
+
+impl<T: TypedProperty> NonGenericTypeCell<T> {
+    /// Initialize a [`NonGenericTypeCell`] for non-generic types.
     pub const fn new() -> Self {
         Self(OnceBox::new())
     }
 
-    /// Returns a reference to the [`TypeInfo`] stored in the cell.
+    /// Returns a reference to the [`TypedProperty`] stored in the cell.
     ///
-    /// If there is no [`TypeInfo`] found, a new one will be generated from the given function.
+    /// If there is no entry found, a new one will be generated from the given function.
-    ///
+    pub fn get_or_set<F>(&self, f: F) -> &T::Stored
-    /// [`TypeInfos`]: TypeInfo
-    pub fn get_or_set<F>(&self, f: F) -> &TypeInfo
     where
-        F: FnOnce() -> TypeInfo,
+        F: FnOnce() -> T::Stored,
     {
         self.0.get_or_init(|| Box::new(f()))
     }
 }
 
-/// A container for [`TypeInfo`] over generic types, allowing instances to be stored statically.
+/// A container for [`TypedProperty`] over generic types, allowing instances to be stored statically.
 ///
 /// This is specifically meant for use with generic types. If your type isn't generic,
-/// then use [`NonGenericTypeInfoCell`] instead as it should be much more performant.
+/// then use [`NonGenericTypeCell`] instead as it should be much more performant.
 ///
-/// ## Example
+/// `#[derive(TypePath)]` and [`impl_type_path`] should always be used over [`GenericTypePathCell`]
+/// where possible.
+///
+/// ## Examples
+///
+/// Implementing [`TypeInfo`] with generics.
 ///
 /// ```
 /// # use std::any::Any;
-/// # use bevy_reflect::{Reflect, ReflectMut, ReflectOwned, ReflectRef, TupleStructInfo, Typed, TypeInfo, UnnamedField};
+/// # use bevy_reflect::{DynamicTypePath, Reflect, ReflectMut, ReflectOwned, ReflectRef, TupleStructInfo, Typed, TypeInfo, UnnamedField};
 /// use bevy_reflect::utility::GenericTypeInfoCell;
 ///
-/// struct Foo<T: Reflect>(T);
+/// struct Foo<T>(T);
 ///
 /// impl<T: Reflect> Typed for Foo<T> {
-///   fn type_info() -> &'static TypeInfo {
+///     fn type_info() -> &'static TypeInfo {
-///     static CELL: GenericTypeInfoCell = GenericTypeInfoCell::new();
+///         static CELL: GenericTypeInfoCell = GenericTypeInfoCell::new();
-///     CELL.get_or_insert::<Self, _>(|| {
+///         CELL.get_or_insert::<Self, _>(|| {
-///       let fields = [UnnamedField::new::<T>(0)];
+///             let fields = [UnnamedField::new::<T>(0)];
-///       let info = TupleStructInfo::new::<Self>("Foo", &fields);
+///             let info = TupleStructInfo::new::<Self>("Foo", &fields);
-///       TypeInfo::TupleStruct(info)
+///             TypeInfo::TupleStruct(info)
-///     })
+///         })
-///   }
+///     }
 /// }
 /// #
 /// # impl<T: Reflect> Reflect for Foo<T> {
-/// #   fn type_name(&self) -> &str { todo!() }
+/// #     fn type_name(&self) -> &str { todo!() }
-/// #   fn get_represented_type_info(&self) -> Option<&'static TypeInfo> { todo!() }
+/// #     fn get_type_path(&self) -> &dyn DynamicTypePath { todo!() }
-/// #   fn into_any(self: Box<Self>) -> Box<dyn Any> { todo!() }
+/// #     fn get_represented_type_info(&self) -> Option<&'static TypeInfo> { todo!() }
-/// #   fn as_any(&self) -> &dyn Any { todo!() }
+/// #     fn into_any(self: Box<Self>) -> Box<dyn Any> { todo!() }
-/// #   fn as_any_mut(&mut self) -> &mut dyn Any { todo!() }
+/// #     fn as_any(&self) -> &dyn Any { todo!() }
-/// #   fn into_reflect(self: Box<Self>) -> Box<dyn Reflect> { todo!() }
+/// #     fn as_any_mut(&mut self) -> &mut dyn Any { todo!() }
-/// #   fn as_reflect(&self) -> &dyn Reflect { todo!() }
+/// #     fn into_reflect(self: Box<Self>) -> Box<dyn Reflect> { todo!() }
-/// #   fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() }
+/// #     fn as_reflect(&self) -> &dyn Reflect { todo!() }
-/// #   fn apply(&mut self, value: &dyn Reflect) { todo!() }
+/// #     fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() }
-/// #   fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> { todo!() }
+/// #     fn apply(&mut self, value: &dyn Reflect) { todo!() }
-/// #   fn reflect_ref(&self) -> ReflectRef { todo!() }
+/// #     fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> { todo!() }
-/// #   fn reflect_mut(&mut self) -> ReflectMut { todo!() }
+/// #     fn reflect_ref(&self) -> ReflectRef { todo!() }
-/// #   fn reflect_owned(self: Box<Self>) -> ReflectOwned { todo!() }
+/// #     fn reflect_mut(&mut self) -> ReflectMut { todo!() }
-/// #   fn clone_value(&self) -> Box<dyn Reflect> { todo!() }
+/// #     fn reflect_owned(self: Box<Self>) -> ReflectOwned { todo!() }
+/// #     fn clone_value(&self) -> Box<dyn Reflect> { todo!() }
 /// # }
 /// ```
-pub struct GenericTypeInfoCell(OnceBox<RwLock<HashMap<TypeId, &'static TypeInfo>>>);
+///
+///  Implementing [`TypePath`] with generics.
+///
+/// ```
+/// # use std::any::Any;
+/// # use bevy_reflect::{DynamicTypePath, Reflect, ReflectMut, ReflectOwned, ReflectRef, TypeInfo, TypePath};
+/// use bevy_reflect::utility::GenericTypePathCell;
+///
+/// struct Foo<T>(T);
+///
+/// impl<T: Reflect + TypePath> TypePath for Foo<T> {
+///     fn type_path() -> &'static str {
+///         static CELL: GenericTypePathCell = GenericTypePathCell::new();
+///         CELL.get_or_insert::<Self, _>(|| format!("my_crate::foo::Foo<{}>", T::type_path()))
+///     }
+///     
+///     fn short_type_path() -> &'static str {
+///         static CELL: GenericTypePathCell = GenericTypePathCell::new();
+///         CELL.get_or_insert::<Self, _>(|| format!("Foo<{}>", T::short_type_path()))
+///     }
+/// }
+/// #
+/// # impl<T: Reflect> Reflect for Foo<T> {
+/// #     fn type_name(&self) -> &str { todo!() }
+/// #     fn get_type_path(&self) -> &dyn DynamicTypePath { todo!() }
+/// #     fn get_represented_type_info(&self) -> Option<&'static TypeInfo> { todo!() }
+/// #     fn into_any(self: Box<Self>) -> Box<dyn Any> { todo!() }
+/// #     fn as_any(&self) -> &dyn Any { todo!() }
+/// #     fn as_any_mut(&mut self) -> &mut dyn Any { todo!() }
+/// #     fn into_reflect(self: Box<Self>) -> Box<dyn Reflect> { todo!() }
+/// #     fn as_reflect(&self) -> &dyn Reflect { todo!() }
+/// #     fn as_reflect_mut(&mut self) -> &mut dyn Reflect { todo!() }
+/// #     fn apply(&mut self, value: &dyn Reflect) { todo!() }
+/// #     fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>> { todo!() }
+/// #     fn reflect_ref(&self) -> ReflectRef { todo!() }
+/// #     fn reflect_mut(&mut self) -> ReflectMut { todo!() }
+/// #     fn reflect_owned(self: Box<Self>) -> ReflectOwned { todo!() }
+/// #     fn clone_value(&self) -> Box<dyn Reflect> { todo!() }
+/// # }
+/// ```
+/// [`impl_type_path`]: crate::impl_type_path
+/// [`TypePath`]: crate::TypePath
+pub struct GenericTypeCell<T: TypedProperty>(OnceBox<RwLock<HashMap<TypeId, &'static T::Stored>>>);
 
-impl GenericTypeInfoCell {
+/// See [`GenericTypeCell`].
-    /// Initialize a [`GenericTypeInfoCell`] for generic types.
+pub type GenericTypeInfoCell = GenericTypeCell<TypeInfo>;
+/// See [`GenericTypeCell`].
+pub type GenericTypePathCell = GenericTypeCell<TypePathComponent>;
+
+impl<T: TypedProperty> GenericTypeCell<T> {
+    /// Initialize a [`GenericTypeCell`] for generic types.
     pub const fn new() -> Self {
         Self(OnceBox::new())
     }
 
-    /// Returns a reference to the [`TypeInfo`] stored in the cell.
+    /// Returns a reference to the [`TypedProperty`] stored in the cell.
     ///
-    /// This method will then return the correct [`TypeInfo`] reference for the given type `T`.
+    /// This method will then return the correct [`TypedProperty`] reference for the given type `T`.
-    /// If there is no [`TypeInfo`] found, a new one will be generated from the given function.
+    /// If there is no entry found, a new one will be generated from the given function.
-    pub fn get_or_insert<T, F>(&self, f: F) -> &TypeInfo
+    pub fn get_or_insert<G, F>(&self, f: F) -> &T::Stored
     where
-        T: Any + ?Sized,
+        G: Any + ?Sized,
-        F: FnOnce() -> TypeInfo,
+        F: FnOnce() -> T::Stored,
     {
-        let type_id = TypeId::of::<T>();
+        let type_id = TypeId::of::<G>();
         // let mapping = self.0.get_or_init(|| Box::new(RwLock::default()));
         let mapping = self.0.get_or_init(Box::default);
         if let Some(info) = mapping.read().get(&type_id) {

crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.rs

@@ -1,4 +1,4 @@
-use bevy_reflect::Reflect;
+use bevy_reflect::{Reflect, TypePath};
 
 #[derive(Reflect)]
 struct Foo<T> {
@@ -6,10 +6,11 @@ struct Foo<T> {
 }
 
 // Type that doesn't implement Reflect
+#[derive(TypePath)]
 struct NoReflect(f32);
 
 fn main() {
     let mut foo: Box<dyn Reflect> = Box::new(Foo::<NoReflect> { a: NoReflect(42.0) });
     // foo doesn't implement Reflect because NoReflect doesn't implement Reflect
     foo.get_field::<NoReflect>("a").unwrap();
-}
+}

crates/bevy_reflect_compile_fail_tests/tests/reflect_derive/generics.fail.stderr

@@ -1,13 +1,13 @@
 error[E0599]: no method named `get_field` found for struct `Box<(dyn Reflect + 'static)>` in the current scope
-  --> tests/reflect_derive/generics.fail.rs:14:9
+  --> tests/reflect_derive/generics.fail.rs:15:9
    |
-14 |     foo.get_field::<NoReflect>("a").unwrap();
+15 |     foo.get_field::<NoReflect>("a").unwrap();
    |         ^^^^^^^^^ method not found in `Box<dyn Reflect>`
 
 error[E0277]: the trait bound `NoReflect: Reflect` is not satisfied
-  --> tests/reflect_derive/generics.fail.rs:12:37
+  --> tests/reflect_derive/generics.fail.rs:13:37
    |
-12 |     let mut foo: Box<dyn Reflect> = Box::new(Foo::<NoReflect> { a: NoReflect(42.0) });
+13 |     let mut foo: Box<dyn Reflect> = Box::new(Foo::<NoReflect> { a: NoReflect(42.0) });
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `Reflect` is not implemented for `NoReflect`
    |
    = help: the following other types implement trait `Reflect`:

crates/bevy_render/src/mesh/mesh/mod.rs

@@ -12,7 +12,7 @@ use bevy_core::cast_slice;
 use bevy_derive::EnumVariantMeta;
 use bevy_ecs::system::{lifetimeless::SRes, SystemParamItem};
 use bevy_math::*;
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{TypePath, TypeUuid};
 use bevy_utils::{tracing::error, Hashed};
 use std::{collections::BTreeMap, hash::Hash, iter::FusedIterator};
 use thiserror::Error;
@@ -25,7 +25,7 @@ pub const INDEX_BUFFER_ASSET_INDEX: u64 = 0;
 pub const VERTEX_ATTRIBUTE_BUFFER_ID: u64 = 10;
 
 // TODO: allow values to be unloaded after been submitting to the GPU to conserve memory
-#[derive(Debug, TypeUuid, Clone)]
+#[derive(Debug, TypeUuid, TypePath, Clone)]
 #[uuid = "8ecbac0f-f545-4473-ad43-e1f4243af51e"]
 pub struct Mesh {
     primitive_topology: PrimitiveTopology,

crates/bevy_render/src/mesh/mesh/skinning.rs

@@ -6,7 +6,7 @@ use bevy_ecs::{
     reflect::ReflectMapEntities,
 };
 use bevy_math::Mat4;
-use bevy_reflect::{Reflect, TypeUuid};
+use bevy_reflect::{Reflect, TypePath, TypeUuid};
 use std::ops::Deref;
 
 #[derive(Component, Debug, Default, Clone, Reflect)]
@@ -24,7 +24,7 @@ impl MapEntities for SkinnedMesh {
     }
 }
 
-#[derive(Debug, TypeUuid)]
+#[derive(Debug, TypeUuid, TypePath)]
 #[uuid = "b9f155a9-54ec-4026-988f-e0a03e99a76f"]
 pub struct SkinnedMeshInverseBindposes(Box<[Mat4]>);
 

crates/bevy_render/src/render_resource/shader.rs

@@ -1,7 +1,7 @@
 use super::ShaderDefVal;
 use crate::define_atomic_id;
 use bevy_asset::{AssetLoader, AssetPath, Handle, LoadContext, LoadedAsset};
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{TypePath, TypeUuid};
 use bevy_utils::{tracing::error, BoxedFuture, HashMap};
 #[cfg(feature = "shader_format_glsl")]
 use naga::back::wgsl::WriterFlags;
@@ -31,7 +31,7 @@ pub enum ShaderReflectError {
 }
 /// A shader, as defined by its [`ShaderSource`] and [`ShaderStage`](naga::ShaderStage)
 /// This is an "unprocessed" shader. It can contain preprocessor directives.
-#[derive(Debug, Clone, TypeUuid)]
+#[derive(Debug, Clone, TypeUuid, TypePath)]
 #[uuid = "d95bc916-6c55-4de3-9622-37e7b6969fda"]
 pub struct Shader {
     source: Source,

crates/bevy_render/src/view/visibility/mod.rs

@@ -69,7 +69,7 @@ bitflags::bitflags! {
         const VISIBLE_IN_HIERARCHY = 1 << 1;
     }
 }
-bevy_reflect::impl_reflect_value!(ComputedVisibilityFlags);
+bevy_reflect::impl_reflect_value!((in bevy_render::view) ComputedVisibilityFlags);
 bevy_reflect::impl_from_reflect_value!(ComputedVisibilityFlags);
 
 /// Algorithmically-computed indication of whether an entity is visible and should be extracted for rendering

crates/bevy_scene/src/dynamic_scene.rs

@@ -8,7 +8,7 @@ use bevy_ecs::{
     reflect::{ReflectComponent, ReflectMapEntities},
     world::World,
 };
-use bevy_reflect::{Reflect, TypeRegistryArc, TypeUuid};
+use bevy_reflect::{Reflect, TypePath, TypeRegistryArc, TypeUuid};
 use bevy_utils::HashMap;
 
 #[cfg(feature = "serialize")]
@@ -26,7 +26,7 @@ use serde::Serialize;
 /// * adding the [`Handle<DynamicScene>`](bevy_asset::Handle) to an entity (the scene will only be
 /// visible if the entity already has [`Transform`](bevy_transform::components::Transform) and
 /// [`GlobalTransform`](bevy_transform::components::GlobalTransform) components)
-#[derive(Default, TypeUuid)]
+#[derive(Default, TypeUuid, TypePath)]
 #[uuid = "749479b1-fb8c-4ff8-a775-623aa76014f5"]
 pub struct DynamicScene {
     pub resources: Vec<Box<dyn Reflect>>,

crates/bevy_scene/src/scene.rs

@@ -4,7 +4,7 @@ use bevy_ecs::{
     reflect::{ReflectComponent, ReflectMapEntities, ReflectResource},
     world::World,
 };
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{TypePath, TypeUuid};
 
 use crate::{DynamicScene, InstanceInfo, SceneSpawnError};
 
@@ -14,7 +14,7 @@ use crate::{DynamicScene, InstanceInfo, SceneSpawnError};
 /// * adding the [`Handle<Scene>`](bevy_asset::Handle) to an entity (the scene will only be
 /// visible if the entity already has [`Transform`](bevy_transform::components::Transform) and
 /// [`GlobalTransform`](bevy_transform::components::GlobalTransform) components)
-#[derive(Debug, TypeUuid)]
+#[derive(Debug, TypeUuid, TypePath)]
 #[uuid = "c156503c-edd9-4ec7-8d33-dab392df03cd"]
 pub struct Scene {
     pub world: World,

crates/bevy_sprite/src/mesh2d/material.rs

@@ -14,7 +14,7 @@ use bevy_ecs::{
     },
 };
 use bevy_log::error;
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{TypePath, TypeUuid};
 use bevy_render::{
     extract_component::ExtractComponentPlugin,
     mesh::{Mesh, MeshVertexBufferLayout},
@@ -60,11 +60,11 @@ use crate::{
 /// ```
 /// # use bevy_sprite::{Material2d, MaterialMesh2dBundle};
 /// # use bevy_ecs::prelude::*;
-/// # use bevy_reflect::TypeUuid;
+/// # use bevy_reflect::{TypeUuid, TypePath};
 /// # 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, TypePath, 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
@@ -111,7 +111,7 @@ use crate::{
 /// @group(1) @binding(2)
 /// var color_sampler: sampler;
 /// ```
-pub trait Material2d: AsBindGroup + Send + Sync + Clone + TypeUuid + Sized + 'static {
+pub trait Material2d: AsBindGroup + Send + Sync + Clone + TypeUuid + TypePath + Sized {
     /// 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_text/src/font.rs

@@ -1,11 +1,11 @@
 use ab_glyph::{FontArc, FontVec, InvalidFont, OutlinedGlyph};
-use bevy_reflect::TypeUuid;
+use bevy_reflect::{TypePath, TypeUuid};
 use bevy_render::{
     render_resource::{Extent3d, TextureDimension, TextureFormat},
     texture::Image,
 };
 
-#[derive(Debug, TypeUuid, Clone)]
+#[derive(Debug, TypeUuid, TypePath, Clone)]
 #[uuid = "97059ac6-c9ba-4da9-95b6-bed82c3ce198"]
 pub struct Font {
     pub font: FontArc,

crates/bevy_text/src/font_atlas_set.rs

@@ -2,6 +2,7 @@ use crate::{error::TextError, Font, FontAtlas};
 use ab_glyph::{GlyphId, OutlinedGlyph, Point};
 use bevy_asset::{Assets, Handle};
 use bevy_math::Vec2;
+use bevy_reflect::TypePath;
 use bevy_reflect::TypeUuid;
 use bevy_render::texture::Image;
 use bevy_sprite::TextureAtlas;
@@ -10,7 +11,7 @@ use bevy_utils::HashMap;
 
 type FontSizeKey = FloatOrd;
 
-#[derive(TypeUuid)]
+#[derive(TypeUuid, TypePath)]
 #[uuid = "73ba778b-b6b5-4f45-982d-d21b6b86ace2"]
 pub struct FontAtlasSet {
     font_atlases: HashMap<FontSizeKey, Vec<FontAtlas>>,

examples/2d/custom_gltf_vertex_attribute.rs

@@ -2,7 +2,7 @@
 
 use bevy::gltf::GltfPlugin;
 use bevy::prelude::*;
-use bevy::reflect::TypeUuid;
+use bevy::reflect::{TypePath, TypeUuid};
 use bevy::render::mesh::{MeshVertexAttribute, MeshVertexBufferLayout};
 use bevy::render::render_resource::*;
 use bevy::sprite::{
@@ -55,7 +55,7 @@ fn setup(
 /// This custom material uses barycentric coordinates from
 /// `ATTRIBUTE_BARYCENTRIC` to shade a white border around each triangle. The
 /// thickness of the border is animated using the global time shader uniform.
-#[derive(AsBindGroup, TypeUuid, Debug, Clone)]
+#[derive(AsBindGroup, TypeUuid, TypePath, Debug, Clone)]
 #[uuid = "50ffce9e-1582-42e9-87cb-2233724426c0"]
 struct CustomMaterial {}
 

examples/3d/lines.rs

@@ -3,7 +3,7 @@
 use bevy::{
     pbr::{MaterialPipeline, MaterialPipelineKey},
     prelude::*,
-    reflect::TypeUuid,
+    reflect::{TypePath, TypeUuid},
     render::{
         mesh::{MeshVertexBufferLayout, PrimitiveTopology},
         render_resource::{
@@ -62,7 +62,7 @@ fn setup(
     });
 }
 
-#[derive(Default, AsBindGroup, TypeUuid, Debug, Clone)]
+#[derive(Default, AsBindGroup, TypeUuid, TypePath, Debug, Clone)]
 #[uuid = "050ce6ac-080a-4d8c-b6b5-b5bab7560d8f"]
 struct LineMaterial {
     #[uniform(0)]

examples/3d/tonemapping.rs

@@ -5,7 +5,7 @@ use bevy::{
     math::vec2,
     pbr::CascadeShadowConfigBuilder,
     prelude::*,
-    reflect::TypeUuid,
+    reflect::{TypePath, TypeUuid},
     render::{
         render_resource::{
             AsBindGroup, Extent3d, SamplerDescriptor, ShaderRef, TextureDimension, TextureFormat,
@@ -689,7 +689,7 @@ impl Material for ColorGradientMaterial {
     }
 }
 
-#[derive(AsBindGroup, Debug, Clone, TypeUuid)]
+#[derive(AsBindGroup, Debug, Clone, TypeUuid, TypePath)]
 #[uuid = "117f64fe-6844-1822-8926-e3ed372291c8"]
 pub struct ColorGradientMaterial {}
 

examples/asset/custom_asset.rs

@@ -3,12 +3,12 @@
 use bevy::{
     asset::{AssetLoader, LoadContext, LoadedAsset},
     prelude::*,
-    reflect::TypeUuid,
+    reflect::{TypePath, TypeUuid},
     utils::BoxedFuture,
 };
 use serde::Deserialize;
 
-#[derive(Debug, Deserialize, TypeUuid)]
+#[derive(Debug, Deserialize, TypeUuid, TypePath)]
 #[uuid = "39cadc56-aa9c-4543-8640-a018b74b5052"]
 pub struct CustomAsset {
     pub value: i32,

examples/audio/decodable.rs

@@ -3,14 +3,14 @@ use bevy::audio::AddAudioSource;
 use bevy::audio::AudioPlugin;
 use bevy::audio::Source;
 use bevy::prelude::*;
-use bevy::reflect::TypeUuid;
+use bevy::reflect::{TypePath, TypeUuid};
 use bevy::utils::Duration;
 
 // This struct usually contains the data for the audio being played.
 // This is where data read from an audio file would be stored, for example.
 // Implementing `TypeUuid` will automatically implement `Asset`.
 // This allows the type to be registered as an asset.
-#[derive(TypeUuid)]
+#[derive(TypePath, TypeUuid)]
 #[uuid = "c2090c23-78fd-44f1-8508-c89b1f3cec29"]
 struct SineAudio {
     frequency: f32,

examples/shader/animate_shader.rs

@@ -1,7 +1,11 @@
 //! A shader that uses dynamic data like the time since startup.
 //! The time data is in the globals binding which is part of the `mesh_view_bindings` shader import.
 
-use bevy::{prelude::*, reflect::TypeUuid, render::render_resource::*};
+use bevy::{
+    prelude::*,
+    reflect::{TypePath, TypeUuid},
+    render::render_resource::*,
+};
 
 fn main() {
     App::new()
@@ -31,7 +35,7 @@ fn setup(
     });
 }
 
-#[derive(AsBindGroup, TypeUuid, Debug, Clone)]
+#[derive(AsBindGroup, TypeUuid, TypePath, Debug, Clone)]
 #[uuid = "a3d71c04-d054-4946-80f8-ba6cfbc90cad"]
 struct CustomMaterial {}
 

examples/shader/array_texture.rs

@@ -1,7 +1,7 @@
 use bevy::{
     asset::LoadState,
     prelude::*,
-    reflect::TypeUuid,
+    reflect::{TypePath, TypeUuid},
     render::render_resource::{AsBindGroup, ShaderRef},
 };
 
@@ -89,7 +89,7 @@ fn create_array_texture(
     }
 }
 
-#[derive(AsBindGroup, Debug, Clone, TypeUuid)]
+#[derive(AsBindGroup, Debug, Clone, TypeUuid, TypePath)]
 #[uuid = "9c5a0ddf-1eaf-41b4-9832-ed736fd26af3"]
 struct ArrayTextureMaterial {
     #[texture(0, dimension = "2d_array")]

examples/shader/custom_vertex_attribute.rs

@@ -3,7 +3,7 @@
 use bevy::{
     pbr::{MaterialPipeline, MaterialPipelineKey},
     prelude::*,
-    reflect::TypeUuid,
+    reflect::{TypePath, TypeUuid},
     render::{
         mesh::{MeshVertexAttribute, MeshVertexBufferLayout},
         render_resource::{
@@ -57,7 +57,7 @@ fn setup(
 }
 
 // This is the struct that will be passed to your shader
-#[derive(AsBindGroup, Debug, Clone, TypeUuid)]
+#[derive(AsBindGroup, Debug, Clone, TypeUuid, TypePath)]
 #[uuid = "f690fdae-d598-45ab-8225-97e2a3f056e0"]
 pub struct CustomMaterial {
     #[uniform(0)]

examples/shader/shader_defs.rs

@@ -3,7 +3,7 @@
 use bevy::{
     pbr::{MaterialPipeline, MaterialPipelineKey},
     prelude::*,
-    reflect::TypeUuid,
+    reflect::{TypePath, TypeUuid},
     render::{
         mesh::MeshVertexBufferLayout,
         render_resource::{
@@ -75,7 +75,7 @@ impl Material for CustomMaterial {
 }
 
 // This is the struct that will be passed to your shader
-#[derive(AsBindGroup, TypeUuid, Debug, Clone)]
+#[derive(AsBindGroup, TypeUuid, TypePath, Debug, Clone)]
 #[uuid = "f690fdae-d598-45ab-8225-97e2a3f056e0"]
 #[bind_group_data(CustomMaterialKey)]
 pub struct CustomMaterial {

examples/shader/shader_material.rs

@@ -2,7 +2,7 @@
 
 use bevy::{
     prelude::*,
-    reflect::TypeUuid,
+    reflect::{TypePath, TypeUuid},
     render::render_resource::{AsBindGroup, ShaderRef},
 };
 
@@ -53,7 +53,7 @@ impl Material for CustomMaterial {
 }
 
 // This is the struct that will be passed to your shader
-#[derive(AsBindGroup, TypeUuid, Debug, Clone)]
+#[derive(AsBindGroup, TypeUuid, TypePath, Debug, Clone)]
 #[uuid = "f690fdae-d598-45ab-8225-97e2a3f056e0"]
 pub struct CustomMaterial {
     #[uniform(0)]

examples/shader/shader_material_glsl.rs

@@ -3,7 +3,7 @@
 use bevy::{
     pbr::{MaterialPipeline, MaterialPipelineKey},
     prelude::*,
-    reflect::TypeUuid,
+    reflect::{TypePath, TypeUuid},
     render::{
         mesh::MeshVertexBufferLayout,
         render_resource::{
@@ -47,7 +47,7 @@ fn setup(
 }
 
 // This is the struct that will be passed to your shader
-#[derive(AsBindGroup, Clone, TypeUuid)]
+#[derive(AsBindGroup, Clone, TypeUuid, TypePath)]
 #[uuid = "4ee9c363-1124-4113-890e-199d81b00281"]
 pub struct CustomMaterial {
     #[uniform(0)]

examples/shader/shader_material_screenspace_texture.rs

@@ -2,7 +2,7 @@
 
 use bevy::{
     prelude::*,
-    reflect::TypeUuid,
+    reflect::{TypePath, TypeUuid},
     render::render_resource::{AsBindGroup, ShaderRef},
 };
 
@@ -66,7 +66,7 @@ fn rotate_camera(mut camera: Query<&mut Transform, With<MainCamera>>, time: Res<
     cam_transform.look_at(Vec3::ZERO, Vec3::Y);
 }
 
-#[derive(AsBindGroup, Debug, Clone, TypeUuid)]
+#[derive(AsBindGroup, Debug, Clone, TypeUuid, TypePath)]
 #[uuid = "b62bb455-a72c-4b56-87bb-81e0554e234f"]
 pub struct CustomMaterial {
     #[texture(0)]

examples/shader/shader_prepass.rs

@@ -6,7 +6,7 @@ use bevy::{
     core_pipeline::prepass::{DepthPrepass, MotionVectorPrepass, NormalPrepass},
     pbr::{NotShadowCaster, PbrPlugin},
     prelude::*,
-    reflect::TypeUuid,
+    reflect::{TypePath, TypeUuid},
     render::render_resource::{AsBindGroup, ShaderRef, ShaderType},
 };
 
@@ -155,7 +155,7 @@ fn setup(
 }
 
 // This is the struct that will be passed to your shader
-#[derive(AsBindGroup, TypeUuid, Debug, Clone)]
+#[derive(AsBindGroup, TypePath, TypeUuid, Debug, Clone)]
 #[uuid = "f690fdae-d598-45ab-8225-97e2a3f056e0"]
 pub struct CustomMaterial {
     #[uniform(0)]
@@ -204,7 +204,7 @@ struct ShowPrepassSettings {
 }
 
 // This shader simply loads the prepass texture and outputs it directly
-#[derive(AsBindGroup, TypeUuid, Debug, Clone)]
+#[derive(AsBindGroup, TypePath, TypeUuid, Debug, Clone)]
 #[uuid = "0af99895-b96e-4451-bc12-c6b1c1c52750"]
 pub struct PrepassOutputMaterial {
     #[uniform(0)]

examples/shader/texture_binding_array.rs

@@ -3,7 +3,7 @@
 
 use bevy::{
     prelude::*,
-    reflect::TypeUuid,
+    reflect::{TypePath, TypeUuid},
     render::{
         render_asset::RenderAssets,
         render_resource::{AsBindGroupError, PreparedBindGroup, *},
@@ -85,7 +85,7 @@ fn setup(
     });
 }
 
-#[derive(Debug, Clone, TypeUuid)]
+#[derive(Debug, Clone, TypePath, TypeUuid)]
 #[uuid = "8dd2b424-45a2-4a53-ac29-7ce356b2d5fe"]
 struct BindlessMaterial {
     textures: Vec<Handle<Image>>,