Optimize Date display impl

jhpratt · jhpratt · commit a704128e927c · 2026-02-16T02:33:25.000-05:00
diff --git a/time/src/date.rs b/time/src/date.rs
@@ -2,22 +2,22 @@
 
 #[cfg(feature = "formatting")]
 use alloc::string::String;
+use core::fmt;
+use core::mem::MaybeUninit;
 use core::num::NonZero;
 use core::ops::{Add, AddAssign, Sub, SubAssign};
 use core::time::Duration as StdDuration;
-use core::{cmp, fmt};
 #[cfg(feature = "formatting")]
 use std::io;
 
 use deranged::RangedI32;
 use num_conv::prelude::*;
-use powerfmt::ext::FormatterExt;
-use powerfmt::smart_display::{self, FormatterOptions, Metadata, SmartDisplay};
+use powerfmt::smart_display::{FormatterOptions, Metadata, SmartDisplay};
 
-use crate::ext::DigitCount;
 #[cfg(feature = "formatting")]
 use crate::formatting::Formattable;
 use crate::internal_macros::{const_try, const_try_opt, div_floor, ensure_ranged};
+use crate::num_fmt::{four_to_six_digits, str_from_raw_parts, two_digits_zero_padded};
 #[cfg(feature = "parsing")]
 use crate::parsing::Parsable;
 use crate::unit::*;
@@ -1417,90 +1417,111 @@ impl Date {
 mod private {
     /// Metadata for `Date`.
     #[non_exhaustive]
-    #[derive(Debug, Clone, Copy)]
-    pub struct DateMetadata {
-        /// The width of the year component, including the sign.
-        pub(super) year_width: u8,
-        /// Whether the sign should be displayed.
-        pub(super) display_sign: bool,
-        pub(super) year: i32,
-        pub(super) month: u8,
-        pub(super) day: u8,
-    }
+    #[derive(Debug)]
+    pub struct DateMetadata;
 }
 use private::DateMetadata;
 
+// This no longer needs special handling, as the format is fixed and doesn't require anything
+// advanced. Trait impls can't be deprecated and the info is still useful for other types
+// implementing `SmartDisplay`, so leave it as-is for now.
 impl SmartDisplay for Date {
     type Metadata = DateMetadata;
 
     #[inline]
     fn metadata(&self, _: FormatterOptions) -> Metadata<'_, Self> {
-        let (year, month, day) = self.to_calendar_date();
-
-        // There is a minimum of four digits for any year.
-        let mut year_width = cmp::max(year.unsigned_abs().num_digits(), 4);
-        let display_sign = if !(0..10_000).contains(&year) {
-            // An extra character is required for the sign.
-            year_width += 1;
-            true
-        } else {
-            false
-        };
+        use crate::ext::DigitCount as _;
 
-        let formatted_width = year_width.extend::<usize>()
-            + smart_display::padded_width_of!(
-                "-",
-                u8::from(month) => width(2),
-                "-",
-                day => width(2),
-            );
+        let year_sign_width =
+            if self.year() < 0 || (cfg!(feature = "large-dates") && self.year() >= 10_000) {
+                1
+            } else {
+                0
+            };
+        let year_width = self.year().unsigned_abs().num_digits().clamp(4, 6);
+        let formatted_width = year_sign_width + year_width + 6; // include two dashes and two digits each for month and day
 
-        Metadata::new(
-            formatted_width,
-            self,
-            DateMetadata {
-                year_width,
-                display_sign,
-                year,
-                month: u8::from(month),
-                day,
-            },
-        )
+        Metadata::new(formatted_width as usize, self, DateMetadata)
     }
 
     #[inline]
-    fn fmt_with_metadata(
-        &self,
-        f: &mut fmt::Formatter<'_>,
-        metadata: Metadata<Self>,
-    ) -> fmt::Result {
-        let DateMetadata {
-            year_width,
-            display_sign,
-            year,
-            month,
-            day,
-        } = *metadata;
-        let year_width = year_width.extend();
-
-        if display_sign {
-            f.pad_with_width(
-                metadata.unpadded_width(),
-                format_args!("{year:+0year_width$}-{month:02}-{day:02}"),
-            )
-        } else {
-            f.pad_with_width(
-                metadata.unpadded_width(),
-                format_args!("{year:0year_width$}-{month:02}-{day:02}"),
-            )
-        }
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        fmt::Display::fmt(self, f)
     }
 }
 
 impl fmt::Display for Date {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        SmartDisplay::fmt(self, f)
+        let mut buf = [MaybeUninit::uninit(); 13];
+        let mut idx = 0;
+        let (year, month, day) = self.to_calendar_date();
+
+        // Compute the sign of the integer, if any. Doing this in a branchless manner gives a
+        // significant performance improvement.
+        let neg = year.is_negative() as u8;
+        let pos = (cfg!(feature = "large-dates") && year - 10_000 >= 0) as u8;
+        let sign = b'+' + 2 * neg; // b'-' if `neg` is true, b'+' otherwise
+        // Always write the computed byte, even if it's later overwritten by the first digit of the
+        // year.
+        buf[idx] = MaybeUninit::new(sign);
+        idx += (neg | pos) as usize;
+
+        // Safety: `year.unsigned_abs()` is less than 1,000,000.
+        let [first_two, second_two, third_two] = unsafe { four_to_six_digits(year.unsigned_abs()) };
+        // Safety:
+        // - both `first_two` and `buf` are valid for reads and writes of up to 2 bytes.
+        // - `u8` is 1-aligned, so that is not a concern.
+        // - `first_two` points to static memory, while `buf` is a local variable, so they do not
+        //   overlap.
+        unsafe {
+            first_two
+                .as_ptr()
+                .copy_to_nonoverlapping(buf.as_mut_ptr().add(idx).cast(), first_two.len());
+        }
+        idx += first_two.len();
+        // Safety: See above.
+        unsafe {
+            second_two
+                .as_ptr()
+                .copy_to_nonoverlapping(buf.as_mut_ptr().add(idx).cast(), 2);
+        }
+        idx += 2;
+        // Safety: See above.
+        unsafe {
+            third_two
+                .as_ptr()
+                .copy_to_nonoverlapping(buf.as_mut_ptr().add(idx).cast(), 2);
+        }
+        idx += 2;
+
+        buf[idx] = MaybeUninit::new(b'-');
+        idx += 1;
+
+        // Safety: See above for `copy_to_nonoverlapping`. `two_digits` is valid because `month` is
+        // in the range 1..=12.
+        unsafe {
+            two_digits_zero_padded(u8::from(month))
+                .as_ptr()
+                .copy_to_nonoverlapping(buf.as_mut_ptr().add(idx).cast(), 2);
+        }
+        idx += 2;
+
+        buf[idx] = MaybeUninit::new(b'-');
+        idx += 1;
+
+        // Safety: See above for `copy_to_nonoverlapping`. `two_digits` is valid because `day` is in
+        // the range 1..=31.
+        unsafe {
+            two_digits_zero_padded(day)
+                .as_ptr()
+                .copy_to_nonoverlapping(buf.as_mut_ptr().add(idx).cast(), 2);
+        }
+        idx += 2;
+
+        // Safety: All bytes up to `idx` have been initialized with ASCII characters.
+        let s = unsafe { str_from_raw_parts((&raw const buf).cast(), idx) };
+        f.pad(s)
     }
 }
 
diff --git a/time/src/lib.rs b/time/src/lib.rs
@@ -114,6 +114,7 @@ mod interop;
 #[cfg(feature = "macros")]
 pub mod macros;
 mod month;
+mod num_fmt;
 mod offset_date_time;
 #[cfg(feature = "parsing")]
 pub mod parsing;
diff --git a/time/src/num_fmt.rs b/time/src/num_fmt.rs
@@ -0,0 +1,105 @@
+//! Formatting utilities for numbers.
+//!
+//! These functions are low-level, but are designed to be _extremely_ fast for their designed use
+//! cases. They are `unsafe` to avoid validating input, have strict requirements, and may not return
+//! the most ergonomic types to avoid unnecessary allocations and copying.
+
+use core::{hint, slice};
+
+static ZERO_PADDED_PAIRS: [u8; 200] = *b"0001020304050607080910111213141516171819\
+                                         2021222324252627282930313233343536373839\
+                                         4041424344454647484950515253545556575859\
+                                         6061626364656667686970717273747576777879\
+                                         8081828384858687888990919293949596979899";
+
+static SPACE_PADDED_PAIRS: [u8; 200] = *b" 0 1 2 3 4 5 6 7 8 910111213141516171819\
+                                          2021222324252627282930313233343536373839\
+                                          4041424344454647484950515253545556575859\
+                                          6061626364656667686970717273747576777879\
+                                          8081828384858687888990919293949596979899";
+
+/// Safety:
+///
+/// - `ptr` must be non-null and point to `len` initialized bytes of UTF-8 data.
+/// - `ptr` is valid for (and not mutated during) lifetime `'a`.
+#[inline]
+pub(crate) const unsafe fn str_from_raw_parts<'a>(ptr: *const u8, len: usize) -> &'a str {
+    // Safety: The caller must ensure that `ptr` is valid for `len` bytes and that the bytes are
+    // valid UTF-8. The caller must also ensure that the lifetime `'a` is valid for the returned
+    // string.
+    unsafe { str::from_utf8_unchecked(slice::from_raw_parts(ptr, len)) }
+}
+
+/// Obtain a string of two ASCII digits representing `n`. This includes a leading zero if `n` is
+/// less than 10.
+///
+/// # Safety: `n` must be less than 100.
+#[inline]
+pub(crate) const unsafe fn two_digits_zero_padded(n: u8) -> &'static str {
+    debug_assert!(n < 100);
+
+    // Safety: We're staying within the bounds of the array. The array contains only ASCII
+    // characters, so it's valid UTF-8.
+    unsafe { str_from_raw_parts(ZERO_PADDED_PAIRS.as_ptr().add((n as usize) * 2), 2) }
+}
+
+/// Obtain a string of two ASCII digits representing `n`. This includes a leading space if `n` is
+/// less than 10.
+///
+/// # Safety: `n` must be less than 100.
+#[expect(dead_code, reason = "likely to be used in the future")]
+#[inline]
+pub(crate) const unsafe fn two_digits_space_padded(n: u8) -> &'static str {
+    debug_assert!(n < 100);
+
+    // Safety: We're staying within the bounds of the array. The array contains only ASCII
+    // characters, so it's valid UTF-8.
+    unsafe { str_from_raw_parts(SPACE_PADDED_PAIRS.as_ptr().add((n as usize) * 2), 2) }
+}
+
+/// Obtain two strings of two ASCII digits each representing `n`. The first string is the most
+/// significant. Leading zeros are included if the number has fewer than 4 digits.
+///
+/// # Safety: `n` must be less than 10,000.
+#[inline]
+pub(crate) const unsafe fn four_digits(n: u16) -> [&'static str; 2] {
+    debug_assert!(n < 10_000);
+
+    const EXP: u32 = 19; // 19 is faster or equal to 12 even for 3 digits.
+    const SIG: u32 = (1 << EXP) / 100 + 1;
+
+    let high = (n as u32 * SIG) >> EXP; // value / 100
+    let low = n as u32 - high * 100;
+
+    // Safety: We're staying within the bounds of the array.
+    unsafe {
+        [
+            two_digits_zero_padded(high as u8),
+            two_digits_zero_padded(low as u8),
+        ]
+    }
+}
+
+/// Obtain three strings which together represent `n`. The first string is the most significant.
+/// Leading zeros are included if the number has fewer than 4 digits. The first string will be empty
+/// if `n` is less than 10,000.
+///
+/// # Safety: `n` must be less than 1,000,000.
+#[inline]
+pub(crate) const unsafe fn four_to_six_digits(n: u32) -> [&'static str; 3] {
+    debug_assert!(n < 1_000_000);
+    // Safety: The caller must ensure that this is true.
+    unsafe { hint::assert_unchecked(n < 1_000_000) };
+
+    let (first_two, remaining) = (n / 10_000, n % 10_000);
+
+    let size = 2 - (first_two < 10) as usize - (first_two == 0) as usize;
+    let offset = first_two as usize * 2 + 2 - size;
+
+    // Safety: `offset` is within the bounds of the array. The array contains only ASCII characters,
+    // so it's valid UTF-8.
+    let first_two = unsafe { str_from_raw_parts(ZERO_PADDED_PAIRS.as_ptr().add(offset), size) };
+    // Safety: `remaining` is guaranteed to be less than 10,000 due to the modulus above.
+    let [second_two, last_two] = unsafe { four_digits(remaining as u16) };
+    [first_two, second_two, last_two]
+}
diff --git a/time/src/utc_offset.rs b/time/src/utc_offset.rs
@@ -18,6 +18,7 @@ use crate::error;
 #[cfg(feature = "formatting")]
 use crate::formatting::Formattable;
 use crate::internal_macros::ensure_ranged;
+use crate::num_fmt::two_digits_zero_padded;
 #[cfg(feature = "parsing")]
 use crate::parsing::Parsable;
 #[cfg(feature = "local-offset")]
@@ -534,22 +535,6 @@ impl SmartDisplay for UtcOffset {
     }
 }
 
-/// Obtain a pointer to the two ASCII digits representing `n`.
-///
-/// # Safety: `n` must be less than 100.
-#[inline]
-unsafe fn digits_ptr(n: u8) -> *const u8 {
-    const DIGIT_PAIRS: [u8; 200] = *b"0001020304050607080910111213141516171819\
-                                      2021222324252627282930313233343536373839\
-                                      4041424344454647484950515253545556575859\
-                                      6061626364656667686970717273747576777879\
-                                      8081828384858687888990919293949596979899";
-
-    debug_assert!(n < 100);
-    // Safety: We're staying within the bounds of the array.
-    unsafe { DIGIT_PAIRS.as_ptr().add((n as usize) * 2) }
-}
-
 impl fmt::Display for UtcOffset {
     #[inline]
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -563,9 +548,15 @@ impl fmt::Display for UtcOffset {
         // Safety: `hours`, `minutes` and `seconds` are all less than 100. Both the source and
         // destination are valid for two bytes, aligned, and do not overlap.
         unsafe {
-            digits_ptr(hours).copy_to_nonoverlapping(buf.as_mut_ptr().add(1), 2);
-            digits_ptr(minutes).copy_to_nonoverlapping(buf.as_mut_ptr().add(4), 2);
-            digits_ptr(seconds).copy_to_nonoverlapping(buf.as_mut_ptr().add(7), 2);
+            two_digits_zero_padded(hours)
+                .as_ptr()
+                .copy_to_nonoverlapping(buf.as_mut_ptr().add(1), 2);
+            two_digits_zero_padded(minutes)
+                .as_ptr()
+                .copy_to_nonoverlapping(buf.as_mut_ptr().add(4), 2);
+            two_digits_zero_padded(seconds)
+                .as_ptr()
+                .copy_to_nonoverlapping(buf.as_mut_ptr().add(7), 2);
         }
 
         // Safety: All bytes are ASCII, which is a subset of UTF-8.
