Fix TimeZone::get_possible_epoch_ns at date-time limits (#580)

The `is_valid_day_range()` check was based on an erroneous line in the
Temporal spec, see tc39/proposal-temporal#3151.
This PR removes that check, and adds a `get_possible_epoch_ns` unit test
for the affected cases.

For the unit test it was convenient to have CandidateEpochNanoseconds
and EpochNanosecondsAndOffset implement PartialEq. Please let me know if
that's not desired and I'll do it another way.

The second commit is a cleanup, not necessary for the bug fix. Feel free
to drop it if you prefer not to have it. While I was fixing the above, I
noticed that in most places the `to_epoch_days` value is cast to i32 and
then immediately back to i64, so I changed the return type to i64 and
instead moved the cast to the place where i32 is actually needed.

Author: ptomato

provider/src/provider.rs

@@ -30,9 +30,8 @@ pub struct IsoDateTime {
 }
 
 impl IsoDateTime {
-    fn to_epoch_days(self) -> i32 {
-        // NOTE: cast to i32 is safe as IsoDate is in a valid range.
-        utils::epoch_days_from_gregorian_date(self.year, self.month, self.day) as i32
+    fn to_epoch_days(self) -> i64 {
+        utils::epoch_days_from_gregorian_date(self.year, self.month, self.day)
     }
     /// `IsoTimeToEpochMs`
     ///
@@ -49,7 +48,7 @@ impl IsoDateTime {
     /// Convert this datetime to nanoseconds since the Unix epoch
     pub fn as_nanoseconds(&self) -> EpochNanoseconds {
         let time_ms = self.time_to_epoch_ms();
-        let epoch_ms = utils::epoch_days_to_epoch_ms(self.to_epoch_days() as i64, time_ms);
+        let epoch_ms = utils::epoch_days_to_epoch_ms(self.to_epoch_days(), time_ms);
         EpochNanoseconds(
             epoch_ms as i128 * 1_000_000
                 + self.microsecond as i128 * 1_000
@@ -78,7 +77,7 @@ impl From<LocalTimeTypeRecord> for UtcOffsetSeconds {
 }
 
 /// An EpochNanoseconds and a UTC offset
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub struct EpochNanosecondsAndOffset {
     /// The resolved nanoseconds value
     pub ns: EpochNanoseconds,
@@ -135,7 +134,7 @@ pub struct GapEntryOffsets {
 }
 
 /// The potential candidates for a given local datetime
-#[derive(Copy, Clone, Debug)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 pub enum CandidateEpochNanoseconds {
     Zero(GapEntryOffsets),
     One(EpochNanosecondsAndOffset),

src/builtins/core/plain_date.rs

@@ -308,7 +308,10 @@ impl PlainDate {
     #[inline]
     #[must_use]
     fn days_until(&self, other: &Self) -> i32 {
-        other.iso.to_epoch_days() - self.iso.to_epoch_days()
+        // NOTE: cast to i32 is safe as both IsoDates must be in valid range.
+        debug_assert!(self.iso.check_within_limits().is_ok());
+        debug_assert!(other.iso.check_within_limits().is_ok());
+        (other.iso.to_epoch_days() - self.iso.to_epoch_days()) as i32
     }
 
     /// Returns this `PlainDate`'s ISO year value.

src/builtins/core/time_zone.rs

@@ -416,9 +416,7 @@ impl TimeZone {
             }
             // 3. Else,
             Self::IanaIdentifier(identifier) => {
-                // a. Perform ? CheckISODaysRange(isoDateTime.[[ISODate]]).
-                local_iso.date.is_valid_day_range()?;
-                // b. Let possibleEpochNanoseconds be
+                // a. Let possibleEpochNanoseconds be
                 // GetNamedTimeZoneEpochNanoseconds(parseResult.[[Name]],
                 // isoDateTime).
                 provider.candidate_nanoseconds_for_local_epoch_nanoseconds(
@@ -625,4 +623,63 @@ mod tests {
             .time_zone_equals_with_provider(&kolkata, &*crate::builtins::TZ_PROVIDER)
             .unwrap());
     }
+
+    #[cfg(feature = "compiled_data")]
+    fn test_possible_epoch_ns_at_limits_helper(
+        time_zone_identifier: &str,
+        offset_sec_at_min: i64,
+        offset_sec_at_max: i64,
+    ) {
+        use crate::iso::IsoDateTime;
+        use crate::provider::{
+            CandidateEpochNanoseconds, EpochNanosecondsAndOffset, UtcOffsetSeconds,
+        };
+        use crate::unix_time::EpochNanoseconds;
+        use crate::{NS_MAX_INSTANT, NS_MIN_INSTANT};
+
+        let provider = &*crate::builtins::TZ_PROVIDER;
+
+        let time_zone = TimeZone::try_from_identifier_str(time_zone_identifier).unwrap();
+
+        let min = IsoDateTime::balance(-271821, 4, 20, 0, 0, offset_sec_at_min, 0, 0, 0);
+        let min_result = time_zone.get_possible_epoch_ns_for(min, provider).unwrap();
+        assert_eq!(
+            min_result,
+            CandidateEpochNanoseconds::One(EpochNanosecondsAndOffset {
+                ns: EpochNanoseconds(NS_MIN_INSTANT),
+                offset: UtcOffsetSeconds(offset_sec_at_min)
+            })
+        );
+
+        let max = IsoDateTime::balance(275760, 9, 13, 0, 0, offset_sec_at_max, 0, 0, 0);
+        let max_result = time_zone.get_possible_epoch_ns_for(max, provider).unwrap();
+        assert_eq!(
+            max_result,
+            CandidateEpochNanoseconds::One(EpochNanosecondsAndOffset {
+                ns: EpochNanoseconds(NS_MAX_INSTANT),
+                offset: UtcOffsetSeconds(offset_sec_at_max)
+            })
+        );
+
+        let too_early = IsoDateTime::balance(-271821, 4, 20, 0, 0, offset_sec_at_min, 0, 0, -1);
+        assert!(time_zone
+            .get_possible_epoch_ns_for(too_early, provider)
+            .is_err());
+
+        let too_late = IsoDateTime::balance(275760, 9, 13, 0, 0, offset_sec_at_max, 0, 0, 1);
+        assert!(time_zone
+            .get_possible_epoch_ns_for(too_late, provider)
+            .is_err());
+    }
+
+    #[test]
+    #[cfg(feature = "compiled_data")]
+    fn test_possible_epoch_ns_at_limits() {
+        test_possible_epoch_ns_at_limits_helper("UTC", 0, 0);
+        test_possible_epoch_ns_at_limits_helper("+02:00", 7200, 7200);
+        test_possible_epoch_ns_at_limits_helper("-07:00", -25200, -25200);
+        test_possible_epoch_ns_at_limits_helper("Europe/Amsterdam", 1050, 7200);
+        test_possible_epoch_ns_at_limits_helper("America/Vancouver", -29548, -25200);
+        test_possible_epoch_ns_at_limits_helper("Australia/Sydney", 36292, 36000);
+    }
 }

src/iso.rs

@@ -362,9 +362,8 @@ impl IsoDate {
     ///
     /// Equivalent to `IsoDateToEpochDays`
     #[inline]
-    pub(crate) fn to_epoch_days(self) -> i32 {
-        // NOTE: cast to i32 is safe as IsoDate is in a valid range.
-        utils::epoch_days_from_gregorian_date(self.year, self.month, self.day) as i32
+    pub(crate) fn to_epoch_days(self) -> i64 {
+        utils::epoch_days_from_gregorian_date(self.year, self.month, self.day)
     }
 
     /// Returns if the current `IsoDate` is valid.
@@ -903,7 +902,7 @@ fn utc_epoch_nanos(date: IsoDate, time: &IsoTime) -> EpochNanoseconds {
 #[inline]
 fn to_unchecked_epoch_nanoseconds(date: IsoDate, time: &IsoTime) -> i128 {
     let ms = time.to_epoch_ms();
-    let epoch_ms = utils::epoch_days_to_epoch_ms(date.to_epoch_days() as i64, ms);
+    let epoch_ms = utils::epoch_days_to_epoch_ms(date.to_epoch_days(), ms);
     epoch_ms as i128 * 1_000_000 + time.microsecond as i128 * 1_000 + time.nanosecond as i128
 }