use a fn pointer for formatting

Author: joseph-gio

benches/benches/bevy_ecs/scheduling/schedule.rs

@@ -64,18 +64,18 @@ pub fn build_schedule(criterion: &mut Criterion) {
     // Use multiple different kinds of label to ensure that dynamic dispatch
     // doesn't somehow get optimized away.
     #[derive(Debug, Clone, Copy)]
-    struct NumLabel(u16);
+    struct NumLabel(u64);
     #[derive(Debug, Clone, Copy, SystemLabel)]
     struct DummyLabel;
 
     impl SystemLabel for NumLabel {
         #[inline]
-        fn data(&self) -> u16 {
+        fn data(&self) -> u64 {
             self.0
         }
-        fn as_str(&self) -> &'static str {
-            let s = self.0.to_string();
-            Box::leak(s.into_boxed_str())
+        #[inline]
+        fn dbg(&self) -> fn(u64, &mut std::fmt::Formatter) -> std::fmt::Result {
+            |x, f| write!(f, "NumLabel({x})")
         }
     }
 
@@ -89,7 +89,7 @@ pub fn build_schedule(criterion: &mut Criterion) {
     // Also, we are performing the `as_label` operation outside of the loop since that
     // requires an allocation and a leak. This is not something that would be necessary in a
     // real scenario, just a contrivance for the benchmark.
-    let labels: Vec<_> = (0..1000).map(|i| NumLabel(i as u16).as_label()).collect();
+    let labels: Vec<_> = (0..1000).map(|i| NumLabel(i).as_label()).collect();
 
     // Benchmark graphs of different sizes.
     for graph_size in [100, 500, 1000] {

crates/bevy_app/src/app.rs

@@ -901,7 +901,7 @@ 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.as_label()),
         }
     }
 
@@ -923,7 +923,7 @@ 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.as_label()),
         }
     }
 

crates/bevy_ecs/src/schedule/state.rs

@@ -52,23 +52,27 @@ enum ScheduledOperation<T: StateData> {
     Push(T),
 }
 
-#[derive(Debug, PartialEq, Eq, Clone, Hash)]
-struct DriverLabel(TypeId, &'static str);
+struct DriverLabel(
+    TypeId,
+    fn(u64, &mut std::fmt::Formatter) -> std::fmt::Result,
+);
 impl RunCriteriaLabel for DriverLabel {
     fn type_id(&self) -> core::any::TypeId {
         self.0
     }
-    fn data(&self) -> u16 {
+    fn data(&self) -> u64 {
         0
     }
-    fn as_str(&self) -> &'static str {
+    fn dbg(&self) -> fn(u64, &mut std::fmt::Formatter) -> std::fmt::Result {
         self.1
     }
 }
 
 impl DriverLabel {
     fn of<T: 'static>() -> Self {
-        Self(TypeId::of::<T>(), std::any::type_name::<T>())
+        Self(TypeId::of::<T>(), |_, f| {
+            write!(f, "{}", std::any::type_name::<T>())
+        })
     }
 }
 

crates/bevy_ecs/src/system/function_system.rs

@@ -12,7 +12,11 @@ use crate::{
     world::{World, WorldId},
 };
 use bevy_ecs_macros::all_tuples;
-use std::{borrow::Cow, fmt::Debug, marker::PhantomData};
+use std::{
+    borrow::Cow,
+    fmt::{self, Debug},
+    marker::PhantomData,
+};
 
 /// The metadata of a [`System`].
 #[derive(Clone)]
@@ -454,17 +458,17 @@ pub struct SystemTypeIdLabel<T: 'static>(PhantomData<fn() -> T>);
 
 impl<T: 'static> SystemLabel for SystemTypeIdLabel<T> {
     #[inline]
-    fn as_str(&self) -> &'static str {
-        std::any::type_name::<T>()
+    fn data(&self) -> u64 {
+        0
     }
     #[inline]
-    fn data(&self) -> u16 {
-        0
+    fn dbg(&self) -> fn(u64, &mut fmt::Formatter) -> fmt::Result {
+        |_, f| write!(f, "{}", std::any::type_name::<T>())
     }
 }
 
 impl<T> Debug for SystemTypeIdLabel<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("SystemTypeIdLabel")
             .field(&std::any::type_name::<T>())
             .finish()

crates/bevy_macro_utils/src/lib.rs

@@ -161,7 +161,7 @@ pub fn derive_label(
             if matches!(d.fields, syn::Fields::Unit) || ignore_fields {
                 let lit = ident.to_string();
                 let data = quote! { 0 };
-                let as_str = quote! { #lit };
+                let as_str = quote! { |_, f| write!(f, #lit) };
                 (data, as_str)
             } else {
                 let err_msg = format!("Labels cannot contain data, unless explicitly ignored with `#[{attr_name}(ignore_fields)]`");
@@ -191,12 +191,11 @@ pub fn derive_label(
                     let mut path = syn::Path::from(ident.clone());
                     path.segments.push(v.ident.clone().into());
 
-                    // hopefully no one has more than 60 thousand variants
-                    let i = i as u16;
+                    let i = i as u64;
                     data_arms.push(quote! { #path { .. } => #i });
 
                     let lit = format!("{ident}::{}", v.ident.clone());
-                    str_arms.push(quote! { #path { .. } => #lit });
+                    str_arms.push(quote! { #path { .. } => { |_, f| write!(f, #lit) } });
                 } else {
                     let err_msg = format!("Label variants cannot contain data, unless explicitly ignored with `#[{attr_name}(ignore_fields)]`");
                     return quote_spanned! {
@@ -229,10 +228,10 @@ pub fn derive_label(
     (quote! {
         impl #impl_generics #trait_path for #ident #ty_generics #where_clause {
             #[inline]
-            fn data(&self) -> u16 {
+            fn data(&self) -> u64 {
                 #data
             }
-            fn as_str(&self) -> &'static str {
+            fn dbg(&self) -> fn(u64, &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
                 #as_str
             }
         }

crates/bevy_utils/src/label.rs

@@ -3,7 +3,6 @@
 use std::{
     any::Any,
     hash::{Hash, Hasher},
-    marker::PhantomData,
 };
 
 pub trait DynEq: Any {
@@ -48,79 +47,6 @@ where
     }
 }
 
-#[doc(hidden)]
-/// A string slice, stuffed with a payload of data `16` bits long.
-/// This means that the maximum length of the string is `2^(size-16)`,
-/// where `size` is either 32 or 64 depending on your computer.
-#[derive(Clone, Copy)]
-pub struct StuffedStr<'a> {
-    ptr: *const u8,
-    marker: PhantomData<&'a str>,
-
-    /// lower 16 bits stores the data,
-    /// upper 48 or 16 bits stores the length of the string.
-    /// This layout optimizes for calling `.data()`
-    meta: usize,
-}
-
-unsafe impl<'a> Send for StuffedStr<'a> {}
-unsafe impl<'a> Sync for StuffedStr<'a> {}
-
-/// Truncates the passed string slice to be of length `len`, or shorter.
-#[cold]
-#[inline(never)]
-fn truncate(str: &str, mut len: usize) -> &str {
-    // Just keep lowering the expected length until we hit a unicode boundary.
-    // This is messy but if the string is long enough that we need to truncate it,
-    // it's too long for anyone to notice what the end looks like.
-    loop {
-        if let Some(str) = str.get(..len) {
-            break str;
-        }
-        // In practice this won't be able to underflow, since  `str.get(..0)` will always succeed.
-        len -= 1;
-    }
-}
-
-impl<'a> StuffedStr<'a> {
-    const DATA_MASK: usize = !Self::LEN_MASK;
-    const LEN_MASK: usize = !0 << 16;
-
-    pub fn new(mut str: &'a str, data: u16) -> Self {
-        // Make sure there's enough room to store the data.
-        if str.len().leading_zeros() < 16 {
-            str = truncate(str, Self::LEN_MASK >> 16);
-            debug_assert!(str.len().leading_zeros() < 16);
-        }
-        let ptr = str.as_ptr();
-        let meta = data as usize | str.len() << 16;
-        Self {
-            ptr,
-            marker: PhantomData,
-            meta,
-        }
-    }
-
-    #[inline]
-    fn len(&self) -> usize {
-        self.meta >> 16
-    }
-    #[inline]
-    pub fn data(&self) -> u16 {
-        let data = self.meta & Self::DATA_MASK;
-        data as u16
-    }
-    #[inline]
-    pub fn as_str(&self) -> &'a str {
-        // SAFETY: this instance was constructed from a string slice of length `len`, and lifetime `'a`.
-        // It is sound to convert it back to a slice.
-        unsafe {
-            let slice = std::slice::from_raw_parts(self.ptr, self.len());
-            std::str::from_utf8_unchecked(slice)
-        }
-    }
-}
-
 /// Macro to define a new label trait
 ///
 /// # Example
@@ -145,11 +71,12 @@ macro_rules! define_label {
     ) => {
         $(#[$id_attr])*
         #[derive(Clone, Copy)]
-        pub struct $id_name(::core::any::TypeId, $crate::label::StuffedStr<'static>);
+        pub struct $id_name(::std::any::TypeId, u64, fn(u64, &mut ::std::fmt::Formatter) -> ::std::fmt::Result);
 
-        impl ::core::fmt::Debug for $id_name {
-            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
-                write!(f, "{}", self.as_str())
+        impl ::std::fmt::Debug for $id_name {
+            fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                let data = self.data();
+                self.dbg()(data, f)
             }
         }
 
@@ -159,22 +86,17 @@ macro_rules! define_label {
             fn as_label(&self) -> $id_name {
                 let ty = self.type_id();
                 let data = self.data();
-                let text = self.as_str();
-                let stuffed = $crate::label::StuffedStr::new(text, data);
-                $id_name(ty, stuffed)
+                let dbg = self.dbg();
+                $id_name(ty, data, dbg)
             }
             /// Returns the [`TypeId`] used to differentiate labels.
             #[inline]
-            fn type_id(&self) -> ::core::any::TypeId {
-                ::core::any::TypeId::of::<Self>()
+            fn type_id(&self) -> ::std::any::TypeId {
+                ::std::any::TypeId::of::<Self>()
             }
             /// Returns a number used to distinguish different labels of the same type.
-            fn data(&self) -> u16;
-            /// 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;
+            fn data(&self) -> u64;
+            fn dbg(&self) -> fn(u64, &mut ::std::fmt::Formatter) -> ::std::fmt::Result;
         }
 
         impl $label_name for $id_name {
@@ -183,15 +105,16 @@ macro_rules! define_label {
                 *self
             }
             #[inline]
-            fn type_id(&self) -> ::core::any::TypeId {
+            fn type_id(&self) -> ::std::any::TypeId {
                 self.0
             }
             #[inline]
-            fn data(&self) -> u16 {
-                self.1.data()
+            fn data(&self) -> u64 {
+                self.1
             }
-            fn as_str(&self) -> &'static str {
-                self.1.as_str()
+            #[inline]
+            fn dbg(&self) -> fn(u64, &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                self.2
             }
         }
 
@@ -212,18 +135,3 @@ macro_rules! define_label {
         }
     };
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_truncate() {
-        // Slice at byte '4'
-        assert_eq!(truncate("Hello, World!", 4), "Hell");
-
-        // Slicing off at byte '3' would be inside of the emoji,
-        // so instead the whole emoji gets sliced off.
-        assert_eq!(truncate("x😂", 3), "x");
-    }
-}