Fix failing tests

Author: HalidOdat

src/builtins/core/duration.rs

@@ -106,6 +106,19 @@ impl Duration {
             TimeDuration::new_unchecked(value, 0, 0, 0, 0, 0),
         )
     }
+
+    // /// `7.5.6 ToInternalDurationRecordWith24HourDays ( duration )`
+    // ///
+    // /// Spec: <https://tc39.es/proposal-temporal/#sec-temporal-tointernaldurationrecordwith24hourdays>
+    // fn to_internal_record_with_24_hour_days(&self) -> NormalizedTimeDuration {
+    //     // 1. Let timeDuration be TimeDurationFromComponents(duration.[[Hours]], duration.[[Minutes]], duration.[[Seconds]], duration.[[Milliseconds]], duration.[[Microseconds]], duration.[[Nanoseconds]]).
+    //     let time_duration = self.time;
+
+    //     // 2. Set timeDuration to ! Add24HourDaysToTimeDuration(timeDuration, duration.[[Days]]).
+    //     time_duration
+    //     // 3. Let dateDuration be ! CreateDateDurationRecord(duration.[[Years]], duration.[[Months]], duration.[[Weeks]], 0).
+    //     // 4. Return CombineDateAndTimeDuration(dateDuration, timeDuration).
+    // }
 }
 
 // ==== Private Creation methods ====
@@ -755,17 +768,24 @@ impl Duration {
                     .add_normalized_time_duration(internal_duration.normalized_time_duration());
 
                 // c. Let calendar be plainRelativeTo.[[Calendar]].
-                let calendar = plain_relative_to.calendar().clone();
+                let calendar = plain_relative_to.calendar();
 
                 // d. Let dateDuration be ! AdjustDateDurationRecord(internalDuration.[[Date]], targetTime.[[Days]]).
-                let date_duration = self.date.adjust(target_time_days, None, None)?;
+                let date_duration =
+                    internal_duration
+                        .date()
+                        .adjust(target_time_days, None, None)?;
 
                 // e. Let targetDate be ? CalendarDateAdd(calendar, plainRelativeTo.[[ISODate]], dateDuration, constrain).
-                let target_date = calendar.date_add(
-                    &plain_relative_to.iso,
+                let target_date = plain_relative_to.add_date(
                     &Duration::from(date_duration),
-                    ArithmeticOverflow::Constrain,
+                    Some(ArithmeticOverflow::Constrain),
                 )?;
+                // let target_date = calendar.date_add(
+                //     &plain_relative_to.iso,
+                //     &Duration::from(date_duration),
+                //     ArithmeticOverflow::Constrain,
+                // )?;
 
                 // f. Let isoDateTime be CombineISODateAndTimeRecord(plainRelativeTo.[[ISODate]], MidnightTimeRecord()).
                 let iso_date_time =
@@ -775,11 +795,12 @@ impl Duration {
                 let target_date_time = IsoDateTime::new_unchecked(target_date.iso, target_time.iso);
 
                 // h. Set internalDuration to ? DifferencePlainDateTimeWithRounding(isoDateTime, targetDateTime, calendar, largestUnit, roundingIncrement, smallestUnit, roundingMode).
-                let internal_duration = iso_date_time.diff(
-                    &target_date_time,
-                    &calendar,
-                    resolved_options.largest_unit,
-                )?;
+                let internal_duration =
+                    PlainDateTime::new_unchecked(iso_date_time, calendar.clone())
+                        .diff_dt_with_rounding(
+                            &PlainDateTime::new_unchecked(target_date_time, calendar.clone()),
+                            resolved_options,
+                        )?;
 
                 // i. Return ? TemporalDurationFromInternal(internalDuration, largestUnit).
                 return Duration::from_normalized(internal_duration, resolved_options.largest_unit);

src/builtins/core/duration/normalized.rs

@@ -254,7 +254,9 @@ impl NormalizedDurationRecord {
         Ok(Self { date, norm })
     }
 
-    /// Equivalent of 7.5.6
+    /// Equivalent of `7.5.6 ToInternalDurationRecordWith24HourDays ( duration )`
+    ///
+    /// Spec: <https://tc39.es/proposal-temporal/#sec-temporal-tointernaldurationrecordwith24hourdays>
     pub(crate) fn from_duration_with_24_hour_days(duration: &Duration) -> TemporalResult<Self> {
         // 1. Let timeDuration be TimeDurationFromComponents(duration.[[Hours]], duration.[[Minutes]],
         // duration.[[Seconds]], duration.[[Milliseconds]], duration.[[Microseconds]], duration.[[Nanoseconds]]).

src/builtins/core/time.rs

@@ -105,7 +105,9 @@ impl PlainTime {
         self.iso.is_valid()
     }
 
-    /// Specification equivalent to `AddTime`
+    /// Specification equivalent to `4.5.15 AddTime ( time, timeDuration )`
+    ///
+    /// Spec: <https://tc39.es/proposal-temporal/#sec-temporal-addtime>
     pub(crate) fn add_normalized_time_duration(&self, norm: NormalizedTimeDuration) -> (i64, Self) {
         // 1. Set second to second + NormalizedTimeDurationSeconds(norm).
         let second = i64::from(self.second()) + norm.seconds();