Merge remote-tracking branch 'origin/master'

Expose some internals & make const
Ignore cast_possible_wrap pedantic clippy lint
2024-05-20 18:59:45 -04:00 · 2024-05-20 18:58:40 -04:00 · 2024-04-19 20:42:48 -07:00 · 2024-04-19 20:41:43 -07:00 · 2024-04-08 11:52:12 -07:00 · 2024-03-25 23:00:42 -07:00
4 changed files with 100 additions and 73 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -69,7 +69,7 @@ jobs:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@miri
      - run: cargo miri setup
-      - run: cargo miri test --all-targets  # exclude doctests https://github.com/rust-lang/miri/issues/3404
+      - run: cargo miri test
        env:
          MIRIFLAGS: -Zmiri-strict-provenance

@ -102,6 +102,7 @@ jobs:
    timeout-minutes: 45
    steps:
      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
      - uses: dtolnay/install@cargo-outdated
      - run: cargo outdated --workspace --exit-code 1
      - run: cargo outdated --manifest-path fuzz/Cargo.toml --exit-code 1
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,6 +1,6 @@
 [package]
 name = "itoa"
-version = "1.0.10"
+version = "1.0.11"
 authors = ["David Tolnay <dtolnay@gmail.com>"]
 categories = ["value-formatting", "no-std", "no-std::no-alloc"]
 description = "Fast integer primitive to string conversion"
--- a/src/lib.rs
+++ b/src/lib.rs
@ -30,16 +30,23 @@
 //!
 //! ![performance](https://raw.githubusercontent.com/dtolnay/itoa/master/performance.png)

-#![doc(html_root_url = "https://docs.rs/itoa/1.0.10")]
+#![doc(html_root_url = "https://docs.rs/itoa/1.0.11")]
 #![no_std]
 #![allow(
    clippy::cast_lossless,
    clippy::cast_possible_truncation,
+    clippy::cast_possible_wrap,
+    clippy::cast_sign_loss,
    clippy::expl_impl_clone_on_copy,
    clippy::must_use_candidate,
    clippy::needless_doctest_main,
    clippy::unreadable_literal
 )]
+#![feature(const_intrinsic_copy)]
+#![feature(const_mut_refs)]
+#![feature(const_ptr_write)]
+#![feature(const_trait_impl)]
+#![feature(effects)]

 mod udiv128;

@ -84,7 +91,7 @@ impl Buffer {
    /// for efficiency.
    #[inline]
    #[cfg_attr(feature = "no-panic", no_panic)]
-    pub fn new() -> Buffer {
+    pub const fn new() -> Buffer {
        let bytes = [MaybeUninit::<u8>::uninit(); I128_MAX_LEN];
        Buffer { bytes }
    }
@ -92,10 +99,10 @@ impl Buffer {
    /// Print an integer into this buffer and return a reference to its string
    /// representation within the buffer.
    #[cfg_attr(feature = "no-panic", no_panic)]
-    pub fn format<I: Integer>(&mut self, i: I) -> &str {
+    pub const fn format<I: ~const Integer>(&mut self, i: I) -> &str {
        i.write(unsafe {
            &mut *(&mut self.bytes as *mut [MaybeUninit<u8>; I128_MAX_LEN]
-                as *mut <I as private::Sealed>::Buffer)
+                as *mut I::Buffer)
        })
    }
 }
@ -103,13 +110,18 @@ impl Buffer {
 /// An integer that can be written into an [`itoa::Buffer`][Buffer].
 ///
 /// This trait is sealed and cannot be implemented for types outside of itoa.
-pub trait Integer: private::Sealed {}
+#[const_trait]
+pub trait Integer: private::Sealed {
+    #[doc(hidden)]
+    type Buffer: 'static;
+
+    #[doc(hidden)]
+    fn write(self, buf: &mut Self::Buffer) -> &str;
+}

 // Seal to prevent downstream implementations of the Integer trait.
 mod private {
    pub trait Sealed: Copy {
-        type Buffer: 'static;
-        fn write(self, buf: &mut Self::Buffer) -> &str;
    }
 }

@ -124,9 +136,7 @@ const DEC_DIGITS_LUT: &[u8] = b"\
 // https://github.com/rust-lang/rust/blob/b8214dc6c6fc20d0a660fb5700dca9ebf51ebe89/src/libcore/fmt/num.rs#L188-L266
 macro_rules! impl_Integer {
    ($($max_len:expr => $t:ident),* as $conv_fn:ident) => {$(
-        impl Integer for $t {}
-
-        impl private::Sealed for $t {
+        impl const Integer for $t {
            type Buffer = [MaybeUninit<u8>; $max_len];

            #[allow(unused_comparisons)]
@ -137,52 +147,60 @@ macro_rules! impl_Integer {
                let mut n = if is_nonnegative {
                    self as $conv_fn
                } else {
-                    // convert the negative num to positive by summing 1 to it's 2 complement
+                    // Convert negative number to positive by summing 1 to its two's complement.
                    (!(self as $conv_fn)).wrapping_add(1)
                };
                let mut curr = buf.len() as isize;
                let buf_ptr = buf.as_mut_ptr() as *mut u8;
                let lut_ptr = DEC_DIGITS_LUT.as_ptr();

-                unsafe {
-                    // need at least 16 bits for the 4-characters-at-a-time to work.
-                    if mem::size_of::<$t>() >= 2 {
-                        // eagerly decode 4 characters at a time
-                        while n >= 10000 {
-                            let rem = (n % 10000) as isize;
-                            n /= 10000;
+                // Need at least 16 bits for the 4-digits-at-a-time to work.
+                if mem::size_of::<$t>() >= 2 {
+                    // Eagerly decode 4 digits at a time.
+                    while n >= 10000 {
+                        let rem = (n % 10000) as isize;
+                        n /= 10000;

-                            let d1 = (rem / 100) << 1;
-                            let d2 = (rem % 100) << 1;
-                            curr -= 4;
+                        let d1 = (rem / 100) << 1;
+                        let d2 = (rem % 100) << 1;
+                        curr -= 4;
+                        unsafe {
                            ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
                            ptr::copy_nonoverlapping(lut_ptr.offset(d2), buf_ptr.offset(curr + 2), 2);
                        }
                    }
+                }

-                    // if we reach here numbers are <= 9999, so at most 4 chars long
-                    let mut n = n as isize; // possibly reduce 64bit math
+                // If we reach here, numbers are <=9999 so at most 4 digits long.
+                let mut n = n as isize; // Possibly reduce 64-bit math.

-                    // decode 2 more chars, if > 2 chars
-                    if n >= 100 {
-                        let d1 = (n % 100) << 1;
-                        n /= 100;
-                        curr -= 2;
+                // Decode 2 more digits, if >2 digits.
+                if n >= 100 {
+                    let d1 = (n % 100) << 1;
+                    n /= 100;
+                    curr -= 2;
+                    unsafe {
                        ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
                    }
+                }

-                    // decode last 1 or 2 chars
-                    if n < 10 {
-                        curr -= 1;
+                // Decode last 1 or 2 digits.
+                if n < 10 {
+                    curr -= 1;
+                    unsafe {
                        *buf_ptr.offset(curr) = (n as u8) + b'0';
-                    } else {
-                        let d1 = n << 1;
-                        curr -= 2;
+                    }
+                } else {
+                    let d1 = n << 1;
+                    curr -= 2;
+                    unsafe {
                        ptr::copy_nonoverlapping(lut_ptr.offset(d1), buf_ptr.offset(curr), 2);
                    }
+                }

-                    if !is_nonnegative {
-                        curr -= 1;
+                if !is_nonnegative {
+                    curr -= 1;
+                    unsafe {
                        *buf_ptr.offset(curr) = b'-';
                    }
                }
@ -192,6 +210,8 @@ macro_rules! impl_Integer {
                unsafe { str::from_utf8_unchecked(bytes) }
            }
        }
+
+        impl private::Sealed for $t {}
    )*};
 }

@ -226,9 +246,7 @@ impl_Integer!(I64_MAX_LEN => isize, U64_MAX_LEN => usize as u64);

 macro_rules! impl_Integer128 {
    ($($max_len:expr => $t:ident),*) => {$(
-        impl Integer for $t {}
-
-        impl private::Sealed for $t {
+        impl const Integer for $t {
            type Buffer = [MaybeUninit<u8>; $max_len];

            #[allow(unused_comparisons)]
@ -239,53 +257,61 @@ macro_rules! impl_Integer128 {
                let n = if is_nonnegative {
                    self as u128
                } else {
-                    // convert the negative num to positive by summing 1 to it's 2 complement
+                    // Convert negative number to positive by summing 1 to its two's complement.
                    (!(self as u128)).wrapping_add(1)
                };
                let mut curr = buf.len() as isize;
                let buf_ptr = buf.as_mut_ptr() as *mut u8;

-                unsafe {
-                    // Divide by 10^19 which is the highest power less than 2^64.
+                // Divide by 10^19 which is the highest power less than 2^64.
+                let (n, rem) = udiv128::udivmod_1e19(n);
+                let buf1 = unsafe { buf_ptr.offset(curr - U64_MAX_LEN as isize) as *mut [MaybeUninit<u8>; U64_MAX_LEN] };
+                curr -= rem.write(unsafe { &mut *buf1 }).len() as isize;
+
+                if n != 0 {
+                    // Memset the base10 leading zeros of rem.
+                    let target = buf.len() as isize - 19;
+                    unsafe {
+                        ptr::write_bytes(buf_ptr.offset(target), b'0', (curr - target) as usize);
+                    }
+                    curr = target;
+
+                    // Divide by 10^19 again.
                    let (n, rem) = udiv128::udivmod_1e19(n);
-                    let buf1 = buf_ptr.offset(curr - U64_MAX_LEN as isize) as *mut [MaybeUninit<u8>; U64_MAX_LEN];
-                    curr -= rem.write(&mut *buf1).len() as isize;
+                    let buf2 = unsafe { buf_ptr.offset(curr - U64_MAX_LEN as isize) as *mut [MaybeUninit<u8>; U64_MAX_LEN] };
+                    curr -= rem.write(unsafe { &mut *buf2 }).len() as isize;

                    if n != 0 {
-                        // Memset the base10 leading zeros of rem.
-                        let target = buf.len() as isize - 19;
-                        ptr::write_bytes(buf_ptr.offset(target), b'0', (curr - target) as usize);
+                        // Memset the leading zeros.
+                        let target = buf.len() as isize - 38;
+                        unsafe {
+                            ptr::write_bytes(buf_ptr.offset(target), b'0', (curr - target) as usize);
+                        }
                        curr = target;

-                        // Divide by 10^19 again.
-                        let (n, rem) = udiv128::udivmod_1e19(n);
-                        let buf2 = buf_ptr.offset(curr - U64_MAX_LEN as isize) as *mut [MaybeUninit<u8>; U64_MAX_LEN];
-                        curr -= rem.write(&mut *buf2).len() as isize;
-
-                        if n != 0 {
-                            // Memset the leading zeros.
-                            let target = buf.len() as isize - 38;
-                            ptr::write_bytes(buf_ptr.offset(target), b'0', (curr - target) as usize);
-                            curr = target;
-
-                            // There is at most one digit left
-                            // because u128::max / 10^19 / 10^19 is 3.
-                            curr -= 1;
+                        // There is at most one digit left
+                        // because u128::MAX / 10^19 / 10^19 is 3.
+                        curr -= 1;
+                        unsafe {
                            *buf_ptr.offset(curr) = (n as u8) + b'0';
                        }
                    }
+                }

-                    if !is_nonnegative {
-                        curr -= 1;
+                if !is_nonnegative {
+                    curr -= 1;
+                    unsafe {
                        *buf_ptr.offset(curr) = b'-';
                    }
-
-                    let len = buf.len() - curr as usize;
-                    let bytes = slice::from_raw_parts(buf_ptr.offset(curr), len);
-                    str::from_utf8_unchecked(bytes)
                }
+
+                let len = buf.len() - curr as usize;
+                let bytes = unsafe { slice::from_raw_parts(buf_ptr.offset(curr), len) };
+                unsafe { str::from_utf8_unchecked(bytes) }
            }
        }
+
+        impl private::Sealed for $t {}
    )*};
 }

--- a/src/udiv128.rs
+++ b/src/udiv128.rs
@ -4,7 +4,7 @@ use no_panic::no_panic;
 /// Multiply unsigned 128 bit integers, return upper 128 bits of the result
 #[inline]
 #[cfg_attr(feature = "no-panic", no_panic)]
-fn u128_mulhi(x: u128, y: u128) -> u128 {
+const fn u128_mulhi(x: u128, y: u128) -> u128 {
    let x_lo = x as u64;
    let x_hi = (x >> 64) as u64;
    let y_lo = y as u64;
@ -31,7 +31,7 @@ fn u128_mulhi(x: u128, y: u128) -> u128 {
 ///
 #[inline]
 #[cfg_attr(feature = "no-panic", no_panic)]
-pub fn udivmod_1e19(n: u128) -> (u128, u64) {
+pub const fn udivmod_1e19(n: u128) -> (u128, u64) {
    let d = 10_000_000_000_000_000_000_u64; // 10^19

    let quot = if n < 1 << 83 {
@ -41,8 +41,8 @@ pub fn udivmod_1e19(n: u128) -> (u128, u64) {
    };

    let rem = (n - quot * d as u128) as u64;
-    debug_assert_eq!(quot, n / d as u128);
-    debug_assert_eq!(rem as u128, n % d as u128);
+    debug_assert!(quot == n / d as u128);
+    debug_assert!(rem as u128 == n % d as u128);

    (quot, rem)
 }