Build out add and subtract datetime functionality

Author: nekevss

src/components/date.rs

@@ -45,7 +45,7 @@ impl<C: CalendarProtocol> Date<C> {
         duration: &Duration,
         context: &mut C::Context,
     ) -> TemporalResult<(Self, f64)> {
-        let new_date = self.add_date(duration, ArithmeticOverflow::Constrain, context)?;
+        let new_date = self.add_date(duration, None, context)?;
         let days = f64::from(self.days_until(&new_date));
         Ok((new_date, days))
     }
@@ -56,10 +56,11 @@ impl<C: CalendarProtocol> Date<C> {
     pub(crate) fn add_date(
         &self,
         duration: &Duration,
-        overflow: ArithmeticOverflow,
+        overflow: Option<ArithmeticOverflow>,
         context: &mut C::Context,
     ) -> TemporalResult<Self> {
         // 2. If options is not present, set options to undefined.
+        let overflow = overflow.unwrap_or(ArithmeticOverflow::Constrain);
         // 3. If duration.[[Years]] ≠ 0, or duration.[[Months]] ≠ 0, or duration.[[Weeks]] ≠ 0, then
         if duration.date().years != 0.0
             || duration.date().months != 0.0
@@ -301,11 +302,7 @@ impl<C: CalendarProtocol> Date<C> {
         overflow: Option<ArithmeticOverflow>,
         context: &mut C::Context,
     ) -> TemporalResult<Self> {
-        self.add_date(
-            duration,
-            overflow.unwrap_or(ArithmeticOverflow::Constrain),
-            context,
-        )
+        self.add_date(duration, overflow, context)
     }
 
     pub fn contextual_subtract(
@@ -314,11 +311,7 @@ impl<C: CalendarProtocol> Date<C> {
         overflow: Option<ArithmeticOverflow>,
         context: &mut C::Context,
     ) -> TemporalResult<Self> {
-        self.add_date(
-            &duration.negated(),
-            overflow.unwrap_or(ArithmeticOverflow::Constrain),
-            context,
-        )
+        self.add_date(&duration.negated(), overflow, context)
     }
 
     pub fn contextual_until(

src/components/datetime.rs

@@ -14,7 +14,11 @@ use crate::{
 use std::str::FromStr;
 use tinystr::TinyAsciiStr;
 
-use super::calendar::{CalendarDateLike, GetCalendarSlot};
+use super::{
+    calendar::{CalendarDateLike, GetCalendarSlot},
+    duration::normalized::NormalizedTimeDuration,
+    Duration,
+};
 
 /// The native Rust implementation of `Temporal.PlainDateTime`
 #[non_exhaustive]
@@ -51,6 +55,40 @@ impl<C: CalendarProtocol> DateTime<C> {
         let iso = IsoDateTime::from_epoch_nanos(&instant.nanos, offset)?;
         Ok(Self { iso, calendar })
     }
+
+    // 5.5.14 AddDurationToOrSubtractDurationFromPlainDateTime ( operation, dateTime, temporalDurationLike, options )
+    fn add_or_subtract_duration(
+        &self,
+        duration: &Duration,
+        overflow: Option<ArithmeticOverflow>,
+        context: &mut C::Context,
+    ) -> TemporalResult<Self> {
+        // SKIP: 1, 2, 3, 4
+        // 1. If operation is subtract, let sign be -1. Otherwise, let sign be 1.
+        // 2. Let duration be ? ToTemporalDurationRecord(temporalDurationLike).
+        // 3. Set options to ? GetOptionsObject(options).
+        // 4. Let calendarRec be ? CreateCalendarMethodsRecord(dateTime.[[Calendar]], « date-add »).
+
+        // 5. Let norm be NormalizeTimeDuration(sign × duration.[[Hours]], sign × duration.[[Minutes]], sign × duration.[[Seconds]], sign × duration.[[Milliseconds]], sign × duration.[[Microseconds]], sign × duration.[[Nanoseconds]]).
+        let norm = NormalizedTimeDuration::from_time_duration(duration.time());
+
+        // TODO: validate Constrain is default with all the recent changes.
+        // 6. Let result be ? AddDateTime(dateTime.[[ISOYear]], dateTime.[[ISOMonth]], dateTime.[[ISODay]], dateTime.[[ISOHour]], dateTime.[[ISOMinute]], dateTime.[[ISOSecond]], dateTime.[[ISOMillisecond]], dateTime.[[ISOMicrosecond]], dateTime.[[ISONanosecond]], calendarRec, sign × duration.[[Years]], sign × duration.[[Months]], sign × duration.[[Weeks]], sign × duration.[[Days]], norm, options).
+        let result = self.iso.add_date_duration(
+            self.calendar(),
+            duration.date(),
+            norm,
+            overflow,
+            context,
+        )?;
+
+        // 7. Assert: IsValidISODate(result.[[Year]], result.[[Month]], result.[[Day]]) is true.
+        // 8. Assert: IsValidTime(result.[[Hour]], result.[[Minute]], result.[[Second]], result.[[Millisecond]], result.[[Microsecond]], result.[[Nanosecond]]) is true.
+        assert!(result.is_within_limits());
+
+        // 9. Return ? CreateTemporalDateTime(result.[[Year]], result.[[Month]], result.[[Day]], result.[[Hour]], result.[[Minute]], result.[[Second]], result.[[Millisecond]], result.[[Microsecond]], result.[[Nanosecond]], dateTime.[[Calendar]]).
+        Ok(Self::new_unchecked(result, self.calendar.clone()))
+    }
 }
 
 // ==== Public DateTime API ====
@@ -166,7 +204,6 @@ impl<C: CalendarProtocol> DateTime<C> {
 
 // ==== Calendar-derived public API ====
 
-// TODO: Revert to `DateTime<C>`.
 impl DateTime<()> {
     /// Returns the calendar year value.
     pub fn year(&self) -> TemporalResult<i32> {
@@ -245,6 +282,24 @@ impl DateTime<()> {
         self.calendar
             .in_leap_year(&CalendarDateLike::DateTime(self.clone()), &mut ())
     }
+
+    #[inline]
+    pub fn add(
+        &self,
+        duration: &Duration,
+        overflow: Option<ArithmeticOverflow>,
+    ) -> TemporalResult<Self> {
+        self.contextual_add(duration, overflow, &mut ())
+    }
+
+    #[inline]
+    pub fn subtract(
+        &self,
+        duration: &Duration,
+        overflow: Option<ArithmeticOverflow>,
+    ) -> TemporalResult<Self> {
+        self.contextual_subtract(duration, overflow, &mut ())
+    }
 }
 
 impl<C: CalendarProtocol> DateTime<C> {
@@ -355,6 +410,26 @@ impl<C: CalendarProtocol> DateTime<C> {
         this.get_calendar()
             .in_leap_year(&CalendarDateLike::CustomDateTime(this.clone()), context)
     }
+
+    #[inline]
+    pub fn contextual_add(
+        &self,
+        duration: &Duration,
+        overflow: Option<ArithmeticOverflow>,
+        context: &mut C::Context,
+    ) -> TemporalResult<Self> {
+        self.add_or_subtract_duration(duration, overflow, context)
+    }
+
+    #[inline]
+    pub fn contextual_subtract(
+        &self,
+        duration: &Duration,
+        overflow: Option<ArithmeticOverflow>,
+        context: &mut C::Context,
+    ) -> TemporalResult<Self> {
+        self.add_or_subtract_duration(&duration.negated(), overflow, context)
+    }
 }
 
 // ==== Trait impls ====
@@ -408,7 +483,10 @@ impl<C: CalendarProtocol> FromStr for DateTime<C> {
 mod tests {
     use std::str::FromStr;
 
-    use crate::components::calendar::CalendarSlot;
+    use crate::{
+        components::{calendar::CalendarSlot, Duration},
+        iso::{IsoDate, IsoTime},
+    };
 
     use super::DateTime;
 
@@ -429,20 +507,118 @@ mod tests {
             0,
             CalendarSlot::from_str("iso8601").unwrap(),
         );
-        let positive_limit = DateTime::<()>::new(
-            275_760,
-            9,
-            14,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            CalendarSlot::from_str("iso8601").unwrap(),
-        );
+        let positive_limit =
+            DateTime::<()>::new(275_760, 9, 14, 0, 0, 0, 0, 0, 0, CalendarSlot::default());
 
         assert!(negative_limit.is_err());
         assert!(positive_limit.is_err());
     }
+
+    // options-undefined.js
+    #[test]
+    fn datetime_add_test() {
+        let pdt = DateTime::<()>::new(
+            2020,
+            1,
+            31,
+            12,
+            34,
+            56,
+            987,
+            654,
+            321,
+            CalendarSlot::default(),
+        )
+        .unwrap();
+
+        let result = pdt.add(&Duration::one_month(1.0), None).unwrap();
+
+        assert_eq!(result.month(), Ok(2));
+        assert_eq!(result.day(), Ok(29));
+    }
+
+    // options-undefined.js
+    #[test]
+    fn datetime_subtract_test() {
+        let pdt = DateTime::<()>::new(
+            2000,
+            3,
+            31,
+            12,
+            34,
+            56,
+            987,
+            654,
+            321,
+            CalendarSlot::default(),
+        )
+        .unwrap();
+
+        let result = pdt.subtract(&Duration::one_month(1.0), None).unwrap();
+
+        assert_eq!(result.month(), Ok(2));
+        assert_eq!(result.day(), Ok(29));
+    }
+
+    // subtract/hour-overflow.js
+    #[test]
+    fn datetime_subtract_hour_overflows() {
+        let dt = DateTime::<()>::new(
+            2019,
+            10,
+            29,
+            10,
+            46,
+            38,
+            271,
+            986,
+            102,
+            CalendarSlot::default(),
+        )
+        .unwrap();
+
+        let result = dt.subtract(&Duration::hour(12.0), None).unwrap();
+
+        assert_eq!(
+            result.iso.date,
+            IsoDate {
+                year: 2019,
+                month: 10,
+                day: 28
+            }
+        );
+        assert_eq!(
+            result.iso.time,
+            IsoTime {
+                hour: 22,
+                minute: 46,
+                second: 38,
+                millisecond: 271,
+                microsecond: 986,
+                nanosecond: 102
+            }
+        );
+
+        let result = dt.add(&Duration::hour(-12.0), None).unwrap();
+
+        assert_eq!(
+            result.iso.date,
+            IsoDate {
+                year: 2019,
+                month: 10,
+                day: 28
+            }
+        );
+        assert_eq!(
+            result.iso.time,
+            IsoTime {
+                hour: 22,
+                minute: 46,
+                second: 38,
+                millisecond: 271,
+                microsecond: 986,
+                nanosecond: 102
+            }
+        );
+    }
 }

src/components/duration.rs

@@ -47,6 +47,16 @@ pub struct Duration {
 //   - Methods (private/public/feature)
 //
 
+#[cfg(test)]
+impl Duration {
+    pub(crate) fn hour(value: f64) -> Self {
+        Self::new_unchecked(
+            DateDuration::default(),
+            TimeDuration::new_unchecked(value, 0.0, 0.0, 0.0, 0.0, 0.0),
+        )
+    }
+}
+
 // ==== Private Creation methods ====
 
 impl Duration {

src/components/duration/date.rs

@@ -500,11 +500,7 @@ impl DateDuration {
                 // i. Let dateAdd be unused.
 
                 // e. Let yearsLater be ? AddDate(calendar, plainRelativeTo, yearsDuration, undefined, dateAdd).
-                let years_later = plain_relative_to.add_date(
-                    &years_duration,
-                    ArithmeticOverflow::Constrain,
-                    context,
-                )?;
+                let years_later = plain_relative_to.add_date(&years_duration, None, context)?;
 
                 // f. Let yearsMonthsWeeks be ! CreateTemporalDuration(years, months, weeks, 0, 0, 0, 0, 0, 0, 0).
                 let years_months_weeks = Duration::new_unchecked(
@@ -513,11 +509,8 @@ impl DateDuration {
                 );
 
                 // g. Let yearsMonthsWeeksLater be ? AddDate(calendar, plainRelativeTo, yearsMonthsWeeks, undefined, dateAdd).
-                let years_months_weeks_later = plain_relative_to.add_date(
-                    &years_months_weeks,
-                    ArithmeticOverflow::Constrain,
-                    context,
-                )?;
+                let years_months_weeks_later =
+                    plain_relative_to.add_date(&years_months_weeks, None, context)?;
 
                 // h. Let monthsWeeksInDays be DaysUntil(yearsLater, yearsMonthsWeeksLater).
                 let months_weeks_in_days = years_later.days_until(&years_months_weeks_later);
@@ -609,23 +602,17 @@ impl DateDuration {
                 // i. Let dateAdd be unused.
 
                 // e. Let yearsMonthsLater be ? AddDate(calendar, plainRelativeTo, yearsMonths, undefined, dateAdd).
-                let years_months_later = plain_relative_to.add_date(
-                    &years_months,
-                    ArithmeticOverflow::Constrain,
-                    context,
-                )?;
+                let years_months_later =
+                    plain_relative_to.add_date(&years_months, None, context)?;
 
                 // f. Let yearsMonthsWeeks be ! CreateTemporalDuration(years, months, weeks, 0, 0, 0, 0, 0, 0, 0).
                 let years_months_weeks = Duration::from_date_duration(
                     &DateDuration::new_unchecked(self.years, self.months, self.weeks, 0.0),
                 );
 
                 // g. Let yearsMonthsWeeksLater be ? AddDate(calendar, plainRelativeTo, yearsMonthsWeeks, undefined, dateAdd).
-                let years_months_weeks_later = plain_relative_to.add_date(
-                    &years_months_weeks,
-                    ArithmeticOverflow::Constrain,
-                    context,
-                )?;
+                let years_months_weeks_later =
+                    plain_relative_to.add_date(&years_months_weeks, None, context)?;
 
                 // h. Let weeksInDays be DaysUntil(yearsMonthsLater, yearsMonthsWeeksLater).
                 let weeks_in_days = years_months_later.days_until(&years_months_weeks_later);