Update IncrementRounder to use NonZeroU64

Author: nekevss

src/components/duration.rs

@@ -614,7 +614,7 @@ impl Duration {
         } else {
             // NOTE: DateDuration::round will always return a NormalizedTime::default as per spec.
             // a. Let normWithDays be ? Add24HourDaysToNormalizedTimeDuration(roundResult.[[NormalizedTime]], roundResult.[[Days]]).
-            let norm_with_days = round_result.0 .1.add_days(round_result.0 .0.days)?;
+            let norm_with_days = round_result.0 .1.add_days(round_result.0 .0.days as i64)?;
             // b. Let balanceResult be BalanceTimeDuration(normWithDays, largestUnit).
             TimeDuration::from_normalized(norm_with_days, largest_unit)?
         };

src/components/duration/date.rs

@@ -448,8 +448,6 @@ impl DateDuration {
         _precalculated_dt: Option<DateTime<C>>,
         context: &mut C::Context,
     ) -> TemporalResult<(Self, f64)> {
-        let increment = f64::from(increment.0.get());
-
         // 1. If plainRelativeTo is not present, set plainRelativeTo to undefined.
         let plain_relative_to = relative_to.date;
         // 2. If zonedRelativeTo is not present, set zonedRelativeTo to undefined.
@@ -581,9 +579,11 @@ impl DateDuration {
                 let frac_years = years + (fractional_days / one_year_days.abs());
 
                 // ab. Set years to RoundNumberToIncrement(fractionalYears, increment, roundingMode).
-                let rounded_years =
-                    IncrementRounder::<f64>::from_potentially_negative_parts(frac_years, increment)
-                        .round(rounding_mode);
+                let rounded_years = IncrementRounder::<f64>::from_potentially_negative_parts(
+                    frac_years,
+                    increment.as_extended_increment(),
+                )?
+                .round(rounding_mode);
 
                 // ac. Set total to fractionalYears.
                 // ad. Set months and weeks to 0.
@@ -666,8 +666,8 @@ impl DateDuration {
                 // r. Set months to RoundNumberToIncrement(fractionalMonths, increment, roundingMode).
                 let rounded_months = IncrementRounder::<f64>::from_potentially_negative_parts(
                     frac_months,
-                    increment,
-                )
+                    increment.as_extended_increment(),
+                )?
                 .round(rounding_mode);
 
                 // s. Set total to fractionalMonths.
@@ -719,9 +719,11 @@ impl DateDuration {
                 let frac_weeks = weeks + fractional_days / one_week_days.abs();
 
                 // k. Set weeks to RoundNumberToIncrement(fractionalWeeks, increment, roundingMode).
-                let rounded_weeks =
-                    IncrementRounder::<f64>::from_potentially_negative_parts(frac_weeks, increment)
-                        .round(rounding_mode);
+                let rounded_weeks = IncrementRounder::<f64>::from_potentially_negative_parts(
+                    frac_weeks,
+                    increment.as_extended_increment(),
+                )?
+                .round(rounding_mode);
                 // l. Set total to fractionalWeeks.
                 let result = Self::new(self.years, self.months, rounded_weeks as f64, 0f64)?;
                 Ok((result, frac_weeks))
@@ -731,8 +733,8 @@ impl DateDuration {
                 // a. Set days to RoundNumberToIncrement(fractionalDays, increment, roundingMode).
                 let rounded_days = IncrementRounder::<f64>::from_potentially_negative_parts(
                     fractional_days,
-                    increment,
-                )
+                    increment.as_extended_increment(),
+                )?
                 .round(rounding_mode);
 
                 // b. Set total to fractionalDays.

src/components/duration/normalized.rs

@@ -1,6 +1,6 @@
 //! This module implements the normalized `Duration` records.
 
-use std::ops::Add;
+use std::{num::NonZeroU64, ops::Add};
 
 use num_traits::Euclid;
 
@@ -40,11 +40,11 @@ impl NormalizedTimeDuration {
         Self(nanoseconds)
     }
 
-    // NOTE: `days: f64` should be an integer.
+    // NOTE: `days: f64` should be an integer -> `i64`.
     /// Equivalent: 7.5.23 Add24HourDaysToNormalizedTimeDuration ( d, days )
     #[allow(unused)]
-    pub(super) fn add_days(&self, days: f64) -> TemporalResult<Self> {
-        let result = self.0 + i128::from(days as i64 * NS_PER_DAY);
+    pub(super) fn add_days(&self, days: i64) -> TemporalResult<Self> {
+        let result = self.0 + i128::from(days * NS_PER_DAY as i64);
         if result.abs() > MAX_TIME_DURATION {
             return Err(TemporalError::range()
                 .with_message("normalizedTimeDuration exceeds maxTimeDuration."));
@@ -88,10 +88,13 @@ impl NormalizedTimeDuration {
     }
 
     /// Round the current `NormalizedTimeDuration`.
-    pub(super) fn round(&self, increment: u64, mode: TemporalRoundingMode) -> TemporalResult<Self> {
-        let rounded =
-            IncrementRounder::<i128>::from_potentially_negative_parts(self.0, increment.into())
-                .round(mode);
+    pub(super) fn round(
+        &self,
+        increment: NonZeroU64,
+        mode: TemporalRoundingMode,
+    ) -> TemporalResult<Self> {
+        let rounded = IncrementRounder::<i128>::from_potentially_negative_parts(self.0, increment)?
+            .round(mode);
         if rounded.abs() > MAX_TIME_DURATION {
             return Err(TemporalError::range()
                 .with_message("normalizedTimeDuration exceeds maxTimeDuration."));

src/components/duration/time.rs

@@ -1,8 +1,10 @@
 //! An implementation of `TimeDuration` and it's methods.
 
+use std::num::NonZeroU64;
+
 use crate::{
     options::{RoundingIncrement, TemporalRoundingMode, TemporalUnit},
-    TemporalError, TemporalResult,
+    TemporalError, TemporalResult, TemporalUnwrap,
 };
 
 use super::{is_valid_duration, normalized::NormalizedTimeDuration};
@@ -373,7 +375,6 @@ impl TimeDuration {
         unit: TemporalUnit,
         mode: TemporalRoundingMode,
     ) -> TemporalResult<(NormalizedTimeDuration, i64)> {
-        let increment = u64::from(increment.0.get());
         let norm = match unit {
             TemporalUnit::Year
             | TemporalUnit::Month
@@ -393,7 +394,11 @@ impl TimeDuration {
                 // b. Set total to DivideNormalizedTimeDuration(norm, divisor).
                 let total = norm.divide(NANOSECONDS_PER_HOUR as i64);
                 // c. Set norm to ? RoundNormalizedTimeDurationToIncrement(norm, divisor × increment, roundingMode).
-                let norm = norm.round(NANOSECONDS_PER_HOUR * increment, mode)?;
+                let increment_mul_divisor = increment
+                    .as_extended_increment()
+                    .checked_mul(unsafe { NonZeroU64::new_unchecked(NANOSECONDS_PER_HOUR) })
+                    .temporal_unwrap()?;
+                let norm = norm.round(increment_mul_divisor, mode)?;
                 Ok((norm, total as i64))
             }
             // 13. Else if unit is "minute", then
@@ -402,7 +407,11 @@ impl TimeDuration {
                 // b. Set total to DivideNormalizedTimeDuration(norm, divisor).
                 let total = norm.divide(NANOSECONDS_PER_MINUTE as i64);
                 // c. Set norm to ? RoundNormalizedTimeDurationToIncrement(norm, divisor × increment, roundingMode).
-                let norm = norm.round(NANOSECONDS_PER_MINUTE * increment, mode)?;
+                let increment_mul_divisor = increment
+                    .as_extended_increment()
+                    .checked_mul(unsafe { NonZeroU64::new_unchecked(NANOSECONDS_PER_MINUTE) })
+                    .temporal_unwrap()?;
+                let norm = norm.round(increment_mul_divisor, mode)?;
                 Ok((norm, total as i64))
             }
             // 14. Else if unit is "second", then
@@ -411,7 +420,11 @@ impl TimeDuration {
                 // b. Set total to DivideNormalizedTimeDuration(norm, divisor).
                 let total = norm.divide(NANOSECONDS_PER_SECOND as i64);
                 // c. Set norm to ? RoundNormalizedTimeDurationToIncrement(norm, divisor × increment, roundingMode).
-                let norm = norm.round(NANOSECONDS_PER_SECOND * increment, mode)?;
+                let increment_mul_divisor = increment
+                    .as_extended_increment()
+                    .checked_mul(unsafe { NonZeroU64::new_unchecked(NANOSECONDS_PER_SECOND) })
+                    .temporal_unwrap()?;
+                let norm = norm.round(increment_mul_divisor, mode)?;
                 Ok((norm, total as i64))
             }
             // 15. Else if unit is "millisecond", then
@@ -420,7 +433,11 @@ impl TimeDuration {
                 // b. Set total to DivideNormalizedTimeDuration(norm, divisor).
                 let total = norm.divide(1_000_000);
                 // c. Set norm to ? RoundNormalizedTimeDurationToIncrement(norm, divisor × increment, roundingMode).
-                let norm = norm.round(1_000_000 * increment, mode)?;
+                let increment_mul_divisor = increment
+                    .as_extended_increment()
+                    .checked_mul(unsafe { NonZeroU64::new_unchecked(1_000_000) })
+                    .temporal_unwrap()?;
+                let norm = norm.round(increment_mul_divisor, mode)?;
                 Ok((norm, total as i64))
             }
             // 16. Else if unit is "microsecond", then
@@ -429,7 +446,11 @@ impl TimeDuration {
                 // b. Set total to DivideNormalizedTimeDuration(norm, divisor).
                 let total = norm.divide(1_000);
                 // c. Set norm to ? RoundNormalizedTimeDurationToIncrement(norm, divisor × increment, roundingMode).
-                let norm = norm.round(1_000 * increment, mode)?;
+                let increment_mul_divisor = increment
+                    .as_extended_increment()
+                    .checked_mul(unsafe { NonZeroU64::new_unchecked(1_000) })
+                    .temporal_unwrap()?;
+                let norm = norm.round(increment_mul_divisor, mode)?;
                 Ok((norm, total as i64))
             }
             // 17. Else,
@@ -439,7 +460,7 @@ impl TimeDuration {
                 let total =
                     norm.seconds() * (NANOSECONDS_PER_SECOND as i64) + i64::from(norm.subseconds());
                 // c. Set norm to ? RoundNormalizedTimeDurationToIncrement(norm, increment, roundingMode).
-                let norm = norm.round(increment, mode)?;
+                let norm = norm.round(increment.as_extended_increment(), mode)?;
                 Ok((norm, total))
             }
             _ => unreachable!("All other units early return error."),

src/components/instant.rs

@@ -1,10 +1,12 @@
 //! An implementation of the Temporal Instant.
 
+use std::num::NonZeroU64;
+
 use crate::{
     components::{duration::TimeDuration, Duration},
     options::{RoundingIncrement, TemporalRoundingMode, TemporalUnit},
     rounding::{IncrementRounder, Round},
-    TemporalError, TemporalResult, MS_PER_DAY, NS_PER_DAY,
+    TemporalError, TemporalResult, TemporalUnwrap, MS_PER_DAY, NS_PER_DAY,
 };
 
 use num_bigint::BigInt;
@@ -103,21 +105,33 @@ impl Instant {
         unit: TemporalUnit,
         rounding_mode: TemporalRoundingMode,
     ) -> TemporalResult<BigInt> {
-        let increment = u64::from(increment.0.get());
+        let increment = increment.as_extended_increment();
         let increment = match unit {
-            TemporalUnit::Hour => increment * (NANOSECONDS_PER_HOUR as u64),
-            TemporalUnit::Minute => increment * (NANOSECONDS_PER_MINUTE as u64),
-            TemporalUnit::Second => increment * (NANOSECONDS_PER_SECOND as u64),
-            TemporalUnit::Millisecond => increment * 1_000_000,
-            TemporalUnit::Microsecond => increment * 1_000,
-            TemporalUnit::Nanosecond => increment,
+            TemporalUnit::Hour => increment
+                .checked_mul(NonZeroU64::new(NANOSECONDS_PER_HOUR as u64).temporal_unwrap()?),
+            TemporalUnit::Minute => increment
+                .checked_mul(NonZeroU64::new(NANOSECONDS_PER_MINUTE as u64).temporal_unwrap()?),
+            TemporalUnit::Second => increment
+                .checked_mul(NonZeroU64::new(NANOSECONDS_PER_SECOND as u64).temporal_unwrap()?),
+            TemporalUnit::Millisecond => {
+                increment.checked_mul(NonZeroU64::new(1_000_000).temporal_unwrap()?)
+            }
+            TemporalUnit::Microsecond => {
+                increment.checked_mul(NonZeroU64::new(1_000).temporal_unwrap()?)
+            }
+            TemporalUnit::Nanosecond => Some(increment),
             _ => {
                 return Err(TemporalError::range()
                     .with_message("Invalid unit provided for Instant::round."))
             }
         };
 
-        let rounded = IncrementRounder::<f64>::from_positive_parts(self.to_f64(), increment as f64)
+        // NOTE: Potentially remove the below and just `temporal_unwrap`
+        let Some(increment) = increment else {
+            return Err(TemporalError::range().with_message("Increment exceeded a valid range."));
+        };
+
+        let rounded = IncrementRounder::<f64>::from_positive_parts(self.to_f64(), increment)?
             .round_as_positive(rounding_mode);
 
         BigInt::from_u64(rounded)
@@ -238,7 +252,7 @@ impl Instant {
             TemporalUnit::Second => 24 * 3600,
             TemporalUnit::Millisecond => MS_PER_DAY as u64,
             TemporalUnit::Microsecond => MS_PER_DAY as u64 * 1000,
-            TemporalUnit::Nanosecond => NS_PER_DAY as u64,
+            TemporalUnit::Nanosecond => NS_PER_DAY,
             _ => return Err(TemporalError::range().with_message("Invalid roundTo unit provided.")),
         };
         // NOTE: to_rounding_increment returns an f64 within a u32 range.

src/iso.rs

@@ -12,6 +12,8 @@
 //!
 //! An `IsoDateTime` has the internal slots of both an `IsoDate` and `IsoTime`.
 
+use std::num::NonZeroU64;
+
 use crate::{
     components::{
         calendar::{CalendarProtocol, CalendarSlot},
@@ -21,7 +23,7 @@ use crate::{
     error::TemporalError,
     options::{ArithmeticOverflow, RoundingIncrement, TemporalRoundingMode, TemporalUnit},
     rounding::{IncrementRounder, Round},
-    utils, TemporalResult, NS_PER_DAY,
+    utils, TemporalResult, TemporalUnwrap, NS_PER_DAY,
 };
 use icu_calendar::{Date as IcuDate, Iso};
 use num_bigint::BigInt;
@@ -554,7 +556,7 @@ impl IsoTime {
         increment: RoundingIncrement,
         unit: TemporalUnit,
         mode: TemporalRoundingMode,
-        day_length_ns: Option<i64>,
+        day_length_ns: Option<u64>,
     ) -> TemporalResult<(i32, Self)> {
         // 1. Let fractionalSecond be nanosecond × 10-9 + microsecond × 10-6 + millisecond × 10-3 + second.
 
@@ -612,19 +614,22 @@ impl IsoTime {
         };
 
         let ns_per_unit = if unit == TemporalUnit::Day {
-            day_length_ns.unwrap_or(NS_PER_DAY)
+            unsafe { NonZeroU64::new_unchecked(day_length_ns.unwrap_or(NS_PER_DAY)) }
         } else {
-            unit.as_nanoseconds().expect("Only valid time values are ") as i64
+            let nanos = unit.as_nanoseconds().temporal_unwrap()?;
+            unsafe { NonZeroU64::new_unchecked(nanos) }
         };
 
+        let increment = ns_per_unit
+            .checked_mul(increment.as_extended_increment())
+            .temporal_unwrap()?;
+
         // TODO: Verify validity of cast or handle better for result.
         // 9. Let result be RoundNumberToIncrement(quantity, increment, roundingMode).
-        let result = IncrementRounder::<i128>::from_potentially_negative_parts(
-            quantity.into(),
-            ns_per_unit as i128 * u64::from(increment.get()) as i128,
-        )
-        .round(mode)
-            / ns_per_unit as i128;
+        let result =
+            IncrementRounder::<i128>::from_potentially_negative_parts(quantity.into(), increment)?
+                .round(mode)
+                / i128::from(ns_per_unit.get());
 
         let result = match unit {
             // 10. If unit is "day", then

src/lib.rs

@@ -82,9 +82,9 @@ impl<T> TemporalUnwrap for Option<T> {
 
 // Relevant numeric constants
 /// Nanoseconds per day constant: 8.64e+13
-pub const NS_PER_DAY: i64 = MS_PER_DAY as i64 * 1_000_000;
+pub const NS_PER_DAY: u64 = MS_PER_DAY as u64 * 1_000_000;
 /// Milliseconds per day constant: 8.64e+7
-pub const MS_PER_DAY: i32 = 24 * 60 * 60 * 1000;
+pub const MS_PER_DAY: u32 = 24 * 60 * 60 * 1000;
 /// Max Instant nanosecond constant
 #[doc(hidden)]
 pub(crate) const NS_MAX_INSTANT: i128 = NS_PER_DAY as i128 * 100_000_000i128;

src/options.rs

@@ -81,19 +81,19 @@ impl TemporalUnit {
     // TODO: potentiall use a u64
     /// Returns the `Nanosecond amount for any given value.`
     #[must_use]
-    pub fn as_nanoseconds(&self) -> Option<f64> {
+    pub fn as_nanoseconds(&self) -> Option<u64> {
         use TemporalUnit::{
             Auto, Day, Hour, Microsecond, Millisecond, Minute, Month, Nanosecond, Second, Week,
             Year,
         };
         match self {
             Year | Month | Week | Day | Auto => None,
-            Hour => Some(3600e9),
-            Minute => Some(60e9),
-            Second => Some(1e9),
-            Millisecond => Some(1e6),
-            Microsecond => Some(1e3),
-            Nanosecond => Some(1f64),
+            Hour => Some(3_600_000_000_000),
+            Minute => Some(60_000_000_000),
+            Second => Some(1_000_000_000),
+            Millisecond => Some(1_000_000),
+            Microsecond => Some(1_000),
+            Nanosecond => Some(1),
         }
     }
 

src/options/increment.rs

@@ -1,4 +1,4 @@
-use std::num::NonZeroU32;
+use std::num::{NonZeroU32, NonZeroU64};
 
 use crate::{TemporalError, TemporalResult};
 
@@ -106,4 +106,8 @@ impl RoundingIncrement {
         // 5. Return unused.
         Ok(())
     }
+
+    pub(crate) fn as_extended_increment(&self) -> NonZeroU64 {
+        NonZeroU64::from(self.0)
+    }
 }