derive boxed labels

Author: joseph-gio

crates/bevy_ecs/examples/derive_label.rs

@@ -1,9 +1,6 @@
 use std::{hash::Hash, marker::PhantomData};
 
-use bevy_ecs::{
-    prelude::*,
-    schedule::{LabelGuard, Labels, SystemLabelId},
-};
+use bevy_ecs::prelude::*;
 
 fn main() {
     // Unit labels are always equal.
@@ -91,29 +88,8 @@ pub struct BadLabel2 {
     x: (),
 }*/
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, SystemLabel)]
+#[system_label(hash)]
 pub struct ComplexLabel {
     people: Vec<&'static str>,
 }
-
-static MAP: Labels<ComplexLabel> = Labels::new();
-
-impl SystemLabel for ComplexLabel {
-    fn data(&self) -> u64 {
-        let hash = bevy_utils::compute_fixed_hash(self);
-        MAP.intern(hash, || self.clone());
-        hash
-    }
-    fn fmt(hash: u64, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        MAP.scope(hash, |val| write!(f, "{val:?}"))
-            .ok_or_else(Default::default)?
-    }
-}
-
-impl bevy_utils::label::LabelDowncast<SystemLabelId> for ComplexLabel {
-    type Output = LabelGuard<'static, ComplexLabel>;
-    fn downcast_from(label: SystemLabelId) -> Option<Self::Output> {
-        let hash = label.data();
-        MAP.get(hash)
-    }
-}

crates/bevy_ecs/macros/src/lib.rs

@@ -446,7 +446,10 @@ pub fn derive_system_label(input: TokenStream) -> TokenStream {
     trait_path
         .segments
         .push(format_ident!("SystemLabel").into());
-    derive_label(input, &trait_path, "system_label")
+    let mut id_path = bevy_ecs_path();
+    id_path.segments.push(format_ident!("schedule").into());
+    id_path.segments.push(format_ident!("SystemLabelId").into());
+    derive_label(input, &trait_path, &id_path, "system_label")
 }
 
 /// Generates an impl of the `StageLabel` trait.
@@ -459,7 +462,10 @@ pub fn derive_stage_label(input: TokenStream) -> TokenStream {
     let mut trait_path = bevy_ecs_path();
     trait_path.segments.push(format_ident!("schedule").into());
     trait_path.segments.push(format_ident!("StageLabel").into());
-    derive_label(input, &trait_path, "stage_label")
+    let mut id_path = bevy_ecs_path();
+    id_path.segments.push(format_ident!("schedule").into());
+    id_path.segments.push(format_ident!("StageLabelId").into());
+    derive_label(input, &trait_path, &id_path, "stage_label")
 }
 
 /// Generates an impl of the `AmbiguitySetLabel` trait.
@@ -474,7 +480,12 @@ pub fn derive_ambiguity_set_label(input: TokenStream) -> TokenStream {
     trait_path
         .segments
         .push(format_ident!("AmbiguitySetLabel").into());
-    derive_label(input, &trait_path, "ambiguity_set_label")
+    let mut id_path = bevy_ecs_path();
+    id_path.segments.push(format_ident!("schedule").into());
+    id_path
+        .segments
+        .push(format_ident!("AmbiguitySetLabelId").into());
+    derive_label(input, &trait_path, &id_path, "ambiguity_set_label")
 }
 
 /// Generates an impl of the `RunCriteriaLabel` trait.
@@ -489,7 +500,12 @@ pub fn derive_run_criteria_label(input: TokenStream) -> TokenStream {
     trait_path
         .segments
         .push(format_ident!("RunCriteriaLabel").into());
-    derive_label(input, &trait_path, "run_criteria_label")
+    let mut id_path = bevy_ecs_path();
+    id_path.segments.push(format_ident!("schedule").into());
+    id_path
+        .segments
+        .push(format_ident!("RunCriteriaLabelId").into());
+    derive_label(input, &trait_path, &id_path, "run_criteria_label")
 }
 
 pub(crate) fn bevy_ecs_path() -> syn::Path {

crates/bevy_macro_utils/src/lib.rs

@@ -9,7 +9,7 @@ pub use shape::*;
 pub use symbol::*;
 
 use proc_macro::TokenStream;
-use quote::{quote, quote_spanned};
+use quote::{format_ident, quote, quote_spanned};
 use std::{env, path::PathBuf};
 use syn::spanned::Spanned;
 use toml::{map::Map, Value};
@@ -105,6 +105,22 @@ impl BevyManifest {
     }
 }
 
+fn is_attr<T: syn::parse::Parse + syn::token::CustomToken>(
+    attr: &syn::Attribute,
+    attr_name: &str,
+) -> bool {
+    if attr.path.get_ident().as_ref().unwrap() != &attr_name {
+        return false;
+    }
+
+    attr.parse_args_with(|input: syn::parse::ParseStream| {
+        let ignore = input.parse::<Option<T>>()?.is_some();
+        Ok(ignore)
+    })
+    .ok()
+        == Some(true)
+}
+
 /// Derive a label trait
 ///
 /// # Args
@@ -114,32 +130,49 @@ impl BevyManifest {
 pub fn derive_label(
     input: syn::DeriveInput,
     trait_path: &syn::Path,
+    id_path: &syn::Path,
     attr_name: &str,
 ) -> TokenStream {
-    // return true if the variant specified is an `ignore_fields` attribute
-    fn is_ignore(attr: &syn::Attribute, attr_name: &str) -> bool {
-        if attr.path.get_ident().as_ref().unwrap() != &attr_name {
-            return false;
-        }
-
-        syn::custom_keyword!(ignore_fields);
-        attr.parse_args_with(|input: syn::parse::ParseStream| {
-            let ignore = input.parse::<Option<ignore_fields>>()?.is_some();
-            Ok(ignore)
-        })
-        .unwrap()
+    fn is_hash_attr(attr: &syn::Attribute, attr_name: &str) -> bool {
+        syn::custom_keyword!(hash);
+        is_attr::<hash>(attr, attr_name)
     }
 
-    let ident = input.ident.clone();
+    // If the label is marked with `#[label(hash)]`.
+    let hash_attr = input.attrs.iter().any(|a| is_hash_attr(a, attr_name));
 
-    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    if hash_attr {
+        derive_hashed_label(input, trait_path, id_path, attr_name)
+    } else {
+        derive_named_label(input, trait_path, attr_name)
+    }
+}
+
+fn with_static_bound(where_clause: Option<&syn::WhereClause>) -> syn::WhereClause {
     let mut where_clause = where_clause.cloned().unwrap_or_else(|| syn::WhereClause {
         where_token: Default::default(),
         predicates: Default::default(),
     });
     where_clause
         .predicates
         .push(syn::parse2(quote! { Self: 'static }).unwrap());
+    where_clause
+}
+
+fn derive_named_label(
+    input: syn::DeriveInput,
+    trait_path: &syn::Path,
+    attr_name: &str,
+) -> TokenStream {
+    // return true if the variant specified is an `ignore_fields` attribute
+    fn is_ignore(attr: &syn::Attribute, attr_name: &str) -> bool {
+        syn::custom_keyword!(ignore_fields);
+        is_attr::<ignore_fields>(attr, attr_name)
+    }
+
+    let ident = input.ident.clone();
+    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
+    let where_clause = with_static_bound(where_clause);
 
     let (data, mut fmt) = match input.data {
         syn::Data::Struct(d) => {
@@ -260,3 +293,68 @@ pub fn derive_label(
     })
     .into()
 }
+
+fn derive_hashed_label(
+    input: syn::DeriveInput,
+    trait_path: &syn::Path,
+    id_path: &syn::Path,
+    _attr_name: &str,
+) -> TokenStream {
+    let manifest = BevyManifest::default();
+
+    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 compute_hash_path = {
+        let mut path = manifest.get_path("bevy_utils");
+        path.segments
+            .push(format_ident!("compute_fixed_hash").into());
+        path
+    };
+    let interner_type_path = {
+        let mut path = manifest.get_path("bevy_ecs");
+        path.segments.push(format_ident!("schedule").into());
+        path.segments.push(format_ident!("Labels").into());
+        path
+    };
+    let guard_type_path = {
+        let mut path = manifest.get_path("bevy_ecs");
+        path.segments.push(format_ident!("schedule").into());
+        path.segments.push(format_ident!("LabelGuard").into());
+        path
+    };
+    let interner_ident = format_ident!("{}_INTERN", ident.to_string().to_uppercase());
+    let downcast_trait_path = {
+        let mut path = manifest.get_path("bevy_utils");
+        path.segments.push(format_ident!("label").into());
+        path.segments.push(format_ident!("LabelDowncast").into());
+        path
+    };
+
+    quote! {
+        static #interner_ident : #interner_type_path <#ident #ty_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);
+                #interner_ident .intern(hash, || ::std::clone::Clone::clone(self));
+                hash
+            }
+            fn fmt(hash: u64, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                #interner_ident
+                    .scope(hash, |val| ::std::fmt::Debug::fmt(val, f))
+                    .ok_or(::std::fmt::Error)?
+            }
+        }
+
+        impl #impl_generics #downcast_trait_path <#id_path> for #ident #ty_generics #where_clause {
+            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)
+            }
+        }
+    }.into()
+}