chore: Make TypePath more stable, README note

README.md

@@ -174,6 +174,12 @@ All recommended crates implement the necessary traits to be compatible with `bev
 - **`thread_local_entropy`** - Enables `ThreadLocalEntropy`, overriding `SeedableRng::from_entropy` implementations to make use of thread local entropy sources for faster PRNG initialisation. Enabled by default.
 - **`serialize`** - Enables [`Serialize`] and [`Deserialize`] derives. Enabled by default.
 
+## Note about Reflection & `TypePath` stability.
+
+All `rand` PRNGs do not implement `TypePath` in any form, even as an optional feature, due to lack of native support for reflection in Rust. As such, while the components/resource in this library are *stable* and implement a stable `TypePath` for themselves, PRNGs rely on `std::any::type_name` for returning the type's name/path, which is NOT guaranteed to be stable for all versions of the compiler. As such, there may be instabilities/compatibilities with different compiler versions and compilations, as this instability infects the overall `TypePath` via the generic portion of the type path.
+
+If there arises problems with regards to stability for reflection purposes, please make an issue with regards to that in this repository, so I can track such occurrences. Tests are included in the crate anyway to hopefully detect such cases in the future.
+
 ## Supported Versions & MSRV
 
 `bevy_rand` uses the same MSRV as `bevy`.

src/component.rs

@@ -123,15 +123,20 @@ impl<R: SeedableEntropySource + 'static> EntropyComponent<R> {
     }
 }
 
-
 impl<R: SeedableEntropySource + 'static> TypePath for EntropyComponent<R> {
     fn type_path() -> &'static str {
-        std::any::type_name::<Self>()
+        static CELL: GenericTypePathCell = GenericTypePathCell::new();
+        CELL.get_or_insert::<Self, _>(|| {
+            format!(
+                "bevy_rand::component::EntropyComponent<{}>",
+                std::any::type_name::<R>()
+            )
+        })
     }
 
     fn short_type_path() -> &'static str {
         static CELL: GenericTypePathCell = GenericTypePathCell::new();
-        CELL.get_or_insert::<Self, _>(|| bevy::utils::get_short_name(std::any::type_name::<Self>()))
+        CELL.get_or_insert::<Self, _>(|| bevy::utils::get_short_name(Self::type_path()))
     }
 
     fn type_ident() -> Option<&'static str> {
@@ -250,6 +255,19 @@ mod tests {
         );
     }
 
+    #[test]
+    fn type_paths() {
+        assert_eq!(
+            "bevy_rand::component::EntropyComponent<rand_chacha::chacha::ChaCha8Rng>",
+            EntropyComponent::<ChaCha8Rng>::type_path()
+        );
+
+        assert_eq!(
+            "EntropyComponent<ChaCha8Rng>",
+            EntropyComponent::<ChaCha8Rng>::short_type_path()
+        );
+    }
+
     #[cfg(feature = "serialize")]
     #[test]
     fn rng_reflection() {

src/resource.rs

@@ -68,12 +68,18 @@ impl<R: SeedableEntropySource + 'static> GlobalEntropy<R> {
 
 impl<R: SeedableEntropySource + 'static> TypePath for GlobalEntropy<R> {
     fn type_path() -> &'static str {
-        std::any::type_name::<Self>()
+        static CELL: GenericTypePathCell = GenericTypePathCell::new();
+        CELL.get_or_insert::<Self, _>(|| {
+            format!(
+                "bevy_rand::resource::GlobalEntropy<{}>",
+                std::any::type_name::<R>()
+            )
+        })
     }
 
     fn short_type_path() -> &'static str {
         static CELL: GenericTypePathCell = GenericTypePathCell::new();
-        CELL.get_or_insert::<Self, _>(|| bevy::utils::get_short_name(std::any::type_name::<Self>()))
+        CELL.get_or_insert::<Self, _>(|| bevy::utils::get_short_name(Self::type_path()))
     }
 
     fn type_ident() -> Option<&'static str> {
@@ -160,15 +166,30 @@ impl<R: SeedableEntropySource + 'static> From<&mut R> for GlobalEntropy<R> {
 
 #[cfg(test)]
 mod tests {
+    use rand_chacha::ChaCha8Rng;
+
+    use super::*;
+
+    #[test]
+    fn type_paths() {
+        assert_eq!(
+            "bevy_rand::resource::GlobalEntropy<rand_chacha::chacha::ChaCha8Rng>",
+            GlobalEntropy::<ChaCha8Rng>::type_path()
+        );
+
+        assert_eq!(
+            "GlobalEntropy<ChaCha8Rng>",
+            GlobalEntropy::<ChaCha8Rng>::short_type_path()
+        );
+    }
+
     #[cfg(feature = "serialize")]
     #[test]
     fn rng_reflection() {
-        use super::*;
         use bevy::reflect::{
             serde::{ReflectSerializer, UntypedReflectDeserializer},
             TypeRegistryInternal,
         };
-        use rand_chacha::ChaCha8Rng;
         use ron::ser::to_string;
         use serde::de::DeserializeSeed;