Make all labels internable

geieredgar · geieredgar · commit 4bd9b8b10f08 · 2023-07-23T11:51:26.000+02:00
diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
@@ -8,7 +8,7 @@ use bevy_ecs::{
         ScheduleLabel,
     },
 };
-use bevy_utils::{tracing::debug, HashMap, HashSet};
+use bevy_utils::{intern::Interned, tracing::debug, HashMap, HashSet};
 use std::{
     fmt::Debug,
     panic::{catch_unwind, resume_unwind, AssertUnwindSafe},
@@ -20,10 +20,12 @@ use bevy_utils::tracing::info_span;
 bevy_utils::define_label!(
     /// A strongly-typed class of labels used to identify an [`App`].
     AppLabel,
-    /// A strongly-typed identifier for an [`AppLabel`].
-    AppLabelId,
+    APP_LABEL_INTERNER
 );
 
+/// A shorthand for `Interned<dyn AppLabel>`.
+pub type InternedAppLabel = Interned<dyn AppLabel>;
+
 pub(crate) enum AppError {
     DuplicatePlugin { plugin_name: String },
 }
@@ -71,7 +73,7 @@ pub struct App {
     ///
     /// This is initially set to [`Main`].
     pub main_schedule_label: InternedScheduleLabel,
-    sub_apps: HashMap<AppLabelId, SubApp>,
+    sub_apps: HashMap<InternedAppLabel, SubApp>,
     plugin_registry: Vec<Box<dyn Plugin>>,
     plugin_name_added: HashSet<String>,
     /// A private counter to prevent incorrect calls to `App::run()` from `Plugin::build()`
@@ -748,16 +750,15 @@ impl App {
     pub fn sub_app_mut(&mut self, label: impl AppLabel) -> &mut App {
         match self.get_sub_app_mut(label) {
             Ok(app) => app,
-            Err(label) => panic!("Sub-App with label '{:?}' does not exist", label.as_str()),
+            Err(label) => panic!("Sub-App with label '{:?}' does not exist", label),
         }
     }
 
     /// Retrieves a `SubApp` inside this [`App`] with the given label, if it exists. Otherwise returns
     /// an [`Err`] containing the given label.
-    pub fn get_sub_app_mut(&mut self, label: impl AppLabel) -> Result<&mut App, AppLabelId> {
-        let label = label.as_label();
+    pub fn get_sub_app_mut(&mut self, label: impl AppLabel) -> Result<&mut App, impl AppLabel> {
         self.sub_apps
-            .get_mut(&label)
+            .get_mut(&InternedAppLabel::from(&label as &dyn AppLabel))
             .map(|sub_app| &mut sub_app.app)
             .ok_or(label)
     }
@@ -770,25 +771,27 @@ impl App {
     pub fn sub_app(&self, label: impl AppLabel) -> &App {
         match self.get_sub_app(label) {
             Ok(app) => app,
-            Err(label) => panic!("Sub-App with label '{:?}' does not exist", label.as_str()),
+            Err(label) => panic!("Sub-App with label '{:?}' does not exist", label),
         }
     }
 
     /// Inserts an existing sub app into the app
     pub fn insert_sub_app(&mut self, label: impl AppLabel, sub_app: SubApp) {
-        self.sub_apps.insert(label.as_label(), sub_app);
+        self.sub_apps
+            .insert((&label as &dyn AppLabel).into(), sub_app);
     }
 
     /// Removes a sub app from the app. Returns [`None`] if the label doesn't exist.
     pub fn remove_sub_app(&mut self, label: impl AppLabel) -> Option<SubApp> {
-        self.sub_apps.remove(&label.as_label())
+        self.sub_apps
+            .remove(&InternedAppLabel::from(&label as &dyn AppLabel))
     }
 
     /// Retrieves a `SubApp` inside this [`App`] with the given label, if it exists. Otherwise returns
     /// an [`Err`] containing the given label.
     pub fn get_sub_app(&self, label: impl AppLabel) -> Result<&App, impl AppLabel> {
         self.sub_apps
-            .get(&label.as_label())
+            .get(&InternedAppLabel::from(&label as &dyn AppLabel))
             .map(|sub_app| &sub_app.app)
             .ok_or(label)
     }
diff --git a/crates/bevy_derive/src/lib.rs b/crates/bevy_derive/src/lib.rs
@@ -203,10 +203,10 @@ pub fn derive_enum_variant_meta(input: TokenStream) -> TokenStream {
 ///
 /// This works only for unit structs, or enums with only unit variants.
 /// You may force a struct or variant to behave as if it were fieldless with `#[app_label(ignore_fields)]`.
-#[proc_macro_derive(AppLabel, attributes(app_label))]
+#[proc_macro_derive(AppLabel)]
 pub fn derive_app_label(input: TokenStream) -> TokenStream {
     let input = syn::parse_macro_input!(input as syn::DeriveInput);
     let mut trait_path = BevyManifest::default().get_path("bevy_app");
     trait_path.segments.push(format_ident!("AppLabel").into());
-    derive_label(input, &trait_path, "app_label")
+    derive_label(input, &trait_path)
 }
diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
@@ -6,9 +6,7 @@ mod set;
 mod states;
 
 use crate::{fetch::derive_world_query_impl, set::derive_set};
-use bevy_macro_utils::{
-    derive_interned_label, ensure_no_collision, get_named_struct_fields, BevyManifest,
-};
+use bevy_macro_utils::{derive_label, ensure_no_collision, get_named_struct_fields, BevyManifest};
 use proc_macro::TokenStream;
 use proc_macro2::Span;
 use quote::{format_ident, quote};
@@ -435,7 +433,7 @@ pub fn derive_schedule_label(input: TokenStream) -> TokenStream {
     trait_path
         .segments
         .push(format_ident!("ScheduleLabel").into());
-    derive_interned_label(input, &trait_path)
+    derive_label(input, &trait_path)
 }
 
 /// Derive macro generating an impl of the trait `SystemSet`.
diff --git a/crates/bevy_ecs/src/schedule/set.rs b/crates/bevy_ecs/src/schedule/set.rs
@@ -5,15 +5,19 @@ use std::hash::{Hash, Hasher};
 use std::marker::PhantomData;
 
 pub use bevy_ecs_macros::{ScheduleLabel, SystemSet};
-use bevy_utils::define_interned_label;
+use bevy_utils::define_label;
 use bevy_utils::intern::{Interned, Leak, OptimizedInterner, StaticRef};
 use bevy_utils::label::DynHash;
 
 use crate::system::{
     ExclusiveSystemParamFunction, IsExclusiveFunctionSystem, IsFunctionSystem, SystemParamFunction,
 };
 
-define_interned_label!(ScheduleLabel, SCHEDULE_LABEL_INTERNER);
+define_label!(
+    /// A strongly-typed class of labels used to identify an [`Schedule`].
+    ScheduleLabel,
+    SCHEDULE_LABEL_INTERNER
+);
 
 static SYSTEM_SET_INTERNER: OptimizedInterner<dyn SystemSet> = OptimizedInterner::new();
 /// A shorthand for `Interned<dyn SystemSet>`.
@@ -248,7 +252,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn test_interned_label() {
+    fn test_label() {
         use crate::{self as bevy_ecs, world::World};
 
         #[derive(Resource)]
diff --git a/crates/bevy_macro_utils/src/lib.rs b/crates/bevy_macro_utils/src/lib.rs
@@ -169,7 +169,7 @@ pub fn ensure_no_collision(value: Ident, haystack: TokenStream) -> Ident {
 ///
 /// - `input`: The [`syn::DeriveInput`] for struct that is deriving the label trait
 /// - `trait_path`: The path [`syn::Path`] to the label trait
-pub fn derive_interned_label(input: syn::DeriveInput, trait_path: &syn::Path) -> TokenStream {
+pub fn derive_label(input: syn::DeriveInput, trait_path: &syn::Path) -> TokenStream {
     let bevy_utils_path = BevyManifest::default().get_path("bevy_utils");
 
     let ident = input.ident;
@@ -260,115 +260,3 @@ pub fn derive_interned_label(input: syn::DeriveInput, trait_path: &syn::Path) ->
     })
     .into()
 }
-
-/// Derive a label trait
-///
-/// # Args
-///
-/// - `input`: The [`syn::DeriveInput`] for struct that is deriving the label trait
-/// - `trait_path`: The path [`syn::Path`] to the label trait
-pub fn derive_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 {
-        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()
-    }
-
-    let ident = input.ident.clone();
-
-    let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
-    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());
-
-    let as_str = match input.data {
-        syn::Data::Struct(d) => {
-            // see if the user tried to ignore fields incorrectly
-            if let Some(attr) = d
-                .fields
-                .iter()
-                .flat_map(|f| &f.attrs)
-                .find(|a| is_ignore(a, attr_name))
-            {
-                let err_msg = format!("`#[{attr_name}(ignore_fields)]` cannot be applied to fields individually: add it to the struct declaration");
-                return quote_spanned! {
-                    attr.span() => compile_error!(#err_msg);
-                }
-                .into();
-            }
-            // Structs must either be fieldless, or explicitly ignore the fields.
-            let ignore_fields = input.attrs.iter().any(|a| is_ignore(a, attr_name));
-            if matches!(d.fields, syn::Fields::Unit) || ignore_fields {
-                let lit = ident.to_string();
-                quote! { #lit }
-            } else {
-                let err_msg = format!("Labels cannot contain data, unless explicitly ignored with `#[{attr_name}(ignore_fields)]`");
-                return quote_spanned! {
-                    d.fields.span() => compile_error!(#err_msg);
-                }
-                .into();
-            }
-        }
-        syn::Data::Enum(d) => {
-            // check if the user put #[label(ignore_fields)] in the wrong place
-            if let Some(attr) = input.attrs.iter().find(|a| is_ignore(a, attr_name)) {
-                let err_msg = format!("`#[{attr_name}(ignore_fields)]` can only be applied to enum variants or struct declarations");
-                return quote_spanned! {
-                    attr.span() => compile_error!(#err_msg);
-                }
-                .into();
-            }
-            let arms = d.variants.iter().map(|v| {
-                // Variants must either be fieldless, or explicitly ignore the fields.
-                let ignore_fields = v.attrs.iter().any(|a| is_ignore(a, attr_name));
-                if matches!(v.fields, syn::Fields::Unit) | ignore_fields {
-                    let mut path = syn::Path::from(ident.clone());
-                    path.segments.push(v.ident.clone().into());
-                    let lit = format!("{ident}::{}", v.ident.clone());
-                    quote! { #path { .. } => #lit }
-                } else {
-                    let err_msg = format!("Label variants cannot contain data, unless explicitly ignored with `#[{attr_name}(ignore_fields)]`");
-                    quote_spanned! {
-                        v.fields.span() => _ => { compile_error!(#err_msg); }
-                    }
-                }
-            });
-            quote! {
-                match self {
-                    #(#arms),*
-                }
-            }
-        }
-        syn::Data::Union(_) => {
-            return quote_spanned! {
-                input.span() => compile_error!("Unions cannot be used as labels.");
-            }
-            .into();
-        }
-    };
-
-    (quote! {
-        impl #impl_generics #trait_path for #ident #ty_generics #where_clause {
-            fn as_str(&self) -> &'static str {
-                #as_str
-            }
-        }
-    })
-    .into()
-}
diff --git a/crates/bevy_utils/src/label.rs b/crates/bevy_utils/src/label.rs
@@ -65,13 +65,22 @@ where
 /// # Example
 ///
 /// ```
-/// # use bevy_utils::define_interned_label;
-/// define_interned_label!(MyNewLabelTrait, MY_NEW_LABEL_TRAIT_INTERNER);
+/// # use bevy_utils::define_label;
+/// define_label!(
+///     /// Documentation of label trait
+///     MyNewLabelTrait,
+///     MY_NEW_LABEL_TRAIT_INTERNER
+/// );
 /// ```
 #[macro_export]
-macro_rules! define_interned_label {
-    ($label_trait_name:ident, $interner_name:ident) => {
-        /// A strongly-typed label.
+macro_rules! define_label {
+    (
+        $(#[$label_attr:meta])*
+        $label_trait_name:ident,
+        $interner_name:ident
+    ) => {
+
+        $(#[$label_attr])*
         pub trait $label_trait_name: 'static + Send + Sync + ::std::fmt::Debug {
             /// Return's the [TypeId] of this label, or the the ID of the
             /// wrappped label type for `Box<dyn
@@ -181,74 +190,3 @@ macro_rules! define_interned_label {
         }
     };
 }
-
-/// Macro to define a new label trait
-///
-/// # Example
-///
-/// ```
-/// # use bevy_utils::define_label;
-/// define_label!(
-///     /// A class of labels.
-///     MyNewLabelTrait,
-///     /// Identifies a value that implements `MyNewLabelTrait`.
-///     MyNewLabelId,
-/// );
-/// ```
-#[macro_export]
-macro_rules! define_label {
-    (
-        $(#[$label_attr:meta])*
-        $label_name:ident,
-
-        $(#[$id_attr:meta])*
-        $id_name:ident $(,)?
-    ) => {
-        $(#[$id_attr])*
-        #[derive(Clone, Copy, PartialEq, Eq, Hash)]
-        pub struct $id_name(::core::any::TypeId, &'static str);
-
-        impl ::core::fmt::Debug for $id_name {
-            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-                write!(f, "{}", self.1)
-            }
-        }
-
-        $(#[$label_attr])*
-        pub trait $label_name: 'static {
-            /// Converts this type into an opaque, strongly-typed label.
-            fn as_label(&self) -> $id_name {
-                let id = self.type_id();
-                let label = self.as_str();
-                $id_name(id, label)
-            }
-            /// Returns the [`TypeId`] used to differentiate labels.
-            fn type_id(&self) -> ::core::any::TypeId {
-                ::core::any::TypeId::of::<Self>()
-            }
-            /// Returns the representation of this label as a string literal.
-            ///
-            /// In cases where you absolutely need a label to be determined at runtime,
-            /// you can use [`Box::leak`] to get a `'static` reference.
-            fn as_str(&self) -> &'static str;
-        }
-
-        impl $label_name for $id_name {
-            fn as_label(&self) -> Self {
-                *self
-            }
-            fn type_id(&self) -> ::core::any::TypeId {
-                self.0
-            }
-            fn as_str(&self) -> &'static str {
-                self.1
-            }
-        }
-
-        impl $label_name for &'static str {
-            fn as_str(&self) -> Self {
-                self
-            }
-        }
-    };
-}
