remove Borrow from Leak

Author: joseph-gio

crates/bevy_ecs/src/schedule/set.rs

@@ -1,5 +1,4 @@
 use std::any::TypeId;
-use std::borrow::Borrow;
 use std::fmt::Debug;
 use std::hash::{Hash, Hasher};
 use std::marker::PhantomData;
@@ -79,21 +78,7 @@ pub trait SystemSet: DynHash + Debug + Send + Sync + 'static {
 
 impl From<&dyn SystemSet> for Interned<dyn SystemSet> {
     fn from(value: &dyn SystemSet) -> Interned<dyn SystemSet> {
-        struct LeakHelper<'a>(&'a dyn SystemSet);
-
-        impl<'a> Borrow<dyn SystemSet> for LeakHelper<'a> {
-            fn borrow(&self) -> &dyn SystemSet {
-                self.0
-            }
-        }
-
-        impl<'a> Leak<dyn SystemSet> for LeakHelper<'a> {
-            fn leak(self) -> &'static dyn SystemSet {
-                Box::leak(self.0.dyn_clone())
-            }
-        }
-
-        SYSTEM_SET_INTERNER.intern(LeakHelper(value))
+        SYSTEM_SET_INTERNER.intern(value)
     }
 }
 
@@ -111,6 +96,12 @@ impl Hash for dyn SystemSet {
     }
 }
 
+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

@@ -5,7 +5,7 @@
 //! and make comparisons for any type as fast as integers.
 
 use std::{
-    borrow::{Borrow, Cow},
+    borrow::Borrow,
     fmt::Debug,
     hash::Hash,
     ops::Deref,
@@ -76,31 +76,15 @@ impl<T> From<&Interned<T>> for Interned<T> {
 /// A trait for leaking data.
 ///
 /// This is used by [`Interner<T>`] to create static references for values that are interned.
-///
-/// It is implemented for static references of `T`, [`Box<T>`], and [`Cow<'static, T>`].
-pub trait Leak<T: ?Sized>: Borrow<T> {
-    /// Creates a static reference to a value equal to `self.borrow()`, possibly leaking memory.
-    fn leak(self) -> &'static T;
-}
-
-impl<T: ?Sized> Leak<T> for &'static T {
-    fn leak(self) -> &'static T {
-        self
-    }
+pub trait Leak {
+    /// Creates a static reference to `self`, possibly leaking memory.
+    fn leak(&self) -> &'static Self;
 }
 
-impl<T: ?Sized> Leak<T> for Box<T> {
-    fn leak(self) -> &'static T {
-        Box::leak(self)
-    }
-}
-
-impl<T: Clone + ?Sized> Leak<T> for Cow<'static, T> {
-    fn leak(self) -> &'static T {
-        match self {
-            Cow::Borrowed(value) => value,
-            Cow::Owned(value) => Box::leak(Box::new(value)),
-        }
+impl Leak for str {
+    fn leak(&self) -> &'static Self {
+        let str = self.to_owned().into_boxed_str();
+        Box::leak(str)
     }
 }
 
@@ -161,16 +145,16 @@ impl<T: ?Sized> Interner<T> {
     }
 }
 
-impl<T: StaticRef + Hash + Eq + ?Sized> Interner<T> {
+impl<T: Leak + StaticRef + 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
     /// [`Interned<T>`] using the obtained static reference. Subsequent calls for the same `value`
     /// will return [`Interned<T>`] using the same static reference.
     ///
     /// This uses [`StaticRef::static_ref`] to short-circuit the interning process.
-    pub fn intern<Q: Leak<T>>(&self, value: Q) -> Interned<T> {
-        if let Some(value) = value.borrow().static_ref() {
+    pub fn intern(&self, value: &T) -> Interned<T> {
+        if let Some(value) = value.static_ref() {
             return Interned(value);
         }
         let lock = self.0.get_or_init(Default::default);
@@ -219,15 +203,15 @@ mod tests {
             }
         }
 
-        impl Leak<A> for A {
-            fn leak(self) -> &'static Self {
+        impl Leak for A {
+            fn leak(&self) -> &'static Self {
                 &A
             }
         }
 
         let interner = Interner::default();
-        let x = interner.intern(A);
-        let y = interner.intern(A);
+        let x = interner.intern(&A);
+        let y = interner.intern(&A);
         assert_eq!(x, y);
     }
 
@@ -248,8 +232,8 @@ mod tests {
             }
         }
 
-        impl Leak<A> for A {
-            fn leak(self) -> &'static Self {
+        impl Leak for A {
+            fn leak(&self) -> &'static Self {
                 match self {
                     A::X => &A::X,
                     A::Y => &A::Y,
@@ -258,8 +242,8 @@ mod tests {
         }
 
         let interner = Interner::default();
-        let x = interner.intern(A::X);
-        let y = interner.intern(A::Y);
+        let x = interner.intern(&A::X);
+        let y = interner.intern(&A::Y);
         assert_ne!(x, y);
     }
 

crates/bevy_utils/src/label.rs

@@ -156,6 +156,12 @@ macro_rules! define_label {
             }
         }
 
+        impl ::bevy_utils::intern::Leak for dyn $label_trait_name {
+            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()
@@ -171,21 +177,7 @@ macro_rules! define_label {
             fn from(
                 value: &dyn $label_trait_name,
             ) -> ::bevy_utils::intern::Interned<dyn $label_trait_name> {
-                struct LeakHelper<'a>(&'a dyn $label_trait_name);
-
-                impl<'a> ::std::borrow::Borrow<dyn $label_trait_name> for LeakHelper<'a> {
-                    fn borrow(&self) -> &dyn $label_trait_name {
-                        self.0
-                    }
-                }
-
-                impl<'a> ::bevy_utils::intern::Leak<dyn $label_trait_name> for LeakHelper<'a> {
-                    fn leak(self) -> &'static dyn $label_trait_name {
-                        Box::leak(self.0.dyn_clone())
-                    }
-                }
-
-                $interner_name.intern(LeakHelper(value))
+                $interner_name.intern(value)
             }
         }
     };