Implement _fmt on u128

Author: GuillaumeGomez

library/core/src/fmt/num.rs

@@ -566,7 +566,7 @@ mod imp {
 impl_Exp!(i128, u128 as u128 via to_u128 named exp_u128);
 
 /// Helper function for writing a u64 into `buf` going from last to first, with `curr`.
-fn parse_u64_into<const N: usize>(mut n: u64, buf: &mut [MaybeUninit<u8>; N], curr: &mut usize) {
+fn parse_u64_into(mut n: u64, buf: &mut [MaybeUninit<u8>], curr: &mut usize) {
     let buf_ptr = MaybeUninit::slice_as_mut_ptr(buf);
     let lut_ptr = DEC_DIGITS_LUT.as_ptr();
     assert!(*curr > 19);
@@ -655,77 +655,90 @@ fn parse_u64_into<const N: usize>(mut n: u64, buf: &mut [MaybeUninit<u8>; N], cu
 #[stable(feature = "rust1", since = "1.0.0")]
 impl fmt::Display for u128 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt_u128(*self, true, f)
+        const MAX_DEC_N: usize = u128::MAX.ilog(10) as usize + 1;
+        let mut buf = [MaybeUninit::<u8>::uninit(); MAX_DEC_N];
+
+        f.pad_integral(true, "", self._fmt(&mut buf))
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
 impl fmt::Display for i128 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // This is not a typo, we use the maximum number of digits of `u128`, hence why we use
+        // `u128::MAX`.
+        const MAX_DEC_N: usize = u128::MAX.ilog(10) as usize + 1;
+        let mut buf = [MaybeUninit::<u8>::uninit(); MAX_DEC_N];
+
         let is_nonnegative = *self >= 0;
         let n = if is_nonnegative {
             self.to_u128()
         } else {
             // convert the negative num to positive by summing 1 to its 2s complement
             (!self.to_u128()).wrapping_add(1)
         };
-        fmt_u128(n, is_nonnegative, f)
+        f.pad_integral(is_nonnegative, "", n._fmt(&mut buf))
     }
 }
 
-/// Specialized optimization for u128. Instead of taking two items at a time, it splits
-/// into at most 2 u64s, and then chunks by 10e16, 10e8, 10e4, 10e2, and then 10e1.
-/// It also has to handle 1 last item, as 10^40 > 2^128 > 10^39, whereas
-/// 10^20 > 2^64 > 10^19.
-fn fmt_u128(n: u128, is_nonnegative: bool, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-    const MAX_DEC_N: usize = u128::MAX.ilog(10) as usize + 1;
-    let mut buf = [MaybeUninit::<u8>::uninit(); MAX_DEC_N];
-    let mut curr = buf.len();
-
-    let (n, rem) = udiv_1e19(n);
-    parse_u64_into(rem, &mut buf, &mut curr);
-
-    if n != 0 {
-        // 0 pad up to point
-        let target = buf.len() - 19;
-        // SAFETY: Guaranteed that we wrote at most 19 bytes, and there must be space
-        // remaining since it has length 39
-        unsafe {
-            ptr::write_bytes(
-                MaybeUninit::slice_as_mut_ptr(&mut buf).add(target),
-                b'0',
-                curr - target,
-            );
-        }
-        curr = target;
+impl u128 {
+    /// Specialized optimization for u128. Instead of taking two items at a time, it splits
+    /// into at most 2 u64s, and then chunks by 10e16, 10e8, 10e4, 10e2, and then 10e1.
+    /// It also has to handle 1 last item, as 10^40 > 2^128 > 10^39, whereas
+    /// 10^20 > 2^64 > 10^19.
+    #[doc(hidden)]
+    #[unstable(
+        feature = "fmt_internals",
+        reason = "specialized method meant to only be used by `SpecToString` implementation",
+        issue = "none"
+    )]
+    pub fn _fmt<'a>(self, buf: &'a mut [MaybeUninit<u8>]) -> &'a str {
+        let mut curr = buf.len();
+
+        let (n, rem) = udiv_1e19(self);
+        parse_u64_into(rem, buf, &mut curr);
 
-        let (n, rem) = udiv_1e19(n);
-        parse_u64_into(rem, &mut buf, &mut curr);
-        // Should this following branch be annotated with unlikely?
         if n != 0 {
-            let target = buf.len() - 38;
-            // The raw `buf_ptr` pointer is only valid until `buf` is used the next time,
-            // buf `buf` is not used in this scope so we are good.
-            let buf_ptr = MaybeUninit::slice_as_mut_ptr(&mut buf);
-            // SAFETY: At this point we wrote at most 38 bytes, pad up to that point,
-            // There can only be at most 1 digit remaining.
+            // 0 pad up to point
+            let target = buf.len() - 19;
+            // SAFETY: Guaranteed that we wrote at most 19 bytes, and there must be space
+            // remaining since it has length 39
             unsafe {
-                ptr::write_bytes(buf_ptr.add(target), b'0', curr - target);
-                curr = target - 1;
-                *buf_ptr.add(curr) = (n as u8) + b'0';
+                ptr::write_bytes(
+                    MaybeUninit::slice_as_mut_ptr(buf).add(target),
+                    b'0',
+                    curr - target,
+                );
+            }
+            curr = target;
+
+            let (n, rem) = udiv_1e19(n);
+            parse_u64_into(rem, buf, &mut curr);
+            // Should this following branch be annotated with unlikely?
+            if n != 0 {
+                let target = buf.len() - 38;
+                // The raw `buf_ptr` pointer is only valid until `buf` is used the next time,
+                // buf `buf` is not used in this scope so we are good.
+                let buf_ptr = MaybeUninit::slice_as_mut_ptr(buf);
+                // SAFETY: At this point we wrote at most 38 bytes, pad up to that point,
+                // There can only be at most 1 digit remaining.
+                unsafe {
+                    ptr::write_bytes(buf_ptr.add(target), b'0', curr - target);
+                    curr = target - 1;
+                    *buf_ptr.add(curr) = (n as u8) + b'0';
+                }
             }
         }
-    }
 
-    // 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 {
-        str::from_utf8_unchecked(slice::from_raw_parts(
-            MaybeUninit::slice_as_mut_ptr(&mut buf).add(curr),
-            buf.len() - curr,
-        ))
-    };
-    f.pad_integral(is_nonnegative, "", buf_slice)
+        // SAFETY: `curr` > 0 (since we made `buf` large enough), and all the chars are valid
+        // UTF-8 since `DEC_DIGITS_LUT` is
+        unsafe {
+            str::from_utf8_unchecked(slice::from_raw_parts(
+                MaybeUninit::slice_as_mut_ptr(buf).add(curr),
+                buf.len() - curr,
+            ))
+        }
+    }
 }
 
 /// Partition of `n` into n > 1e19 and rem <= 1e19