Implement generic assign operations for various types

src/datetime/mod.rs

@@ -912,16 +912,6 @@ impl<Tz: TimeZone> Add<OldDuration> for DateTime<Tz> {
  }
 }
 
-impl<Tz: TimeZone> AddAssign<OldDuration> for DateTime<Tz> {
- #[inline]
- fn add_assign(&mut self, rhs: OldDuration) {
- let datetime =
- self.datetime.checked_add_signed(rhs).expect("`DateTime + Duration` overflowed");
- let tz = self.timezone();
- *self = tz.from_utc_datetime(&datetime);
- }
-}
-
 impl<Tz: TimeZone> Add<Months> for DateTime<Tz> {
  type Output = DateTime<Tz>;
 
@@ -939,16 +929,6 @@ impl<Tz: TimeZone> Sub<OldDuration> for DateTime<Tz> {
  }
 }
 
-impl<Tz: TimeZone> SubAssign<OldDuration> for DateTime<Tz> {
- #[inline]
- fn sub_assign(&mut self, rhs: OldDuration) {
- let datetime =
- self.datetime.checked_sub_signed(rhs).expect("`DateTime - Duration` overflowed");
- let tz = self.timezone();
- *self = tz.from_utc_datetime(&datetime)
- }
-}
-
 impl<Tz: TimeZone> Sub<Months> for DateTime<Tz> {
  type Output = DateTime<Tz>;
 
@@ -982,6 +962,30 @@ impl<Tz: TimeZone> Sub<Days> for DateTime<Tz> {
  }
 }
 
+impl<T, Tz: TimeZone> AddAssign<T> for DateTime<Tz>
+where
+ NaiveDateTime: Add<T, Output = NaiveDateTime>,
+{
+ #[inline]
+ fn add_assign(&mut self, rhs: T) {
+ let datetime = self.datetime + rhs;
+ let tz = self.timezone();
+ *self = tz.from_utc_datetime(&datetime);
+ }
+}
+
+impl<T, Tz: TimeZone> SubAssign<T> for DateTime<Tz>
+where
+ NaiveDateTime: Sub<T, Output = NaiveDateTime>,
+{
+ #[inline]
+ fn sub_assign(&mut self, rhs: T) {
+ let datetime = self.datetime - rhs;
+ let tz = self.timezone();
+ *self = tz.from_utc_datetime(&datetime);
+ }
+}
+
 impl<Tz: TimeZone> fmt::Debug for DateTime<Tz> {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  self.naive_local().fmt(f)?;

src/datetime/tests.rs

@@ -242,6 +242,73 @@ fn test_datetime_sub_months() {
  );
 }
 
+#[test]
+fn test_datetime_addassignment() {
+ let est = FixedOffset::west_opt(5 * 60 * 60).unwrap();
+ let ymdhms = |y, m, d, h, n, s| est.with_ymd_and_hms(y, m, d, h, n, s).unwrap();
+
+ {
+ let mut dt = ymdhms(2014, 5, 6, 7, 8, 9);
+ dt += Duration::seconds(5);
+ assert_eq!(dt, ymdhms(2014, 5, 6, 7, 8, 14));
+ dt += Duration::minutes(35);
+ assert_eq!(dt, ymdhms(2014, 5, 6, 7, 43, 14));
+ }
+
+ {
+ let mut dt = ymdhms(2014, 5, 6, 7, 8, 9);
+ dt += Days::new(5);
+ assert_eq!(dt, ymdhms(2014, 5, 11, 7, 8, 9));
+ dt += Days::new(35);
+ assert_eq!(dt, ymdhms(2014, 6, 15, 7, 8, 9));
+ }
+
+ {
+ let mut dt = ymdhms(2014, 5, 6, 7, 8, 9);
+ dt += Months::new(1);
+ assert_eq!(dt, ymdhms(2014, 6, 6, 7, 8, 9));
+ dt += Months::new(5);
+ assert_eq!(dt, ymdhms(2014, 11, 6, 7, 8, 9));
+ }
+}
+
+#[test]
+fn test_datetime_subassignment() {
+ let est = FixedOffset::west_opt(5 * 60 * 60).unwrap();
+ let original_dt = est.with_ymd_and_hms(2014, 5, 6, 7, 8, 9).unwrap();
+
+ {
+ let mut dt = original_dt;
+ dt -= Duration::seconds(5);
+ assert_eq!(dt, original_dt - Duration::seconds(5));
+ dt -= Duration::minutes(35);
+ assert_eq!(dt, original_dt - Duration::seconds(2105));
+ }
+
+ {
+ let mut dt = original_dt;
+ dt -= Days::new(5);
+ assert_eq!(dt, original_dt - Days::new(5));
+ dt -= Days::new(35);
+ assert_eq!(dt, original_dt - Days::new(40));
+ }
+
+ {
+ let mut dt = original_dt;
+ dt -= Months::new(1);
+ assert_eq!(dt, original_dt - Months::new(1));
+ dt -= Months::new(5);
+ assert_eq!(dt, original_dt - Months::new(6));
+ }
+}
+
+#[test]
+#[should_panic(expected = "`NaiveDateTime + Duration` overflowed")]
+fn test_datetime_addassign_overflow() {
+ let mut dt = DateTime::<Utc>::MAX_UTC;
+ dt += Duration::seconds(1);
+}
+
 #[test]
 fn test_datetime_offset() {
  let est = FixedOffset::west_opt(5 * 60 * 60).unwrap();

src/naive/date.rs

@@ -1627,13 +1627,6 @@ impl Add<OldDuration> for NaiveDate {
  }
 }
 
-impl AddAssign<OldDuration> for NaiveDate {
- #[inline]
- fn add_assign(&mut self, rhs: OldDuration) {
- *self = self.add(rhs);
- }
-}
-
 impl Add<Months> for NaiveDate {
  type Output = NaiveDate;
 
@@ -1735,13 +1728,6 @@ impl Sub<OldDuration> for NaiveDate {
  }
 }
 
-impl SubAssign<OldDuration> for NaiveDate {
- #[inline]
- fn sub_assign(&mut self, rhs: OldDuration) {
- *self = self.sub(rhs);
- }
-}
-
 /// Subtracts another `NaiveDate` from the current date.
 /// Returns a `Duration` of integral numbers.
 ///
@@ -1775,6 +1761,26 @@ impl Sub<NaiveDate> for NaiveDate {
  }
 }
 
+impl<T> AddAssign<T> for NaiveDate
+where
+ Self: Add<T, Output = Self>,
+{
+ #[inline]
+ fn add_assign(&mut self, rhs: T) {
+ *self = *self + rhs;
+ }
+}
+
+impl<T> SubAssign<T> for NaiveDate
+where
+ Self: Sub<T, Output = Self>,
+{
+ #[inline]
+ fn sub_assign(&mut self, rhs: T) {
+ *self = *self - rhs;
+ }
+}
+
 /// Iterator over `NaiveDate` with a step size of one day.
 #[derive(Debug, Copy, Clone, Hash, PartialEq, PartialOrd, Eq, Ord)]
 pub struct NaiveDateDaysIterator {
@@ -2713,21 +2719,59 @@ mod tests {
  #[test]
  fn test_date_addassignment() {
  let ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
- let mut date = ymd(2016, 10, 1);
- date += Duration::days(10);
- assert_eq!(date, ymd(2016, 10, 11));
- date += Duration::days(30);
- assert_eq!(date, ymd(2016, 11, 10));
+
+ {
+ let mut date = ymd(2016, 10, 1);
+ date += Duration::days(10);
+ assert_eq!(date, ymd(2016, 10, 11));
+ date += Duration::days(30);
+ assert_eq!(date, ymd(2016, 11, 10));
+ }
+
+ {
+ let mut date = ymd(2016, 10, 1);
+ date += Months::new(1);
+ assert_eq!(date, ymd(2016, 11, 1));
+ date += Months::new(3);
+ assert_eq!(date, ymd(2017, 2, 1));
+ }
+
+ {
+ let mut date = ymd(2016, 10, 1);
+ date += Days::new(10);
+ assert_eq!(date, ymd(2016, 10, 11));
+ date += Days::new(30);
+ assert_eq!(date, ymd(2016, 11, 10));
+ }
  }
 
  #[test]
  fn test_date_subassignment() {
  let ymd = |y, m, d| NaiveDate::from_ymd_opt(y, m, d).unwrap();
- let mut date = ymd(2016, 10, 11);
- date -= Duration::days(10);
- assert_eq!(date, ymd(2016, 10, 1));
- date -= Duration::days(2);
- assert_eq!(date, ymd(2016, 9, 29));
+
+ {
+ let mut date = ymd(2016, 10, 11);
+ date -= Duration::days(10);
+ assert_eq!(date, ymd(2016, 10, 1));
+ date -= Duration::days(2);
+ assert_eq!(date, ymd(2016, 9, 29));
+ }
+
+ {
+ let mut date = ymd(2016, 10, 11);
+ date -= Months::new(10);
+ assert_eq!(date, ymd(2015, 12, 11));
+ date -= Months::new(2);
+ assert_eq!(date, ymd(2015, 10, 11));
+ }
+
+ {
+ let mut date = ymd(2016, 10, 11);
+ date -= Days::new(10);
+ assert_eq!(date, ymd(2016, 10, 1));
+ date -= Days::new(2);
+ assert_eq!(date, ymd(2016, 9, 29));
+ }
  }
 
  #[test]

src/naive/datetime/mod.rs

@@ -1461,13 +1461,6 @@ impl Add<OldDuration> for NaiveDateTime {
  }
 }
 
-impl AddAssign<OldDuration> for NaiveDateTime {
- #[inline]
- fn add_assign(&mut self, rhs: OldDuration) {
- *self = self.add(rhs);
- }
-}
-
 impl Add<Months> for NaiveDateTime {
  type Output = NaiveDateTime;
 
@@ -1570,13 +1563,6 @@ impl Sub<OldDuration> for NaiveDateTime {
  }
 }
 
-impl SubAssign<OldDuration> for NaiveDateTime {
- #[inline]
- fn sub_assign(&mut self, rhs: OldDuration) {
- *self = self.sub(rhs);
- }
-}
-
 /// A subtraction of Months from `NaiveDateTime` clamped to valid days in resulting month.
 ///
 /// # Panics
@@ -1674,6 +1660,26 @@ impl Sub<Days> for NaiveDateTime {
  }
 }
 
+impl<T> AddAssign<T> for NaiveDateTime
+where
+ Self: Add<T, Output = Self>,
+{
+ #[inline]
+ fn add_assign(&mut self, rhs: T) {
+ *self = *self + rhs;
+ }
+}
+
+impl<T> SubAssign<T> for NaiveDateTime
+where
+ Self: Sub<T, Output = Self>,
+{
+ #[inline]
+ fn sub_assign(&mut self, rhs: T) {
+ *self = *self - rhs;
+ }
+}
+
 /// The `Debug` output of the naive date and time `dt` is the same as
 /// [`dt.format("%Y-%m-%dT%H:%M:%S%.f")`](crate::format::strftime).
 ///

src/naive/datetime/tests.rs

@@ -1,7 +1,5 @@
 use super::NaiveDateTime;
-use crate::oldtime::Duration;
-use crate::NaiveDate;
-use crate::{Datelike, FixedOffset, Utc};
+use crate::{oldtime::Duration, Datelike, Days, FixedOffset, Months, NaiveDate, Utc};
 use std::i64;
 
 #[test]
@@ -163,22 +161,60 @@ fn test_datetime_sub() {
 fn test_datetime_addassignment() {
  let ymdhms =
  |y, m, d, h, n, s| NaiveDate::from_ymd_opt(y, m, d).unwrap().and_hms_opt(h, n, s).unwrap();
- let mut date = ymdhms(2016, 10, 1, 10, 10, 10);
- date += Duration::minutes(10_000_000);
- assert_eq!(date, ymdhms(2035, 10, 6, 20, 50, 10));
- date += Duration::days(10);
- assert_eq!(date, ymdhms(2035, 10, 16, 20, 50, 10));
+
+ {
+ let mut date = ymdhms(2016, 10, 1, 10, 10, 10);
+ date += Duration::minutes(10_000_000);
+ assert_eq!(date, ymdhms(2035, 10, 6, 20, 50, 10));
+ date += Duration::days(10);
+ assert_eq!(date, ymdhms(2035, 10, 16, 20, 50, 10));
+ }
+
+ {
+ let mut date = ymdhms(2016, 10, 1, 10, 10, 10);
+ date += Months::new(1_000);
+ assert_eq!(date, ymdhms(2100, 2, 1, 10, 10, 10));
+ date += Months::new(10);
+ assert_eq!(date, ymdhms(2100, 12, 1, 10, 10, 10));
+ }
+
+ {
+ let mut date = ymdhms(2016, 10, 1, 10, 10, 10);
+ date += Days::new(10_000);
+ assert_eq!(date, ymdhms(2044, 2, 17, 10, 10, 10));
+ date += Days::new(10);
+ assert_eq!(date, ymdhms(2044, 2, 27, 10, 10, 10));
+ }
 }
 
 #[test]
 fn test_datetime_subassignment() {
  let ymdhms =
  |y, m, d, h, n, s| NaiveDate::from_ymd_opt(y, m, d).unwrap().and_hms_opt(h, n, s).unwrap();
- let mut date = ymdhms(2016, 10, 1, 10, 10, 10);
- date -= Duration::minutes(10_000_000);
- assert_eq!(date, ymdhms(1997, 9, 26, 23, 30, 10));
- date -= Duration::days(10);
- assert_eq!(date, ymdhms(1997, 9, 16, 23, 30, 10));
+
+ {
+ let mut date = ymdhms(2016, 10, 1, 10, 10, 10);
+ date -= Duration::minutes(10_000_000);
+ assert_eq!(date, ymdhms(1997, 9, 26, 23, 30, 10));
+ date -= Duration::days(10);
+ assert_eq!(date, ymdhms(1997, 9, 16, 23, 30, 10));
+ }
+
+ {
+ let mut date = ymdhms(2016, 10, 1, 10, 10, 10);
+ date -= Months::new(1_000);
+ assert_eq!(date, ymdhms(1933, 6, 1, 10, 10, 10));
+ date -= Months::new(10);
+ assert_eq!(date, ymdhms(1932, 8, 1, 10, 10, 10));
+ }
+
+ {
+ let mut date = ymdhms(2016, 10, 1, 10, 10, 10);
+ date -= Days::new(10_000);
+ assert_eq!(date, ymdhms(1989, 5, 16, 10, 10, 10));
+ date -= Days::new(10);
+ assert_eq!(date, ymdhms(1989, 5, 6, 10, 10, 10));
+ }
 }
 
 #[test]