support generic hashed labels

Author: joseph-gio

crates/bevy_ecs/examples/derive_label.rs

@@ -1,4 +1,4 @@
-use std::{hash::Hash, marker::PhantomData};
+use std::{fmt::Debug, hash::Hash, marker::PhantomData};
 
 use bevy_ecs::prelude::*;
 
@@ -93,3 +93,7 @@ pub struct BadLabel2 {
 pub struct ComplexLabel {
     people: Vec<&'static str>,
 }
+
+#[derive(Debug, Clone, PartialEq, Eq, Hash, SystemLabel)]
+#[system_label(hash)]
+pub struct ComplexerLabel<T>(T);

crates/bevy_ecs/src/schedule/label.rs

@@ -1,4 +1,7 @@
+use std::fmt::Debug;
+
 use bevy_utils::{define_label, StableHashMap};
+use downcast_rs::{impl_downcast, Downcast};
 use parking_lot::{RwLock, RwLockReadGuard};
 
 pub use bevy_ecs_macros::{AmbiguitySetLabel, RunCriteriaLabel, StageLabel, SystemLabel};
@@ -75,3 +78,8 @@ impl<L> Labels<L> {
         RwLockReadGuard::try_map(self.0.read(), |map| map.get(&key)).ok()
     }
 }
+
+#[doc(hidden)]
+pub trait DowncastDebug: Debug + Downcast {}
+impl<T: Debug + Downcast> DowncastDebug for T {}
+impl_downcast!(DowncastDebug);

crates/bevy_macro_utils/src/lib.rs

@@ -304,7 +304,14 @@ fn derive_hashed_label(
 
     let ident = input.ident;
     let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
-    let where_clause = with_static_bound(where_clause);
+    let mut where_clause = with_static_bound(where_clause);
+    where_clause.predicates.push(
+        syn::parse2(quote! {
+            Self: ::std::clone::Clone + ::std::cmp::Eq + ::std::hash::Hash + ::std::fmt::Debug
+                + ::std::marker::Send + ::std::marker::Sync + 'static
+        })
+        .unwrap(),
+    );
 
     let compute_hash_path = {
         let mut path = manifest.get_path("bevy_utils");
@@ -331,15 +338,27 @@ fn derive_hashed_label(
         path.segments.push(format_ident!("LabelDowncast").into());
         path
     };
+    let downcast_debug_path = {
+        let mut path = manifest.get_path("bevy_ecs");
+        path.segments.push(format_ident!("schedule").into());
+        path.segments.push(format_ident!("DowncastDebug").into());
+        path
+    };
 
     quote! {
-        static #interner_ident : #interner_type_path <#ident #ty_generics> = #interner_type_path::new();
+        // NOTE: We need to box the interned objects in order to deal with generics.
+        // Unfortunately, we cannot associate data with generic impls, so they all must be
+        // stored together.
+        // FIXME: Make this concrete for types without generics.
+        static #interner_ident
+            : #interner_type_path <::std::boxed::Box::<dyn #downcast_debug_path + ::std::marker::Send + ::std::marker::Sync>>
+            = #interner_type_path::new();
 
         impl #impl_generics #trait_path for #ident #ty_generics #where_clause {
             #[inline]
             fn data(&self) -> u64 {
                 let hash = #compute_hash_path(self);
-                #interner_ident .intern(hash, || ::std::clone::Clone::clone(self));
+                #interner_ident .intern(hash, || ::std::boxed::Box::new(::std::clone::Clone::clone(self)));
                 hash
             }
             fn fmt(hash: u64, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
@@ -353,8 +372,12 @@ fn derive_hashed_label(
             type Output = #guard_type_path <'static, Self>;
             fn downcast_from(label: #id_path) -> Option<Self::Output> {
                 let hash = <#id_path as #trait_path>::data(&label);
-                #interner_ident .get(hash)
+                <#guard_type_path<_>>::try_map(
+                    #interner_ident .get(hash)?,
+                    |val| <dyn #downcast_debug_path>::downcast_ref::<Self>(&**val),
+                ).ok()
             }
         }
-    }.into()
+    }
+    .into()
 }