Allow constructing non-ISO monthdays

Author: Manishearth

Cargo.lock

@@ -241,9 +241,24 @@ impl Calendar {
             );
         }
 
-        // TODO: This may get complicated...
-        // For reference: https://github.com/tc39/proposal-temporal/blob/main/polyfill/lib/calendar.mjs#L1275.
-        Err(TemporalError::range().with_message("Not yet implemented/supported."))
+        // We trust ResolvedCalendarFields to have calculated an appropriate reference year for us
+        let calendar_date = self
+            .0
+            .from_codes(
+                resolved_fields.era_year.era.as_ref().map(|e| e.0.as_str()),
+                resolved_fields.era_year.year,
+                IcuMonthCode(resolved_fields.month_code.0),
+                resolved_fields.day,
+            )
+            .map_err(TemporalError::from_icu4x)?;
+        let iso = self.0.to_iso(&calendar_date);
+        PlainMonthDay::new_with_overflow(
+            Iso.month(&iso).ordinal,
+            Iso.day_of_month(&iso).0,
+            self.clone(),
+            overflow,
+            Some(Iso.extended_year(&iso)),
+        )
     }
 
     /// `CalendarPlainYearMonthFromFields`

src/builtins/core/calendar.rs

@@ -135,6 +135,24 @@ impl EraYear {
         resolution_type: ResolutionType,
     ) -> TemporalResult<Self> {
         match (partial.year, partial.era, partial.era_year) {
+            _ if resolution_type == ResolutionType::MonthDay => {
+                let day = partial
+                    .day
+                    .ok_or(TemporalError::assert().with_message("MonthDay must specify day"))?;
+                let arithmetic_year = Self::reference_arithmetic_year_for_month_day(
+                    &partial.calendar,
+                    partial.month_code,
+                    partial.month,
+                    day,
+                )?;
+                Ok(Self {
+                    // We should just specify these as arithmetic years, no need
+                    // to muck with eras
+                    era: None,
+                    arithmetic_year,
+                    year: arithmetic_year,
+                })
+            }
             (maybe_year, Some(era), Some(era_year)) => {
                 let Some(era_info) = partial.calendar.get_era_info(&era) else {
                     return Err(TemporalError::range().with_message("Invalid era provided."));
@@ -169,15 +187,96 @@ impl EraYear {
                 year,
                 arithmetic_year: year,
             }),
-            (None, None, None) if resolution_type == ResolutionType::MonthDay => Ok(Self {
-                era: None,
-                year: 1972,
-                arithmetic_year: 1972,
-            }),
             _ => Err(TemporalError::r#type()
                 .with_message("Required fields missing to determine an era and year.")),
         }
     }
+
+    fn reference_arithmetic_year_for_month_day(
+        calendar: &Calendar,
+        month_code: Option<MonthCode>,
+        ordinal_month: Option<u8>,
+        day: u8,
+    ) -> TemporalResult<i32> {
+        let ordinal_month_in_solar = || {
+            ordinal_month
+                .or_else(|| month_code.map(|c| MonthCode::to_month_integer(&c)))
+                .ok_or(TemporalError::assert().with_message("Neither month nor monthCode provided"))
+        };
+        // The reference date is the latest ISO 8601 date corresponding to the calendar date, that is also earlier than
+        // or equal to the ISO 8601 date December 31, 1972. If that calendar date never occurs on or before the ISO 8601 date December 31, 1972,
+        // then the reference date is the earliest ISO 8601 date corresponding to that calendar date.
+        // The reference year is almost always 1972 (the first ISO 8601 leap year after the epoch), with exceptions
+        // for calendars where some dates (e.g. leap days or days in leap months) didn't occur during that ISO 8601 year.
+        // For example, Hebrew calendar leap month Adar I occurred in calendar years 5730 and 5733 (respectively overlapping
+        // ISO 8601 February/March 1970 and February/March 1973), but did not occur between them, so the reference year for days of that month is 1970.
+
+        Ok(match calendar.kind() {
+            AnyCalendarKind::Iso | AnyCalendarKind::Gregorian => 1972,
+            // These calendars just wrap Gregorian with a different epoch
+            AnyCalendarKind::Buddhist => 1972 + 543,
+            AnyCalendarKind::Roc => 1972 - 1911,
+
+            AnyCalendarKind::Indian => {
+                let month = ordinal_month_in_solar()?;
+                // 1972-12-31 is y=1894 saka, m=10, d=10
+                // 1894 happens to be an Indian leap year (which happens at m=1 d=30)
+                if (month == 10 && day > 10) || month > 10 {
+                    // 1894 will produce dates after 1972. Return 1893 instead
+                    1893
+                } else {
+                    1894
+                }
+            }
+            AnyCalendarKind::Persian => {
+                let month = ordinal_month_in_solar()?;
+                // 1972-12-31 is y=1351 ap, m=10, d=10
+                // 1350 happens to be a Persian leap year (which happens at m=12 d=30)
+                if (month == 10 && day > 10) || month > 10 {
+                    // 1351 will produce dates after 1972. Return 1350 instead
+                    // This also handles the leap year
+                    1350
+                } else {
+                    1351
+                }
+            }
+            AnyCalendarKind::Hebrew => {
+                let Some(month_code) = month_code else {
+                    return Err(TemporalError::r#type().with_message(
+                        "Must specify month codes with MonthDay for lunar calendars",
+                    ));
+                };
+
+                // 1972-12-31 is y=5733 am, m=4, d=26. We must produce year 5723 or lower
+                if month_code.is_leap_month() {
+                    // 5730 is a leap year
+                    5730
+                } else {
+                    let month = month_code.to_month_integer();
+                    if (month == 4 && day == 26) || month > 4 {
+                        // 5733 will produce dates after 1972, return 5722 instead
+                        5732
+                    } else {
+                        // All months have 29 days
+                        if day <= 29 {
+                            5733
+                        // Ḥeshvan/Kislev only have 30 days sometimes
+                        // Fortunately 5732 has 30 days for both
+                        } else if month == 2 || month == 3 {
+                            5732
+                        } else {
+                            // Some other month, we don't actually need to check
+                            5733
+                        }
+                    }
+                }
+            }
+            _ => {
+                return Err(TemporalError::range()
+                    .with_message("Do not currently support MonthDay with this calendar"))
+            }
+        })
+    }
 }
 
 // MonthCode constants.

src/builtins/core/calendar/types.rs

@@ -70,6 +70,18 @@ impl PartialDate {
     crate::impl_with_fallback_method!(with_fallback_date, (with_day: day) PlainDate);
     crate::impl_with_fallback_method!(with_fallback_datetime, (with_day:day) PlainDateTime);
     crate::impl_field_keys_to_ignore!((with_day:day));
+
+    pub(crate) fn try_from_month_day(month_day: &PlainMonthDay) -> TemporalResult<Self> {
+        Ok(Self {
+            year: None,
+            month: None,
+            month_code: Some(month_day.month_code()),
+            era: None,
+            era_year: None,
+            day: Some(month_day.day()),
+            calendar: month_day.calendar().clone(),
+        })
+    }
 }
 
 /// The return value of CalendarFieldKeysToIgnore

src/builtins/core/date.rs

@@ -220,20 +220,13 @@ impl PlainMonthDay {
         iso.check_validity()?;
 
         // 13. Set result to ISODateToFields(calendar, isoDate, month-day).
+
+        let intermediate = Self::new_unchecked(iso, Calendar::new(parsed.calendar));
+        let partial = PartialDate::try_from_month_day(&intermediate)?;
         // 14. NOTE: The following operation is called with constrain regardless of the value of overflow, in
         // order for the calendar to store a canonical value in the [[Year]] field of the [[ISODate]] internal slot of the result.
         // 15. Set isoDate to ? CalendarMonthDayFromFields(calendar, result, constrain).
-
-        // TODO(Manishearth) this must tweak the year to something valid
-        // https://github.com/boa-dev/temporal/issues/450
-        // https://github.com/tc39/proposal-intl-era-monthcode/issues/60
-        Self::new_with_overflow(
-            parsed.record.month,
-            parsed.record.day,
-            calendar,
-            ArithmeticOverflow::Reject,
-            Some(parsed.record.year),
-        )
+        PlainMonthDay::from_partial(partial, Some(ArithmeticOverflow::Constrain))
     }
 
     /// Create a `PlainYearMonth` from a `PartialDate`
@@ -334,6 +327,12 @@ impl PlainMonthDay {
         self.calendar.day(&self.iso)
     }
 
+    /// Returns the internal reference year used by this MonthDay.
+    #[inline]
+    pub fn reference_year(&self) -> i32 {
+        self.calendar.year(&self.iso)
+    }
+
     /// Create a [`PlainDate`] from the current `PlainMonthDay`.
     pub fn to_plain_date(&self, year: Option<PartialDate>) -> TemporalResult<PlainDate> {
         let year_partial = match &year {
@@ -409,7 +408,6 @@ impl FromStr for PlainMonthDay {
 mod tests {
     use super::*;
     use crate::builtins::core::PartialDate;
-    use crate::Calendar;
     use tinystr::tinystr;
 
     #[test]
@@ -560,4 +558,77 @@ mod tests {
             assert!(PlainMonthDay::from_utf8(test.as_bytes()).is_err());
         }
     }
+
+    #[test]
+    fn test_reference_year() {
+        // monthCode, day, ISO string, expectedReferenceYear
+        // Some of these parsed strings are deliberately not using the reference year
+        // so that we can test all code paths. By default, when adding new strings, it is easier
+        // to just add the reference year
+        const TESTS: &[(&str, u8, &str, i32)] = &[
+            ("M10", 30, "1868-10-30[u-ca=gregory]", 1972),
+            ("M08", 8, "1868-10-30[u-ca=indian]", 1894),
+            ("M09", 21, "2000-12-12[u-ca=indian]", 1894),
+            // Dates in the earlier half of the year get pushed back a year
+            ("M10", 22, "2000-01-12[u-ca=indian]", 1893),
+            ("M01", 11, "2000-03-30[u-ca=persian]", 1351),
+            ("M09", 22, "2000-12-12[u-ca=persian]", 1351),
+            ("M12", 29, "2025-03-19[u-ca=persian]", 1350),
+            // Leap day
+            ("M12", 30, "2025-03-20[u-ca=persian]", 1350),
+            ("M01", 1, "2025-03-21[u-ca=persian]", 1351),
+            ("M01", 1, "2025-03-21[u-ca=persian]", 1351),
+            ("M01", 1, "1972-01-01[u-ca=roc]", 61),
+            ("M02", 29, "2024-02-29[u-ca=roc]", 61),
+            ("M12", 1, "1972-12-01[u-ca=roc]", 61),
+            ("M01", 1, "1972-09-09[u-ca=hebrew]", 5733),
+            ("M02", 29, "1972-11-06[u-ca=hebrew]", 5733),
+            ("M03", 29, "1972-12-05[u-ca=hebrew]", 5733),
+            ("M03", 30, "1971-12-18[u-ca=hebrew]", 5732),
+            ("M05L", 29, "1970-03-07[u-ca=hebrew]", 5730),
+            ("M07", 1, "1972-03-16[u-ca=hebrew]", 5732),
+        ];
+        let reference_iso = IsoDate::new_unchecked(1972, 12, 31);
+        for (month_code, day, string, year) in TESTS {
+            let md = PlainMonthDay::from_str(string).expect(string);
+
+            let partial = PartialDate {
+                month_code: Some(month_code.parse().unwrap()),
+                day: Some(*day),
+                calendar: md.calendar.clone(),
+                ..Default::default()
+            };
+
+            let md_from_partial =
+                PlainMonthDay::from_partial(partial, Some(ArithmeticOverflow::Reject)).unwrap();
+
+            assert_eq!(
+                md,
+                md_from_partial,
+                "Parsed {string}, compared with {}: Expected {}-{}, Found {}-{}",
+                md_from_partial.to_ixdtf_string(Default::default()),
+                md_from_partial.month_code().0,
+                md_from_partial.day(),
+                md.month_code().0,
+                md.day()
+            );
+
+            assert_eq!(
+                md_from_partial.reference_year(),
+                *year,
+                "Reference year for {string} ({}-{}) must be {year}",
+                month_code,
+                day
+            );
+
+            assert!(
+                md.iso <= reference_iso && md_from_partial.iso <= reference_iso,
+                "Reference ISO for {string} ({}-{}) must be before 1972-12-31, found, {:?} / {:?}",
+                md.month_code().0,
+                md.day(),
+                md.iso,
+                md_from_partial.iso
+            );
+        }
+    }
 }