Optimize ToString implementation for integers

Author: GuillaumeGomez

library/alloc/src/string.rs

@@ -2783,7 +2783,51 @@ impl SpecToString for bool {
     }
 }
 
+macro_rules! impl_to_string {
+    ($($signed:ident, $unsigned:ident,)*) => {
+        $(
+        #[cfg(not(no_global_oom_handling))]
+        #[cfg(not(feature = "optimize_for_size"))]
+        impl SpecToString for $signed {
+            #[inline]
+            fn spec_to_string(&self) -> String {
+                const SIZE: usize = $signed::MAX.ilog(10) as usize + 1;
+                let mut buf = [core::mem::MaybeUninit::<u8>::uninit(); SIZE];
+                // Only difference between signed and unsigned are these 3 lines.
+                let mut out = String::with_capacity(SIZE + 1);
+                if *self < 0 {
+                    out.push('-');
+                }
+
+                out.push_str(self.unsigned_abs()._fmt(&mut buf, SIZE));
+                out
+            }
+        }
+        #[cfg(not(no_global_oom_handling))]
+        #[cfg(not(feature = "optimize_for_size"))]
+        impl SpecToString for $unsigned {
+            #[inline]
+            fn spec_to_string(&self) -> String {
+                const SIZE: usize = $unsigned::MAX.ilog(10) as usize + 1;
+                let mut buf = [core::mem::MaybeUninit::<u8>::uninit(); SIZE];
+
+                self._fmt(&mut buf, SIZE).to_string()
+            }
+        }
+        )*
+    }
+}
+
+impl_to_string! {
+    i8, u8,
+    i16, u16,
+    i32, u32,
+    i64, u64,
+    isize, usize,
+}
+
 #[cfg(not(no_global_oom_handling))]
+#[cfg(feature = "optimize_for_size")]
 impl SpecToString for u8 {
     #[inline]
     fn spec_to_string(&self) -> String {
@@ -2803,6 +2847,7 @@ impl SpecToString for u8 {
 }
 
 #[cfg(not(no_global_oom_handling))]
+#[cfg(feature = "optimize_for_size")]
 impl SpecToString for i8 {
     #[inline]
     fn spec_to_string(&self) -> String {

library/core/src/fmt/num.rs

@@ -207,7 +207,10 @@ macro_rules! impl_Display {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                 #[cfg(not(feature = "optimize_for_size"))]
                 {
-                    self._fmt(true, f)
+                    const SIZE: usize = $unsigned::MAX.ilog(10) as usize + 1;
+                    let mut buf = [MaybeUninit::<u8>::uninit(); SIZE];
+
+                    f.pad_integral(true, "", self._fmt(&mut buf, SIZE))
                 }
                 #[cfg(feature = "optimize_for_size")]
                 {
@@ -221,7 +224,10 @@ macro_rules! impl_Display {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                 #[cfg(not(feature = "optimize_for_size"))]
                 {
-                    return self.unsigned_abs()._fmt(*self >= 0, f);
+                    const SIZE: usize = $signed::MAX.ilog(10) as usize + 1;
+                    let mut buf = [MaybeUninit::<u8>::uninit(); SIZE];
+
+                    f.pad_integral(*self >= 0, "", self.unsigned_abs()._fmt(&mut buf, SIZE))
                 }
                 #[cfg(feature = "optimize_for_size")]
                 {
@@ -232,11 +238,14 @@ macro_rules! impl_Display {
 
         #[cfg(not(feature = "optimize_for_size"))]
         impl $unsigned {
-            fn _fmt(mut self, is_nonnegative: bool, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                const SIZE: usize = $unsigned::MAX.ilog(10) as usize + 1;
-                let mut buf = [MaybeUninit::<u8>::uninit(); SIZE];
-                let mut curr = SIZE;
-                let buf_ptr = MaybeUninit::slice_as_mut_ptr(&mut buf);
+            #[doc(hidden)]
+            #[unstable(
+                feature = "fmt_internals",
+                reason = "internal routines only exposed for testing",
+                issue = "none"
+            )]
+            pub fn _fmt<'a>(mut self, buf: &'a mut [MaybeUninit::<u8>], mut curr: usize) -> &'a str {
+                let buf_ptr = MaybeUninit::slice_as_mut_ptr(buf);
                 let lut_ptr = DEC_DIGITS_LUT.as_ptr();
 
                 // SAFETY: Since `d1` and `d2` are always less than or equal to `198`, we
@@ -296,11 +305,10 @@ macro_rules! impl_Display {
 
                 // SAFETY: `curr` > 0 (since we made `buf` large enough), and all the chars are valid
                 // UTF-8 since `DEC_DIGITS_LUT` is
-                let buf_slice = unsafe {
+                unsafe {
                     str::from_utf8_unchecked(
                         slice::from_raw_parts(buf_ptr.add(curr), buf.len() - curr))
-                };
-                f.pad_integral(is_nonnegative, "", buf_slice)
+                }
             }
         })*