simplify code, don't need to store UniqueValue since &'static str is already unique

Author: maniwani

crates/bevy_ecs/src/schedule/set.rs

@@ -15,46 +15,56 @@ use crate::system::{
     ExclusiveSystemParamFunction, IsExclusiveFunctionSystem, IsFunctionSystem, SystemParamFunction,
 };
 
-type Interner = RwLock<HashMap<UniqueValueHash, &'static str>>;
+type Interner = RwLock<HashMap<UniqueValue, &'static str>>;
 static INTERNER: OnceCell<Interner> = OnceCell::new();
 
 /// The [`TypeId`](std::any::TypeId) of a value and its [`DynHash`] output when hashed with the [`DefaultHasher`].
 ///
 /// This should be different for each value.
 #[derive(Clone, Copy, Eq, PartialEq, Hash)]
-struct UniqueValueHash(TypeId, u64);
+struct UniqueValue(TypeId, u64);
+
+/// Returns a reference to the interned `Debug` string of `value`.
+///
+/// If the string has not been interned, it will be allocated in a [`Box`] and leaked, but
+/// subsequent calls with the same `value` will return the same reference.
+fn intern_debug<T>(value: &T) -> &'static str
+where
+    T: Debug + DynHash + ?Sized,
+{
+    let mut hasher = DefaultHasher::new();
+    value.dyn_hash(&mut hasher);
+    let hash = hasher.finish();
+
+    let key = UniqueValue(TypeId::of::<T>(), hash);
+    let mut map = INTERNER.get_or_init(default).write().unwrap();
+    let str = *map.entry(key).or_insert_with(|| {
+        let string = format!("{:?}", value);
+        let str: &'static str = Box::leak(string.into_boxed_str());
+        str
+    });
+
+    str
+}
 
 /// Identifies a [`Schedule`](super::Schedule).
 pub trait ScheduleLabel: DynHash + Debug + Send + Sync + 'static {}
 
 /// A lightweight and printable identifier for a [`Schedule`](super::Schedule).
 #[derive(Clone, Copy, Eq, PartialEq, Hash)]
-pub struct ScheduleId(UniqueValueHash, &'static str);
+pub struct ScheduleId(&'static str);
 
 impl ScheduleId {
     /// Returns the [`ScheduleId`] of the schedule.
     pub fn of<S: ScheduleLabel + ?Sized>(label: &S) -> ScheduleId {
-        let mut hasher = DefaultHasher::new();
-        label.dyn_hash(&mut hasher);
-        let hash = hasher.finish();
-
-        let type_id = TypeId::of::<S>();
-
-        let key = UniqueValueHash(type_id, hash);
-        let mut map = INTERNER.get_or_init(default).write().unwrap();
-        let str = *map.entry(key).or_insert_with(|| {
-            let string = format!("{:?}", label);
-            let str: &'static str = Box::leak(string.into_boxed_str());
-            str
-        });
-
-        ScheduleId(key, str)
+        let str = intern_debug(label);
+        ScheduleId(str)
     }
 }
 
 impl Debug for ScheduleId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.pad(self.1)
+        self.0.fmt(f)
     }
 }
 
@@ -89,32 +99,19 @@ pub trait SystemSet: DynHash + Debug + Send + Sync + 'static {
 
 /// A lightweight and printable identifier for a [`SystemSet`].
 #[derive(Clone, Copy, Eq, PartialEq, Hash)]
-pub struct SystemSetId(UniqueValueHash, &'static str);
+pub struct SystemSetId(&'static str);
 
 impl SystemSetId {
     /// Returns the [`SystemSetId`] of the set.
     pub fn of<S: SystemSet + ?Sized>(set: &S) -> SystemSetId {
-        let mut hasher = DefaultHasher::new();
-        set.dyn_hash(&mut hasher);
-        let hash = hasher.finish();
-
-        let type_id = TypeId::of::<S>();
-
-        let key = UniqueValueHash(type_id, hash);
-        let mut map = INTERNER.get_or_init(default).write().unwrap();
-        let str = *map.entry(key).or_insert_with(|| {
-            let string = format!("{:?}", set);
-            let str: &'static str = Box::leak(string.into_boxed_str());
-            str
-        });
-
-        SystemSetId(key, str)
+        let str = intern_debug(set);
+        SystemSetId(str)
     }
 }
 
 impl Debug for SystemSetId {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.pad(self.1)
+        self.0.fmt(f)
     }
 }