Further normalize MWDs, add Vancouver and Santiago tests (#504)

We were not handling the fact that the "first Friday of the month" is
not necessarily after the "first sunday of the month".

There's a case to be made here that this logic isn't worth it and we
should just normalize the Mwds to `Seconds` instead of trying to turn
them into something comparable. I don't have a strong opinion there,
someone who wants to look into that can benchmark it.

This also adds some tests for America/Santiago, which has some fun
quirks I discovered.

Author: Manishearth

src/builtins/compiled/zoneddatetime.rs

@@ -666,6 +666,28 @@ mod tests {
 
     const TROLL_FIRST_TRANSITION: &str = "2005-03-27T03:00:00+02:00[Antarctica/Troll]";
 
+    /// Vancouver transitions on the first Sunday in November, which may or may not be
+    /// before the first Friday in November
+    const VANCOUVER_FIRST_FRIDAY_IN_NOVEMBER_BEFORE_SUNDAY: &str =
+        "2019-11-01T00:00:00-07:00[America/Vancouver]";
+    const VANCOUVER_FIRST_FRIDAY_IN_NOVEMBER_AFTER_SUNDAY: &str =
+        "2019-11-06T00:00:00-08:00[America/Vancouver]";
+
+    /// Chile tzdb has a transition on the "first saturday in april", except the transition occurs
+    /// at 24:00:00, which is, of course, the day after. This is not the same thing as the first Sunday in April
+    const SANTIAGO_DST_2024: &str = "2024-09-08T01:00:00-03:00[America/Santiago]";
+    const SANTIAGO_STD_2025_APRIL: &str = "2025-04-05T23:00:00-04:00[America/Santiago]";
+    const SANTIAGO_STD_2025_APRIL_PLUS_ONE: &str =
+        "2025-04-05T23:00:00.000000001-04:00[America/Santiago]";
+    const SANTIAGO_STD_2025_APRIL_MINUS_ONE: &str =
+        "2025-04-05T23:59:59.999999999-03:00[America/Santiago]";
+    const SANTIAGO_DST_2025_SEPT: &str = "2025-09-07T01:00:00-03:00[America/Santiago]";
+    const SANTIAGO_DST_2025_SEPT_PLUS_ONE: &str =
+        "2025-09-07T01:00:00.000000001-03:00[America/Santiago]";
+    const SANTIAGO_DST_2025_SEPT_MINUS_ONE: &str =
+        "2025-09-06T23:59:59.999999999-04:00[America/Santiago]";
+    const SANTIAGO_STD_2026: &str = "2026-04-04T23:00:00-04:00[America/Santiago]";
+
     // MUST only contain full strings
     // The second boolean is whether these are unambiguous when the offset is removed
     // As a rule of thumb, anything around an STD->DST transition
@@ -698,6 +720,16 @@ mod tests {
         (LONDON_POSIX_TRANSITION_2017_03_26_MINUS_ONE, true),
         (LONDON_POSIX_TRANSITION_2017_03_26_MINUS_ONE, true),
         (TROLL_FIRST_TRANSITION, true),
+        (VANCOUVER_FIRST_FRIDAY_IN_NOVEMBER_BEFORE_SUNDAY, true),
+        (VANCOUVER_FIRST_FRIDAY_IN_NOVEMBER_AFTER_SUNDAY, true),
+        (SANTIAGO_DST_2024, true),
+        (SANTIAGO_STD_2025_APRIL, false),
+        (SANTIAGO_STD_2025_APRIL_PLUS_ONE, false),
+        (SANTIAGO_STD_2025_APRIL_MINUS_ONE, false),
+        (SANTIAGO_DST_2025_SEPT, true),
+        (SANTIAGO_DST_2025_SEPT_PLUS_ONE, true),
+        (SANTIAGO_DST_2025_SEPT_MINUS_ONE, true),
+        (SANTIAGO_STD_2026, false),
     ];
 
     #[test]
@@ -766,6 +798,28 @@ mod tests {
         assert_tr(&zdt, Previous, STD_1998_01_31);
         assert_tr(&zdt, Next, DST_1999_04_04);
 
+        // Santiago tests, testing that transitions with the offset = 24:00:00
+        // still work
+        let zdt = parse_zdt_with_reject(SANTIAGO_DST_2025_SEPT_MINUS_ONE).unwrap();
+        assert_tr(&zdt, Previous, SANTIAGO_STD_2025_APRIL);
+        assert_tr(&zdt, Next, SANTIAGO_DST_2025_SEPT);
+        let zdt = parse_zdt_with_reject(SANTIAGO_DST_2025_SEPT).unwrap();
+        assert_tr(&zdt, Previous, SANTIAGO_STD_2025_APRIL);
+        assert_tr(&zdt, Next, SANTIAGO_STD_2026);
+        let zdt = parse_zdt_with_reject(SANTIAGO_DST_2025_SEPT_PLUS_ONE).unwrap();
+        assert_tr(&zdt, Previous, SANTIAGO_DST_2025_SEPT);
+        assert_tr(&zdt, Next, SANTIAGO_STD_2026);
+
+        let zdt = parse_zdt_with_reject(SANTIAGO_STD_2025_APRIL_MINUS_ONE).unwrap();
+        assert_tr(&zdt, Previous, SANTIAGO_DST_2024);
+        assert_tr(&zdt, Next, SANTIAGO_STD_2025_APRIL);
+        let zdt = parse_zdt_with_reject(SANTIAGO_STD_2025_APRIL).unwrap();
+        assert_tr(&zdt, Previous, SANTIAGO_DST_2024);
+        assert_tr(&zdt, Next, SANTIAGO_DST_2025_SEPT);
+        let zdt = parse_zdt_with_reject(SANTIAGO_STD_2025_APRIL_PLUS_ONE).unwrap();
+        assert_tr(&zdt, Previous, SANTIAGO_STD_2025_APRIL);
+        assert_tr(&zdt, Next, SANTIAGO_DST_2025_SEPT);
+
         // Test case from intl402/Temporal/ZonedDateTime/prototype/getTimeZoneTransition/rule-change-without-offset-transition
         // This ensures we skip "fake" transition entries that do not actually change the offset
 

src/tzdb.rs

@@ -1056,13 +1056,24 @@ impl Mwd {
     fn from_u8(month: u8, week: u8, day: u8) -> Self {
         Self { month, week, day }
     }
+
+    /// Given the day of the week of the 0th day in this month,
+    /// normalize the week to being a week number (1 = first week, ...)
+    /// rather than a weekday ordinal (1 = first friday, etc)
+    fn normalize_to_week_number(&mut self, day_of_week_zeroth_day: u8) {
+        if self.day <= day_of_week_zeroth_day {
+            self.week += 1;
+        }
+    }
 }
 
 /// Represents an MWD for a given time
 #[derive(Debug)]
 struct MwdForTime {
     /// This will never have day = 5
     mwd: Mwd,
+    /// The day of the week of the 0th day (the day before the month starts)
+    day_of_week_zeroth_day: u8,
     /// This is the day of week of the 29th and the last day of the month,
     /// if the month has more than 28 days.
     /// Basically, this is the start and end of the "fifth $weekday of the month" period
@@ -1074,21 +1085,24 @@ impl MwdForTime {
         let (year, month, day_of_month) = utils::ymd_from_epoch_milliseconds(seconds * 1_000);
         let week_of_month = day_of_month / 7 + 1;
         let day_of_week = utils::epoch_seconds_to_day_of_week(seconds);
-        let mwd = Mwd::from_u8(month, week_of_month, day_of_week);
+        let mut mwd = Mwd::from_u8(month, week_of_month, day_of_week);
         let days_in_month = utils::iso_days_in_month(year, month);
+        let day_of_week_zeroth_day =
+            (i16::from(day_of_week) - i16::from(day_of_month)).rem_euclid(7) as u8;
+        mwd.normalize_to_week_number(day_of_week_zeroth_day);
         if day_of_month > 28 {
-            let day_of_week_zeroth_day =
-                (i16::from(day_of_week) - i16::from(day_of_month)).rem_euclid(7) as u8;
             let day_of_week_day_29 = (day_of_week_zeroth_day + 29).rem_euclid(7);
             let day_of_week_last_day = (day_of_week_zeroth_day + days_in_month).rem_euclid(7);
             Self {
                 mwd,
+                day_of_week_zeroth_day,
                 extra_days: Some((day_of_week_day_29, day_of_week_last_day)),
             }
         } else {
             // No day 5
             Self {
                 mwd,
+                day_of_week_zeroth_day,
                 extra_days: None,
             }
         }
@@ -1097,27 +1111,38 @@ impl MwdForTime {
     /// MWDs from Posix data can contain `w=5`, which means the *last* $weekday of the month,
     /// not the 5th. For MWDs in the same month, this normalizes the 5 to the actual number of the
     /// last weekday of the month (5 or 4)
+    ///
+    /// Furthermore, this turns the week number into a true week number: the "second friday in March"
+    /// will be turned into "the friday in the first week of March" or "the Friday in the second week of March"
+    /// depending on when March starts.
+    ///
+    /// This normalization *only* applies to MWDs in the same month. For other MWDs, such normalization is irrelevant.
     fn normalize_mwd(&self, other: &mut Mwd) {
-        // If we're in the same month, and the other mwd is looking for
-        // the last $weekday in the month, we need special handling
-        if self.mwd.month == other.month && other.week == 5 {
-            if let Some((day_29, last_day)) = self.extra_days {
-                if day_29 < last_day {
-                    if other.day < day_29 || other.day > last_day {
-                        // This day isn't found in the last week. Subtract one.
-                        other.week = 4;
+        // If we're in the same month, normalization will actually have a useful effect
+        if self.mwd.month == other.month {
+            // First normalize MWDs that are like "the last $weekday in the month"
+            // the last $weekday in the month, we need special handling
+            if other.week == 5 {
+                if let Some((day_29, last_day)) = self.extra_days {
+                    if day_29 < last_day {
+                        if other.day < day_29 || other.day > last_day {
+                            // This day isn't found in the last week. Subtract one.
+                            other.week = 4;
+                        }
+                    } else {
+                        // The extra part of the month crosses Sunday
+                        if other.day < day_29 && other.day > last_day {
+                            // This day isn't found in the last week. Subtract one.
+                            other.week = 4;
+                        }
                     }
                 } else {
-                    // The extra part of the month crosses Sunday
-                    if other.day < day_29 && other.day > last_day {
-                        // This day isn't found in the last week. Subtract one.
-                        other.week = 4;
-                    }
+                    // There is no week 5 in this month, normalize to 4
+                    other.week = 4;
                 }
-            } else {
-                // There is no week 5 in this month, normalize to 4
-                other.week = 4;
             }
+
+            other.normalize_to_week_number(self.day_of_week_zeroth_day);
         }
     }
 }