special-case interned system sets

Author: joseph-gio

crates/bevy_ecs/macros/src/set.rs

@@ -1,3 +1,4 @@
+use bevy_macro_utils::BevyManifest;
 use proc_macro::TokenStream;
 use quote::{quote, quote_spanned};
 use syn::spanned::Spanned;
@@ -9,6 +10,8 @@ use syn::spanned::Spanned;
 /// - `input`: The [`syn::DeriveInput`] for the struct that we want to derive the set trait for
 /// - `trait_path`: The [`syn::Path`] to the set trait
 pub fn derive_set(input: syn::DeriveInput, trait_path: &syn::Path) -> TokenStream {
+    let bevy_utils_path = BevyManifest::default().get_path("bevy_utils");
+
     let ident = input.ident;
 
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
@@ -69,6 +72,15 @@ pub fn derive_set(input: syn::DeriveInput, trait_path: &syn::Path) -> TokenStrea
                 std::boxed::Box::new(std::clone::Clone::clone(self))
             }
 
+            fn as_dyn_eq(&self) -> &dyn #bevy_utils_path::label::DynEq {
+                self
+            }
+
+            fn dyn_hash(&self, mut state: &mut dyn ::std::hash::Hasher) {
+                std::hash::Hash::hash(&std::any::TypeId::of::<Self>(), &mut state);
+                std::hash::Hash::hash(self, &mut state);
+            }
+
             fn dyn_static_ref(&self) -> std::option::Option<&'static dyn #trait_path> {
                 #dyn_static_ref_impl
             }

crates/bevy_ecs/src/schedule/set.rs

@@ -6,7 +6,7 @@ use std::marker::PhantomData;
 pub use bevy_ecs_macros::{ScheduleLabel, SystemSet};
 use bevy_utils::define_label;
 use bevy_utils::intern::{Interned, Interner, Leak};
-use bevy_utils::label::DynHash;
+use bevy_utils::label::DynEq;
 
 use crate::system::{
     ExclusiveSystemParamFunction, IsExclusiveFunctionSystem, IsFunctionSystem, SystemParamFunction,
@@ -25,7 +25,7 @@ pub type InternedSystemSet = Interned<dyn SystemSet>;
 pub type InternedScheduleLabel = Interned<dyn ScheduleLabel>;
 
 /// Types that identify logical groups of systems.
-pub trait SystemSet: DynHash + Debug + Send + Sync + 'static {
+pub trait SystemSet: Debug + Send + Sync + 'static {
     /// Returns `Some` if this system set is a [`SystemTypeSet`].
     fn system_type(&self) -> Option<TypeId> {
         None
@@ -39,6 +39,12 @@ pub trait SystemSet: DynHash + Debug + Send + Sync + 'static {
     /// Creates a boxed clone of the label corresponding to this system set.
     fn dyn_clone(&self) -> Box<dyn SystemSet>;
 
+    /// Casts this value to a form where it can be compared with other type-erased values.
+    fn as_dyn_eq(&self) -> &dyn DynEq;
+
+    /// Feeds this value into the given [`Hasher`].
+    fn dyn_hash(&self, state: &mut dyn Hasher);
+
     /// Returns a static reference to a value equal to `self`, if possible.
     /// This method is used to optimize [interning](bevy_utils::intern).
     ///
@@ -97,6 +103,14 @@ impl SystemSet for Interned<dyn SystemSet> {
         (**self).dyn_clone()
     }
 
+    fn as_dyn_eq(&self) -> &dyn DynEq {
+        (**self).as_dyn_eq()
+    }
+
+    fn dyn_hash(&self, state: &mut dyn Hasher) {
+        (**self).dyn_hash(state)
+    }
+
     fn dyn_static_ref(&self) -> Option<&'static dyn SystemSet> {
         Some(self.0)
     }
@@ -111,7 +125,7 @@ impl SystemSet for Interned<dyn SystemSet> {
 
 impl PartialEq for dyn SystemSet {
     fn eq(&self, other: &Self) -> bool {
-        self.dyn_eq(other.as_dyn_eq())
+        self.as_dyn_eq().dyn_eq(other.as_dyn_eq())
     }
 }
 
@@ -187,6 +201,15 @@ impl<T> SystemSet for SystemTypeSet<T> {
         Box::new(*self)
     }
 
+    fn as_dyn_eq(&self) -> &dyn DynEq {
+        self
+    }
+
+    fn dyn_hash(&self, mut state: &mut dyn Hasher) {
+        std::any::TypeId::of::<Self>().hash(&mut state);
+        self.hash(&mut state);
+    }
+
     fn dyn_static_ref(&self) -> Option<&'static dyn SystemSet> {
         Some(&Self(PhantomData))
     }
@@ -208,6 +231,15 @@ impl SystemSet for AnonymousSet {
         true
     }
 
+    fn as_dyn_eq(&self) -> &dyn DynEq {
+        self
+    }
+
+    fn dyn_hash(&self, mut state: &mut dyn Hasher) {
+        std::any::TypeId::of::<Self>().hash(&mut state);
+        self.hash(&mut state);
+    }
+
     fn dyn_clone(&self) -> Box<dyn SystemSet> {
         Box::new(*self)
     }

crates/bevy_transform/Cargo.toml

@@ -15,6 +15,7 @@ bevy_ecs = { path = "../bevy_ecs", version = "0.12.0-dev", features = ["bevy_ref
 bevy_hierarchy = { path = "../bevy_hierarchy", version = "0.12.0-dev" }
 bevy_math = { path = "../bevy_math", version = "0.12.0-dev" }
 bevy_reflect = { path = "../bevy_reflect", version = "0.12.0-dev", features = ["bevy"] }
+bevy_utils = { path = "../bevy_utils", version = "0.12.0-dev" }
 serde = { version = "1", features = ["derive"], optional = true }
 
 [dev-dependencies]