Merging upstream version 1.72.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 85 insertions, 69 deletions

diff --git a/vendor/time/src/time.rs b/vendor/time/src/time.rs
index 32fa97790..87b465bb9 100644
--- a/vendor/time/src/time.rs
+++ b/vendor/time/src/time.rs
@@ -6,6 +6,7 @@ use core::time::Duration as StdDuration;
 #[cfg(feature = "formatting")]
 use std::io;
 
+use crate::convert::*;
 #[cfg(feature = "formatting")]
 use crate::formatting::Formattable;
 #[cfg(feature = "parsing")]
@@ -71,10 +72,10 @@ impl Time {
         second: u8,
         nanosecond: u32,
     ) -> Self {
-        debug_assert!(hour < 24);
-        debug_assert!(minute < 60);
-        debug_assert!(second < 60);
-        debug_assert!(nanosecond < 1_000_000_000);
+        debug_assert!(hour < Hour.per(Day));
+        debug_assert!(minute < Minute.per(Hour));
+        debug_assert!(second < Second.per(Minute));
+        debug_assert!(nanosecond < Nanosecond.per(Second));
 
         Self {
             hour,
@@ -99,9 +100,9 @@ impl Time {
     /// assert!(Time::from_hms(0, 0, 60).is_err()); // 60 isn't a valid second.
     /// ```
     pub const fn from_hms(hour: u8, minute: u8, second: u8) -> Result<Self, error::ComponentRange> {
-        ensure_value_in_range!(hour in 0 => 23);
-        ensure_value_in_range!(minute in 0 => 59);
-        ensure_value_in_range!(second in 0 => 59);
+        ensure_value_in_range!(hour in 0 => Hour.per(Day) - 1);
+        ensure_value_in_range!(minute in 0 => Minute.per(Hour) - 1);
+        ensure_value_in_range!(second in 0 => Second.per(Minute) - 1);
         Ok(Self::__from_hms_nanos_unchecked(hour, minute, second, 0))
     }
 
@@ -125,15 +126,15 @@ impl Time {
         second: u8,
         millisecond: u16,
     ) -> Result<Self, error::ComponentRange> {
-        ensure_value_in_range!(hour in 0 => 23);
-        ensure_value_in_range!(minute in 0 => 59);
-        ensure_value_in_range!(second in 0 => 59);
-        ensure_value_in_range!(millisecond in 0 => 999);
+        ensure_value_in_range!(hour in 0 => Hour.per(Day) - 1);
+        ensure_value_in_range!(minute in 0 => Minute.per(Hour) - 1);
+        ensure_value_in_range!(second in 0 => Second.per(Minute) - 1);
+        ensure_value_in_range!(millisecond in 0 => Millisecond.per(Second) - 1);
         Ok(Self::__from_hms_nanos_unchecked(
             hour,
             minute,
             second,
-            millisecond as u32 * 1_000_000,
+            millisecond as u32 * Nanosecond.per(Millisecond),
         ))
     }
 
@@ -157,15 +158,15 @@ impl Time {
         second: u8,
         microsecond: u32,
     ) -> Result<Self, error::ComponentRange> {
-        ensure_value_in_range!(hour in 0 => 23);
-        ensure_value_in_range!(minute in 0 => 59);
-        ensure_value_in_range!(second in 0 => 59);
-        ensure_value_in_range!(microsecond in 0 => 999_999);
+        ensure_value_in_range!(hour in 0 => Hour.per(Day) - 1);
+        ensure_value_in_range!(minute in 0 => Minute.per(Hour) - 1);
+        ensure_value_in_range!(second in 0 => Second.per(Minute) - 1);
+        ensure_value_in_range!(microsecond in 0 => Microsecond.per(Second) - 1);
         Ok(Self::__from_hms_nanos_unchecked(
             hour,
             minute,
             second,
-            microsecond * 1_000,
+            microsecond * Nanosecond.per(Microsecond) as u32,
         ))
     }
 
@@ -189,10 +190,10 @@ impl Time {
         second: u8,
         nanosecond: u32,
     ) -> Result<Self, error::ComponentRange> {
-        ensure_value_in_range!(hour in 0 => 23);
-        ensure_value_in_range!(minute in 0 => 59);
-        ensure_value_in_range!(second in 0 => 59);
-        ensure_value_in_range!(nanosecond in 0 => 999_999_999);
+        ensure_value_in_range!(hour in 0 => Hour.per(Day) - 1);
+        ensure_value_in_range!(minute in 0 => Minute.per(Hour) - 1);
+        ensure_value_in_range!(second in 0 => Second.per(Minute) - 1);
+        ensure_value_in_range!(nanosecond in 0 => Nanosecond.per(Second) - 1);
         Ok(Self::__from_hms_nanos_unchecked(
             hour, minute, second, nanosecond,
         ))
@@ -223,7 +224,7 @@ impl Time {
             self.hour,
             self.minute,
             self.second,
-            (self.nanosecond / 1_000_000) as u16,
+            (self.nanosecond / Nanosecond.per(Millisecond)) as u16,
         )
     }
 
@@ -238,7 +239,12 @@ impl Time {
     /// );
     /// ```
     pub const fn as_hms_micro(self) -> (u8, u8, u8, u32) {
-        (self.hour, self.minute, self.second, self.nanosecond / 1_000)
+        (
+            self.hour,
+            self.minute,
+            self.second,
+            self.nanosecond / Nanosecond.per(Microsecond) as u32,
+        )
     }
 
     /// Get the clock hour, minute, second, and nanosecond.
@@ -304,7 +310,7 @@ impl Time {
     /// assert_eq!(time!(23:59:59.999).millisecond(), 999);
     /// ```
     pub const fn millisecond(self) -> u16 {
-        (self.nanosecond / 1_000_000) as _
+        (self.nanosecond / Nanosecond.per(Millisecond)) as _
     }
 
     /// Get the microseconds within the second.
@@ -317,7 +323,7 @@ impl Time {
     /// assert_eq!(time!(23:59:59.999_999).microsecond(), 999_999);
     /// ```
     pub const fn microsecond(self) -> u32 {
-        self.nanosecond / 1_000
+        self.nanosecond / Nanosecond.per(Microsecond) as u32
     }
 
     /// Get the nanoseconds within the second.
@@ -339,19 +345,21 @@ impl Time {
     /// the date is different.
     pub(crate) const fn adjusting_add(self, duration: Duration) -> (DateAdjustment, Self) {
         let mut nanoseconds = self.nanosecond as i32 + duration.subsec_nanoseconds();
-        let mut seconds = self.second as i8 + (duration.whole_seconds() % 60) as i8;
-        let mut minutes = self.minute as i8 + (duration.whole_minutes() % 60) as i8;
-        let mut hours = self.hour as i8 + (duration.whole_hours() % 24) as i8;
+        let mut seconds =
+            self.second as i8 + (duration.whole_seconds() % Second.per(Minute) as i64) as i8;
+        let mut minutes =
+            self.minute as i8 + (duration.whole_minutes() % Minute.per(Hour) as i64) as i8;
+        let mut hours = self.hour as i8 + (duration.whole_hours() % Hour.per(Day) as i64) as i8;
         let mut date_adjustment = DateAdjustment::None;
 
-        cascade!(nanoseconds in 0..1_000_000_000 => seconds);
-        cascade!(seconds in 0..60 => minutes);
-        cascade!(minutes in 0..60 => hours);
-        if hours >= 24 {
-            hours -= 24;
+        cascade!(nanoseconds in 0..Nanosecond.per(Second) as _ => seconds);
+        cascade!(seconds in 0..Second.per(Minute) as _ => minutes);
+        cascade!(minutes in 0..Minute.per(Hour) as _ => hours);
+        if hours >= Hour.per(Day) as _ {
+            hours -= Hour.per(Day) as i8;
             date_adjustment = DateAdjustment::Next;
         } else if hours < 0 {
-            hours += 24;
+            hours += Hour.per(Day) as i8;
             date_adjustment = DateAdjustment::Previous;
         }
 
@@ -370,19 +378,21 @@ impl Time {
     /// whether the date is different.
     pub(crate) const fn adjusting_sub(self, duration: Duration) -> (DateAdjustment, Self) {
         let mut nanoseconds = self.nanosecond as i32 - duration.subsec_nanoseconds();
-        let mut seconds = self.second as i8 - (duration.whole_seconds() % 60) as i8;
-        let mut minutes = self.minute as i8 - (duration.whole_minutes() % 60) as i8;
-        let mut hours = self.hour as i8 - (duration.whole_hours() % 24) as i8;
+        let mut seconds =
+            self.second as i8 - (duration.whole_seconds() % Second.per(Minute) as i64) as i8;
+        let mut minutes =
+            self.minute as i8 - (duration.whole_minutes() % Minute.per(Hour) as i64) as i8;
+        let mut hours = self.hour as i8 - (duration.whole_hours() % Hour.per(Day) as i64) as i8;
         let mut date_adjustment = DateAdjustment::None;
 
-        cascade!(nanoseconds in 0..1_000_000_000 => seconds);
-        cascade!(seconds in 0..60 => minutes);
-        cascade!(minutes in 0..60 => hours);
-        if hours >= 24 {
-            hours -= 24;
+        cascade!(nanoseconds in 0..Nanosecond.per(Second) as _ => seconds);
+        cascade!(seconds in 0..Second.per(Minute) as _ => minutes);
+        cascade!(minutes in 0..Minute.per(Hour) as _ => hours);
+        if hours >= Hour.per(Day) as _ {
+            hours -= Hour.per(Day) as i8;
             date_adjustment = DateAdjustment::Next;
         } else if hours < 0 {
-            hours += 24;
+            hours += Hour.per(Day) as i8;
             date_adjustment = DateAdjustment::Previous;
         }
 
@@ -401,16 +411,18 @@ impl Time {
     /// returning whether the date is the previous date as the first element of the tuple.
     pub(crate) const fn adjusting_add_std(self, duration: StdDuration) -> (bool, Self) {
         let mut nanosecond = self.nanosecond + duration.subsec_nanos();
-        let mut second = self.second + (duration.as_secs() % 60) as u8;
-        let mut minute = self.minute + ((duration.as_secs() / 60) % 60) as u8;
-        let mut hour = self.hour + ((duration.as_secs() / 3_600) % 24) as u8;
+        let mut second = self.second + (duration.as_secs() % Second.per(Minute) as u64) as u8;
+        let mut minute = self.minute
+            + ((duration.as_secs() / Second.per(Minute) as u64) % Minute.per(Hour) as u64) as u8;
+        let mut hour = self.hour
+            + ((duration.as_secs() / Second.per(Hour) as u64) % Hour.per(Day) as u64) as u8;
         let mut is_next_day = false;
 
-        cascade!(nanosecond in 0..1_000_000_000 => second);
-        cascade!(second in 0..60 => minute);
-        cascade!(minute in 0..60 => hour);
-        if hour >= 24 {
-            hour -= 24;
+        cascade!(nanosecond in 0..Nanosecond.per(Second) => second);
+        cascade!(second in 0..Second.per(Minute) => minute);
+        cascade!(minute in 0..Minute.per(Hour) => hour);
+        if hour >= Hour.per(Day) {
+            hour -= Hour.per(Day);
             is_next_day = true;
         }
 
@@ -424,16 +436,18 @@ impl Time {
     /// returning whether the date is the previous date as the first element of the tuple.
     pub(crate) const fn adjusting_sub_std(self, duration: StdDuration) -> (bool, Self) {
         let mut nanosecond = self.nanosecond as i32 - duration.subsec_nanos() as i32;
-        let mut second = self.second as i8 - (duration.as_secs() % 60) as i8;
-        let mut minute = self.minute as i8 - ((duration.as_secs() / 60) % 60) as i8;
-        let mut hour = self.hour as i8 - ((duration.as_secs() / 3_600) % 24) as i8;
+        let mut second = self.second as i8 - (duration.as_secs() % Second.per(Minute) as u64) as i8;
+        let mut minute = self.minute as i8
+            - ((duration.as_secs() / Second.per(Minute) as u64) % Minute.per(Hour) as u64) as i8;
+        let mut hour = self.hour as i8
+            - ((duration.as_secs() / Second.per(Hour) as u64) % Hour.per(Day) as u64) as i8;
         let mut is_previous_day = false;
 
-        cascade!(nanosecond in 0..1_000_000_000 => second);
-        cascade!(second in 0..60 => minute);
-        cascade!(minute in 0..60 => hour);
+        cascade!(nanosecond in 0..Nanosecond.per(Second) as _ => second);
+        cascade!(second in 0..Second.per(Minute) as _ => minute);
+        cascade!(minute in 0..Minute.per(Hour) as _ => hour);
         if hour < 0 {
-            hour += 24;
+            hour += Hour.per(Day) as i8;
             is_previous_day = true;
         }
 
@@ -457,7 +471,7 @@ impl Time {
     /// ```
     #[must_use = "This method does not mutate the original `Time`."]
     pub const fn replace_hour(self, hour: u8) -> Result<Self, error::ComponentRange> {
-        ensure_value_in_range!(hour in 0 => 23);
+        ensure_value_in_range!(hour in 0 => Hour.per(Day) - 1);
         Ok(Self::__from_hms_nanos_unchecked(
             hour,
             self.minute,
@@ -478,7 +492,7 @@ impl Time {
     /// ```
     #[must_use = "This method does not mutate the original `Time`."]
     pub const fn replace_minute(self, minute: u8) -> Result<Self, error::ComponentRange> {
-        ensure_value_in_range!(minute in 0 => 59);
+        ensure_value_in_range!(minute in 0 => Minute.per(Hour) - 1);
         Ok(Self::__from_hms_nanos_unchecked(
             self.hour,
             minute,
@@ -499,7 +513,7 @@ impl Time {
     /// ```
     #[must_use = "This method does not mutate the original `Time`."]
     pub const fn replace_second(self, second: u8) -> Result<Self, error::ComponentRange> {
-        ensure_value_in_range!(second in 0 => 59);
+        ensure_value_in_range!(second in 0 => Second.per(Minute) - 1);
         Ok(Self::__from_hms_nanos_unchecked(
             self.hour,
             self.minute,
@@ -523,12 +537,12 @@ impl Time {
         self,
         millisecond: u16,
     ) -> Result<Self, error::ComponentRange> {
-        ensure_value_in_range!(millisecond in 0 => 999);
+        ensure_value_in_range!(millisecond in 0 => Millisecond.per(Second) - 1);
         Ok(Self::__from_hms_nanos_unchecked(
             self.hour,
             self.minute,
             self.second,
-            millisecond as u32 * 1_000_000,
+            millisecond as u32 * Nanosecond.per(Millisecond),
         ))
     }
 
@@ -547,12 +561,12 @@ impl Time {
         self,
         microsecond: u32,
     ) -> Result<Self, error::ComponentRange> {
-        ensure_value_in_range!(microsecond in 0 => 999_999);
+        ensure_value_in_range!(microsecond in 0 => Microsecond.per(Second) - 1);
         Ok(Self::__from_hms_nanos_unchecked(
             self.hour,
             self.minute,
             self.second,
-            microsecond * 1000,
+            microsecond * Nanosecond.per(Microsecond) as u32,
         ))
     }
 
@@ -568,7 +582,7 @@ impl Time {
     /// ```
     #[must_use = "This method does not mutate the original `Time`."]
     pub const fn replace_nanosecond(self, nanosecond: u32) -> Result<Self, error::ComponentRange> {
-        ensure_value_in_range!(nanosecond in 0 => 999_999_999);
+        ensure_value_in_range!(nanosecond in 0 => Nanosecond.per(Second) - 1);
         Ok(Self::__from_hms_nanos_unchecked(
             self.hour,
             self.minute,
@@ -745,12 +759,14 @@ impl Sub for Time {
         let second_diff = (self.second as i8) - (rhs.second as i8);
         let nanosecond_diff = (self.nanosecond as i32) - (rhs.nanosecond as i32);
 
-        let seconds = hour_diff as i64 * 3_600 + minute_diff as i64 * 60 + second_diff as i64;
+        let seconds = hour_diff as i64 * Second.per(Hour) as i64
+            + minute_diff as i64 * Second.per(Minute) as i64
+            + second_diff as i64;
 
         let (seconds, nanoseconds) = if seconds > 0 && nanosecond_diff < 0 {
-            (seconds - 1, nanosecond_diff + 1_000_000_000)
+            (seconds - 1, nanosecond_diff + Nanosecond.per(Second) as i32)
         } else if seconds < 0 && nanosecond_diff > 0 {
-            (seconds + 1, nanosecond_diff - 1_000_000_000)
+            (seconds + 1, nanosecond_diff - Nanosecond.per(Second) as i32)
         } else {
             (seconds, nanosecond_diff)
         };