change NaiveDateTime and DateTime<Tz> to use TimeDelta

* these are done in one commit as they are very intertwined, eg via round.rs
* removing OldTimeDelta where it is no longer used

Author: esheppa

src/datetime/mod.rs

@@ -12,6 +12,7 @@ use alloc::string::{String, ToString};
 use core::borrow::Borrow;
 use core::cmp::Ordering;
 use core::ops::{Add, AddAssign, Sub, SubAssign};
+use core::time::Duration;
 use core::{fmt, hash, str};
 #[cfg(feature = "std")]
 use std::string::ToString;
@@ -31,7 +32,7 @@ use crate::naive::{Days, IsoWeek, NaiveDate, NaiveDateTime, NaiveTime};
 #[cfg(feature = "clock")]
 use crate::offset::Local;
 use crate::offset::{FixedOffset, Offset, TimeZone, Utc};
-use crate::{Date, Datelike, Months, OldTimeDelta, Timelike, Weekday};
+use crate::{Date, Datelike, Months, TimeDelta, Timelike, Weekday};
 
 /// documented at re-export site
 #[cfg(feature = "serde")]
@@ -318,8 +319,8 @@ impl<Tz: TimeZone> DateTime<Tz> {
     ///
     /// Returns `None` when it will result in overflow.
     #[inline]
-    pub fn checked_add_signed(self, rhs: OldTimeDelta) -> Option<DateTime<Tz>> {
-        let datetime = self.datetime.checked_add_signed(rhs)?;
+    pub fn checked_add(self, rhs: Duration) -> Option<DateTime<Tz>> {
+        let datetime = self.datetime.checked_add(rhs)?;
         let tz = self.timezone();
         Some(tz.from_utc_datetime(&datetime))
     }
@@ -341,8 +342,8 @@ impl<Tz: TimeZone> DateTime<Tz> {
     ///
     /// Returns `None` when it will result in overflow.
     #[inline]
-    pub fn checked_sub_signed(self, rhs: OldTimeDelta) -> Option<DateTime<Tz>> {
-        let datetime = self.datetime.checked_sub_signed(rhs)?;
+    pub fn checked_sub(self, rhs: Duration) -> Option<DateTime<Tz>> {
+        let datetime = self.datetime.checked_sub(rhs)?;
         let tz = self.timezone();
         Some(tz.from_utc_datetime(&datetime))
     }
@@ -383,8 +384,8 @@ impl<Tz: TimeZone> DateTime<Tz> {
     /// Subtracts another `DateTime` from the current date and time.
     /// This does not overflow or underflow at all.
     #[inline]
-    pub fn signed_duration_since<Tz2: TimeZone>(self, rhs: DateTime<Tz2>) -> OldTimeDelta {
-        self.datetime.signed_duration_since(rhs.datetime)
+    pub fn duration_since<Tz2: TimeZone>(self, rhs: DateTime<Tz2>) -> TimeDelta {
+        self.datetime.duration_since(rhs.datetime)
     }
 
     /// Returns a view to the naive UTC datetime.
@@ -966,20 +967,19 @@ impl<Tz: TimeZone> hash::Hash for DateTime<Tz> {
     }
 }
 
-impl<Tz: TimeZone> Add<OldTimeDelta> for DateTime<Tz> {
+impl<Tz: TimeZone> Add<Duration> for DateTime<Tz> {
     type Output = DateTime<Tz>;
 
     #[inline]
-    fn add(self, rhs: OldTimeDelta) -> DateTime<Tz> {
-        self.checked_add_signed(rhs).expect("`DateTime + Duration` overflowed")
+    fn add(self, rhs: Duration) -> DateTime<Tz> {
+        self.checked_add(rhs).expect("`DateTime + Duration` overflowed")
     }
 }
 
-impl<Tz: TimeZone> AddAssign<OldTimeDelta> for DateTime<Tz> {
+impl<Tz: TimeZone> AddAssign<Duration> for DateTime<Tz> {
     #[inline]
-    fn add_assign(&mut self, rhs: OldTimeDelta) {
-        let datetime =
-            self.datetime.checked_add_signed(rhs).expect("`DateTime + Duration` overflowed");
+    fn add_assign(&mut self, rhs: Duration) {
+        let datetime = self.datetime.checked_add(rhs).expect("`DateTime + Duration` overflowed");
         let tz = self.timezone();
         *self = tz.from_utc_datetime(&datetime);
     }
@@ -993,20 +993,19 @@ impl<Tz: TimeZone> Add<Months> for DateTime<Tz> {
     }
 }
 
-impl<Tz: TimeZone> Sub<OldTimeDelta> for DateTime<Tz> {
+impl<Tz: TimeZone> Sub<Duration> for DateTime<Tz> {
     type Output = DateTime<Tz>;
 
     #[inline]
-    fn sub(self, rhs: OldTimeDelta) -> DateTime<Tz> {
-        self.checked_sub_signed(rhs).expect("`DateTime - Duration` overflowed")
+    fn sub(self, rhs: Duration) -> DateTime<Tz> {
+        self.checked_sub(rhs).expect("`DateTime - Duration` overflowed")
     }
 }
 
-impl<Tz: TimeZone> SubAssign<OldTimeDelta> for DateTime<Tz> {
+impl<Tz: TimeZone> SubAssign<Duration> for DateTime<Tz> {
     #[inline]
-    fn sub_assign(&mut self, rhs: OldTimeDelta) {
-        let datetime =
-            self.datetime.checked_sub_signed(rhs).expect("`DateTime - Duration` overflowed");
+    fn sub_assign(&mut self, rhs: Duration) {
+        let datetime = self.datetime.checked_sub(rhs).expect("`DateTime - Duration` overflowed");
         let tz = self.timezone();
         *self = tz.from_utc_datetime(&datetime)
     }
@@ -1020,15 +1019,6 @@ impl<Tz: TimeZone> Sub<Months> for DateTime<Tz> {
     }
 }
 
-impl<Tz: TimeZone> Sub<DateTime<Tz>> for DateTime<Tz> {
-    type Output = OldTimeDelta;
-
-    #[inline]
-    fn sub(self, rhs: DateTime<Tz>) -> OldTimeDelta {
-        self.signed_duration_since(rhs)
-    }
-}
-
 impl<Tz: TimeZone> Add<Days> for DateTime<Tz> {
     type Output = DateTime<Tz>;
 
@@ -1133,8 +1123,6 @@ impl From<SystemTime> for DateTime<Local> {
 #[cfg_attr(docsrs, doc(cfg(feature = "std")))]
 impl<Tz: TimeZone> From<DateTime<Tz>> for SystemTime {
     fn from(dt: DateTime<Tz>) -> SystemTime {
-        use std::time::Duration;
-
         let sec = dt.timestamp();
         let nsec = dt.timestamp_subsec_nanos();
         if sec < 0 {

src/datetime/tests.rs

@@ -1,3 +1,4 @@
+use core::time::Duration;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use super::DateTime;
@@ -7,10 +8,10 @@ use crate::offset::Local;
 use crate::offset::{FixedOffset, TimeZone, Utc};
 #[cfg(feature = "clock")]
 use crate::Datelike;
-use crate::OldTimeDelta;
+use crate::TimeDelta;
 
 #[test]
-fn test_datetime_offset() {
+fn test_datetime_offset_duration() {
     let est = FixedOffset::west_opt(5 * 60 * 60).unwrap();
     let edt = FixedOffset::west_opt(4 * 60 * 60).unwrap();
     let kst = FixedOffset::east_opt(9 * 60 * 60).unwrap();
@@ -69,12 +70,12 @@ fn test_datetime_offset() {
     let dt = Utc.ymd_opt(2014, 5, 6).unwrap().and_hms_opt(7, 8, 9).unwrap();
     assert_eq!(dt, edt.ymd_opt(2014, 5, 6).unwrap().and_hms_opt(3, 8, 9).unwrap());
     assert_eq!(
-        dt + OldTimeDelta::seconds(3600 + 60 + 1),
+        dt + Duration::from_secs(3600 + 60 + 1),
         Utc.ymd_opt(2014, 5, 6).unwrap().and_hms_opt(8, 9, 10).unwrap()
     );
     assert_eq!(
-        dt.signed_duration_since(edt.ymd_opt(2014, 5, 6).unwrap().and_hms_opt(10, 11, 12).unwrap()),
-        OldTimeDelta::seconds(-7 * 3600 - 3 * 60 - 3)
+        dt.duration_since(edt.ymd_opt(2014, 5, 6).unwrap().and_hms_opt(10, 11, 12).unwrap()),
+        TimeDelta::Backwards(Duration::from_secs(7 * 3600 + 3 * 60 + 3))
     );
 
     assert_eq!(*Utc.ymd_opt(2014, 5, 6).unwrap().and_hms_opt(7, 8, 9).unwrap().offset(), Utc);
@@ -362,8 +363,6 @@ fn test_subsecond_part() {
 #[test]
 #[cfg(not(target_os = "windows"))]
 fn test_from_system_time() {
-    use std::time::Duration;
-
     let epoch = Utc.ymd_opt(1970, 1, 1).unwrap().and_hms_opt(0, 0, 0).unwrap();
     let nanos = 999_999_999;
 
@@ -411,8 +410,6 @@ fn test_from_system_time() {
 #[test]
 #[cfg(target_os = "windows")]
 fn test_from_system_time() {
-    use std::time::Duration;
-
     let nanos = 999_999_000;
 
     let epoch = Utc.ymd_opt(1970, 1, 1).unwrap().and_hms_opt(0, 0, 0).unwrap();
@@ -513,98 +510,95 @@ fn test_datetime_from_local() {
 
 #[test]
 #[cfg(feature = "clock")]
-fn test_years_elapsed() {
-    use crate::Days;
-
+fn test_years_elapsed_duration() {
     const WEEKS_PER_YEAR: f32 = 52.1775;
 
     // This is always at least one year because 1 year = 52.1775 weeks.
-    let one_year_ago = Utc.from_utc_date(
-        &(Utc::today().naive_utc() - Days::new((WEEKS_PER_YEAR * 1.5 * 7.0).ceil() as u64)),
-    );
+    let one_year_ago = Utc::today().and_hms_opt(0, 0, 0).unwrap()
+        - Duration::from_secs(7 * 24 * 60 * 60 * (WEEKS_PER_YEAR * 1.5).ceil() as u64);
     // A bit more than 2 years.
-    let two_year_ago = Utc.from_utc_date(
-        &(Utc::today().naive_utc() - Days::new((WEEKS_PER_YEAR * 2.5 * 7.0).ceil() as u64)),
-    );
+    let two_year_ago = Utc::today().and_hms_opt(0, 0, 0).unwrap()
+        - Duration::from_secs(7 * 24 * 60 * 60 * (WEEKS_PER_YEAR * 2.5).ceil() as u64);
 
-    assert_eq!(Utc::today().years_since(one_year_ago), Some(1));
-    assert_eq!(Utc::today().years_since(two_year_ago), Some(2));
+    assert_eq!(Utc::today().and_hms_opt(0, 0, 0).unwrap().years_since(one_year_ago), Some(1));
+    assert_eq!(Utc::today().and_hms_opt(0, 0, 0).unwrap().years_since(two_year_ago), Some(2));
 
     // If the given DateTime is later than now, the function will always return 0.
-    let future = Utc.from_utc_date(&(Utc::today().naive_utc() + Days::new(12 * 7)));
-    assert_eq!(Utc::today().years_since(future), None);
+    let future =
+        Utc::today().and_hms_opt(0, 0, 0).unwrap() + Duration::from_secs(7 * 24 * 60 * 60 * 12);
+    assert_eq!(Utc::today().and_hms_opt(0, 0, 0).unwrap().years_since(future), None);
 }
 
 #[test]
-fn test_datetime_add_assign() {
+fn test_datetime_add_assign_duration() {
     let naivedatetime = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap().and_hms_opt(0, 0, 0).unwrap();
     let datetime = DateTime::<Utc>::from_utc(naivedatetime, Utc);
     let mut datetime_add = datetime;
 
-    datetime_add += OldTimeDelta::seconds(60);
-    assert_eq!(datetime_add, datetime + OldTimeDelta::seconds(60));
+    datetime_add += Duration::from_secs(60);
+    assert_eq!(datetime_add, datetime + Duration::from_secs(60));
 
     let timezone = FixedOffset::east_opt(60 * 60).unwrap();
     let datetime = datetime.with_timezone(&timezone);
     let datetime_add = datetime_add.with_timezone(&timezone);
 
-    assert_eq!(datetime_add, datetime + OldTimeDelta::seconds(60));
+    assert_eq!(datetime_add, datetime + Duration::from_secs(60));
 
     let timezone = FixedOffset::west_opt(2 * 60 * 60).unwrap();
     let datetime = datetime.with_timezone(&timezone);
     let datetime_add = datetime_add.with_timezone(&timezone);
 
-    assert_eq!(datetime_add, datetime + OldTimeDelta::seconds(60));
+    assert_eq!(datetime_add, datetime + Duration::from_secs(60));
 }
 
 #[test]
 #[cfg(feature = "clock")]
-fn test_datetime_add_assign_local() {
+fn test_datetime_add_assign_local_duration() {
     let naivedatetime = NaiveDate::from_ymd_opt(2022, 1, 1).unwrap().and_hms_opt(0, 0, 0).unwrap();
 
     let datetime = Local.from_utc_datetime(&naivedatetime);
     let mut datetime_add = Local.from_utc_datetime(&naivedatetime);
 
     // ensure we cross a DST transition
     for i in 1..=365 {
-        datetime_add += OldTimeDelta::days(1);
-        assert_eq!(datetime_add, datetime + OldTimeDelta::days(i))
+        datetime_add += Duration::from_secs(24 * 60 * 60);
+        assert_eq!(datetime_add, datetime + Duration::from_secs(24 * 60 * 60 * i))
     }
 }
 
 #[test]
-fn test_datetime_sub_assign() {
+fn test_datetime_sub_assign_duration() {
     let naivedatetime = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap().and_hms_opt(12, 0, 0).unwrap();
     let datetime = DateTime::<Utc>::from_utc(naivedatetime, Utc);
     let mut datetime_sub = datetime;
 
-    datetime_sub -= OldTimeDelta::minutes(90);
-    assert_eq!(datetime_sub, datetime - OldTimeDelta::minutes(90));
+    datetime_sub -= Duration::from_secs(60 * 90);
+    assert_eq!(datetime_sub, datetime - Duration::from_secs(60 * 90));
 
     let timezone = FixedOffset::east_opt(60 * 60).unwrap();
     let datetime = datetime.with_timezone(&timezone);
     let datetime_sub = datetime_sub.with_timezone(&timezone);
 
-    assert_eq!(datetime_sub, datetime - OldTimeDelta::minutes(90));
+    assert_eq!(datetime_sub, datetime - Duration::from_secs(60 * 90));
 
     let timezone = FixedOffset::west_opt(2 * 60 * 60).unwrap();
     let datetime = datetime.with_timezone(&timezone);
     let datetime_sub = datetime_sub.with_timezone(&timezone);
 
-    assert_eq!(datetime_sub, datetime - OldTimeDelta::minutes(90));
+    assert_eq!(datetime_sub, datetime - Duration::from_secs(60 * 90));
 }
 
 #[test]
 #[cfg(feature = "clock")]
-fn test_datetime_sub_assign_local() {
+fn test_datetime_sub_assign_local_duration() {
     let naivedatetime = NaiveDate::from_ymd_opt(2022, 1, 1).unwrap().and_hms_opt(0, 0, 0).unwrap();
 
     let datetime = Local.from_utc_datetime(&naivedatetime);
     let mut datetime_sub = Local.from_utc_datetime(&naivedatetime);
 
     // ensure we cross a DST transition
     for i in 1..=365 {
-        datetime_sub -= OldTimeDelta::days(1);
-        assert_eq!(datetime_sub, datetime - OldTimeDelta::days(i))
+        datetime_sub -= Duration::from_secs(24 * 60 * 60);
+        assert_eq!(datetime_sub, datetime - Duration::from_secs(24 * 60 * 60 * i))
     }
 }

src/format/parsed.rs

@@ -5,13 +5,14 @@
 //! They can be constructed incrementally while being checked for consistency.
 
 use core::convert::TryFrom;
+use core::time::Duration;
 
 use num_integer::div_rem;
 
 use super::{ParseResult, IMPOSSIBLE, NOT_ENOUGH, OUT_OF_RANGE};
 use crate::naive::{NaiveDate, NaiveDateTime, NaiveTime};
 use crate::offset::{FixedOffset, LocalResult, Offset, TimeZone};
-use crate::{DateTime, Datelike, Days, OldTimeDelta, Timelike, Weekday};
+use crate::{DateTime, Datelike, Days, Timelike, Weekday};
 
 /// Parsed parts of date and time. There are two classes of methods:
 ///
@@ -601,7 +602,7 @@ impl Parsed {
                     59 => {}
                     // `datetime` is known to be off by one second.
                     0 => {
-                        datetime -= OldTimeDelta::seconds(1);
+                        datetime -= Duration::from_secs(1);
                     }
                     // otherwise it is impossible.
                     _ => return Err(IMPOSSIBLE),
@@ -644,9 +645,17 @@ impl Parsed {
         let offset = FixedOffset::east_opt(offset).ok_or(OUT_OF_RANGE)?;
 
         // this is used to prevent an overflow when calling FixedOffset::from_local_datetime
-        datetime
-            .checked_sub_signed(OldTimeDelta::seconds(i64::from(offset.local_minus_utc())))
-            .ok_or(OUT_OF_RANGE)?;
+        if offset.local_minus_utc() < 0 {
+            datetime
+                .checked_add(Duration::from_secs(
+                    u64::try_from(offset.local_minus_utc().abs()).unwrap(),
+                ))
+                .ok_or(OUT_OF_RANGE)?;
+        } else {
+            datetime
+                .checked_sub(Duration::from_secs(u64::try_from(offset.local_minus_utc()).unwrap()))
+                .ok_or(OUT_OF_RANGE)?;
+        }
 
         match offset.from_local_datetime(&datetime) {
             LocalResult::None => Err(IMPOSSIBLE),