don't box non-generic hashed labels

Author: joseph-gio

crates/bevy_macro_utils/src/lib.rs

@@ -345,29 +345,53 @@ fn derive_hashed_label(
         path
     };
 
-    let boxed_ty = quote! { ::std::boxed::Box::<dyn #downcast_debug_path + ::std::marker::Send + ::std::marker::Sync> };
+    // If the type is generic, we need to box it before interning it.
+    // Since Rust does not currently allow us to have generic types with associated statics,
+    // all of the labels for any generic type must be interned in the same global.
+    let is_generic = !input.generics.params.is_empty();
+
+    let interner_generics = if !is_generic {
+        quote! { <u64, #ident> }
+    } else {
+        let boxed_ty = quote! { ::std::boxed::Box::<dyn #downcast_debug_path + ::std::marker::Send + ::std::marker::Sync> };
+        quote! { <(u64, ::std::any::TypeId), #boxed_ty> }
+    };
+
+    let mut clone_expr = quote! { ::std::clone::Clone::clone(self) };
+    if is_generic {
+        clone_expr = quote! { ::std::boxed::Box::new(#clone_expr) };
+    }
+
+    let key_expr = if !is_generic {
+        quote! { hash }
+    } else {
+        quote! { (hash, ::std::any::TypeId::of::<Self>()) }
+    };
+
+    let mut get_expr = quote! { #interner_ident .get(#key_expr) };
+    if is_generic {
+        let try_map = quote! { <#guard_type_path<_>>::try_map };
+        let downcast = quote! { <dyn #downcast_debug_path>::downcast_ref };
+        get_expr = quote! {
+            #try_map(#get_expr?, |val| #downcast::<Self>(&**val)).ok()
+        };
+    }
 
     quote! {
-        // 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 <(u64, ::std::any::TypeId), #boxed_ty>
+            : #interner_type_path #interner_generics
             = #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);
-                let key = (hash, ::std::any::TypeId::of::<Self>());
-                #interner_ident .intern(key, || ::std::boxed::Box::new(::std::clone::Clone::clone(self)));
+                #interner_ident .intern(#key_expr, || #clone_expr);
                 hash
             }
             fn fmt(hash: u64, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-                let key = (hash, ::std::any::TypeId::of::<Self>());
                 #interner_ident
-                    .scope(key, |val| ::std::fmt::Debug::fmt(val, f))
+                    .scope(#key_expr, |val| ::std::fmt::Debug::fmt(val, f))
                     .ok_or(::std::fmt::Error)?
             }
         }
@@ -376,11 +400,7 @@ 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);
-                let key = (hash, ::std::any::TypeId::of::<Self>());
-                <#guard_type_path<_>>::try_map(
-                    #interner_ident .get(key)?,
-                    |val| <dyn #downcast_debug_path>::downcast_ref::<Self>(&**val),
-                ).ok()
+                #get_expr
             }
         }
     }