merge StaticRef with Leak

Author: joseph-gio

crates/bevy_ecs/src/schedule/set.rs

@@ -5,7 +5,7 @@ use std::marker::PhantomData;
 
 pub use bevy_ecs_macros::{ScheduleLabel, SystemSet};
 use bevy_utils::define_label;
-use bevy_utils::intern::{Interned, Interner, Leak, StaticRef};
+use bevy_utils::intern::{Interned, Interner, Leak};
 use bevy_utils::label::DynHash;
 
 use crate::system::{
@@ -100,9 +100,7 @@ impl Leak for dyn SystemSet {
     fn leak(&self) -> &'static Self {
         Box::leak(self.dyn_clone())
     }
-}
 
-impl StaticRef for dyn SystemSet {
     fn static_ref(&self) -> Option<&'static dyn SystemSet> {
         self.dyn_static_ref()
     }

crates/bevy_utils/src/intern.rs

@@ -79,17 +79,7 @@ impl<T> From<&Interned<T>> for Interned<T> {
 pub trait Leak {
     /// Creates a static reference to `self`, possibly leaking memory.
     fn leak(&self) -> &'static Self;
-}
-
-impl Leak for str {
-    fn leak(&self) -> &'static Self {
-        let str = self.to_owned().into_boxed_str();
-        Box::leak(str)
-    }
-}
 
-/// A type that can provide static references to equal values.
-pub trait StaticRef {
     /// Returns a static reference to a value equal to `self`, if possible.
     /// This method is used by [`Interner::intern`] to optimize the interning process.
     ///
@@ -127,7 +117,12 @@ pub trait StaticRef {
     }
 }
 
-impl StaticRef for str {}
+impl Leak for str {
+    fn leak(&self) -> &'static Self {
+        let str = self.to_owned().into_boxed_str();
+        Box::leak(str)
+    }
+}
 
 /// A thread-safe interner which can be used to create [`Interned<T>`] from `&T`
 ///
@@ -145,7 +140,7 @@ impl<T: ?Sized> Interner<T> {
     }
 }
 
-impl<T: Leak + StaticRef + Hash + Eq + ?Sized> Interner<T> {
+impl<T: Leak + Hash + Eq + ?Sized> Interner<T> {
     /// Return the [`Interned<T>`] corresponding to `value`.
     ///
     /// If it is called the first time for `value`, it will possibly leak the value and return an
@@ -190,23 +185,21 @@ mod tests {
         hash::{Hash, Hasher},
     };
 
-    use crate::intern::{Interned, Interner, Leak, StaticRef};
+    use crate::intern::{Interned, Interner, Leak};
 
     #[test]
     fn zero_sized_type() {
         #[derive(PartialEq, Eq, Hash, Debug)]
         pub struct A;
 
-        impl StaticRef for A {
-            fn static_ref(&self) -> Option<&'static Self> {
-                Some(&A)
-            }
-        }
-
         impl Leak for A {
             fn leak(&self) -> &'static Self {
                 &A
             }
+
+            fn static_ref(&self) -> Option<&'static Self> {
+                Some(&A)
+            }
         }
 
         let interner = Interner::default();
@@ -223,22 +216,20 @@ mod tests {
             Y,
         }
 
-        impl StaticRef for A {
-            fn static_ref(&self) -> Option<&'static Self> {
-                Some(match self {
-                    A::X => &A::X,
-                    A::Y => &A::Y,
-                })
-            }
-        }
-
         impl Leak for A {
             fn leak(&self) -> &'static Self {
                 match self {
                     A::X => &A::X,
                     A::Y => &A::Y,
                 }
             }
+
+            fn static_ref(&self) -> Option<&'static Self> {
+                Some(match self {
+                    A::X => &A::X,
+                    A::Y => &A::Y,
+                })
+            }
         }
 
         let interner = Interner::default();

crates/bevy_utils/src/label.rs

@@ -160,9 +160,7 @@ macro_rules! define_label {
             fn leak(&self) -> &'static Self {
                 Box::leak(self.dyn_clone())
             }
-        }
 
-        impl ::bevy_utils::intern::StaticRef for dyn $label_trait_name {
             fn static_ref(&self) -> std::option::Option<&'static dyn $label_trait_name> {
                 self.dyn_static_ref()
             }