interned labels are labels

Author: joseph-gio

crates/bevy_ecs/src/schedule/config.rs

@@ -449,12 +449,6 @@ impl<S: SystemSet> IntoSystemSetConfig for S {
     }
 }
 
-impl IntoSystemSetConfig for InternedSystemSet {
-    fn into_config(self) -> SystemSetConfig {
-        SystemSetConfig::new(self)
-    }
-}
-
 impl IntoSystemSetConfig for SystemSetConfig {
     fn into_config(self) -> Self {
         self

crates/bevy_ecs/src/schedule/set.rs

@@ -76,6 +76,24 @@ pub trait SystemSet: DynHash + Debug + Send + Sync + 'static {
     }
 }
 
+impl SystemSet for Interned<dyn SystemSet> {
+    fn system_type(&self) -> Option<TypeId> {
+        (**self).system_type()
+    }
+
+    fn is_anonymous(&self) -> bool {
+        (**self).is_anonymous()
+    }
+
+    fn dyn_clone(&self) -> Box<dyn SystemSet> {
+        (**self).dyn_clone()
+    }
+
+    fn dyn_static_ref(&self) -> Option<&'static dyn SystemSet> {
+        Some(self.0)
+    }
+}
+
 impl From<&dyn SystemSet> for Interned<dyn SystemSet> {
     fn from(value: &dyn SystemSet) -> Interned<dyn SystemSet> {
         SYSTEM_SET_INTERNER.intern(value)

crates/bevy_utils/src/intern.rs

@@ -26,7 +26,7 @@ use crate::HashSet;
 // This implements [`Copy`], [`Clone`], [`PartialEq`], [`Eq`] and [`Hash`] regardles of what `T`
 // implements, because it only uses the pointer to the value and not the value itself.
 // Therefore it MUST NEVER implement [`Borrow`](`std::borrow::Borrow`).
-pub struct Interned<T: ?Sized + 'static>(&'static T);
+pub struct Interned<T: ?Sized + 'static>(pub &'static T);
 
 impl<T: ?Sized> Deref for Interned<T> {
     type Target = T;

crates/bevy_utils/src/label.rs

@@ -142,6 +142,29 @@ macro_rules! define_label {
             }
         }
 
+        impl $label_trait_name for ::bevy_utils::intern::Interned<dyn $label_trait_name> {
+            fn inner_type_id(&self) -> ::std::any::TypeId {
+                (**self).inner_type_id()
+            }
+
+            fn dyn_clone(&self) -> Box<dyn $label_trait_name> {
+                (**self).dyn_clone()
+            }
+
+            /// Casts this value to a form where it can be compared with other type-erased values.
+            fn as_dyn_eq(&self) -> &dyn ::bevy_utils::label::DynEq {
+                (**self).as_dyn_eq()
+            }
+
+            fn dyn_hash(&self, state: &mut dyn ::std::hash::Hasher) {
+                (**self).dyn_hash(state)
+            }
+
+            fn dyn_static_ref(&self) -> Option<&'static dyn $label_trait_name> {
+                Some(self.0)
+            }
+        }
+
         impl PartialEq for dyn $label_trait_name {
             fn eq(&self, other: &Self) -> bool {
                 self.as_dyn_eq().dyn_eq(other.as_dyn_eq())