Correctly check the RD range for Date::try_from_fields and Date::try_add*

components/calendar/fuzz/fuzz_targets/add.rs

@@ -41,50 +41,6 @@ impl From<DateDuration> for icu_calendar::types::DateDuration {
     }
 }
 
-impl DateDuration {
-    /// Temporal doesn't care about dates outside of -271821-04-20 to +275760-09-13
-    /// and will not let you attempt to add up to them even with overflow: constrain.
-    ///
-    /// We should eventually be applying some limits to this code in ICU4X.
-    /// We currently do not and `Date::try_added()` will panic for large `days` values.
-    ///
-    /// <https://github.com/unicode-org/icu4x/issues/3964>
-    ///
-    /// For now, fuzz what we can for Temporal's needs.
-    ///
-    /// This code is copied from <https://github.com/boa-dev/temporal/pull/615>
-    /// so that we are testing temporal_rs behavior.
-    fn is_valid_for_temporal(&self) -> bool {
-        // Temporal range is -271821-04-20 to +275760-09-13
-        // This is (roughly) the maximum year duration that can exist for ISO
-        const TEMPORAL_MAX_ISO_YEAR_DURATION: u32 = 275760 + 271821;
-        // Double it. No calendar has years that are half the size of ISO years.
-        const YEAR_DURATION: u32 = 2 * TEMPORAL_MAX_ISO_YEAR_DURATION;
-        // Assume every year is a leap year, calculate a month range
-        const MONTH_DURATION: u32 = YEAR_DURATION * 13;
-        // Our longest year is 390 days
-        const DAY_DURATION: u32 = YEAR_DURATION * 390;
-        const WEEK_DURATION: u32 = DAY_DURATION / 7;
-
-
-        if self.years > YEAR_DURATION {
-            return false;
-        }
-        if self.months > MONTH_DURATION {
-            return false;
-        }
-        if self.weeks > WEEK_DURATION {
-            return false;
-        }
-        if self.days > DAY_DURATION.into() {
-            return false;
-        }
-
-        true
-
-    }
-}
-
 fuzz_target!(|data: FuzzInput| {
     let Some(date) = data.ymd.to_date(data.cal, true) else { return };
 
@@ -94,8 +50,6 @@ fuzz_target!(|data: FuzzInput| {
     } else {
         Some(Overflow::Reject)
     };
-    if !data.duration.is_valid_for_temporal() {
-        return;
-    }
+
     let _ = date.try_added_with_options(data.duration.into(), options);
 });

components/calendar/fuzz/fuzz_targets/common.rs

@@ -4,7 +4,7 @@
 
 use arbitrary::Arbitrary;
 use icu_calendar::{Date, AnyCalendar};
-use icu_calendar::types::{DateFields, MonthCode};
+use icu_calendar::types::{DateFields, Month};
 use icu_calendar::options::*;
 
 
@@ -28,8 +28,6 @@ impl Ymd {
             Some(Overflow::Reject)
         };
 
-        let code: MonthCode;
-
         let mut fields = DateFields::default();
         fields.extended_year = Some(self.year);
         fields.day = Some(self.day);
@@ -93,7 +91,7 @@ impl From<AnyCalendarKind> for icu_calendar::AnyCalendarKind {
             AnyCalendarKind::HijriTabularTypeIIThursday => Self::HijriTabularTypeIIThursday,
             AnyCalendarKind::HijriUmmAlQura => Self::HijriUmmAlQura,
             AnyCalendarKind::Iso => Self::Iso,
-            AnyCalendarKind::Japanese | AnyCalendarKind::JapaneseExtended => Self::Japanese,
+            AnyCalendarKind::Japanese => Self::Japanese,
             AnyCalendarKind::Persian => Self::Persian,
             AnyCalendarKind::Roc => Self::Roc,
         }

components/calendar/src/any_calendar.rs

@@ -325,7 +325,7 @@ macro_rules! make_any_calendar {
                 date: &Self::DateInner,
                 duration: $crate::types::DateDuration,
                 options: $crate::options::DateAddOptions,
-            ) -> Result<Self::DateInner, $crate::DateError> {
+            ) -> Result<Self::DateInner, $crate::error::DateAddError> {
                 let mut date = *date;
                 match (self, &mut date) {
                     $(

components/calendar/src/cal/abstract_gregorian.rs

@@ -4,7 +4,9 @@
 
 use crate::cal::iso::{IsoDateInner, IsoEra};
 use crate::calendar_arithmetic::{ArithmeticDate, DateFieldsResolver};
-use crate::error::{DateError, DateFromFieldsError, EcmaReferenceYearError, UnknownEraError};
+use crate::error::{
+    DateAddError, DateError, DateFromFieldsError, EcmaReferenceYearError, UnknownEraError,
+};
 use crate::options::DateFromFieldsOptions;
 use crate::options::{DateAddOptions, DateDifferenceOptions};
 use crate::preferences::CalendarAlgorithm;
@@ -50,12 +52,12 @@ impl<Y: GregorianYears> DateFieldsResolver for AbstractGregorian<Y> {
     }
 
     #[inline]
-    fn year_info_from_era(
+    fn extended_year_from_era_year(
         &self,
         era: &[u8],
         era_year: i32,
-    ) -> Result<Self::YearInfo, UnknownEraError> {
-        Ok(self.0.extended_from_era_year(Some(era), era_year)? + Y::EXTENDED_YEAR_OFFSET)
+    ) -> Result<i32, UnknownEraError> {
+        self.0.extended_from_era_year(Some(era), era_year)
     }
 
     #[inline]
@@ -147,7 +149,7 @@ impl<Y: GregorianYears> Calendar for AbstractGregorian<Y> {
         date: &Self::DateInner,
         duration: types::DateDuration,
         options: DateAddOptions,
-    ) -> Result<Self::DateInner, DateError> {
+    ) -> Result<Self::DateInner, DateAddError> {
         date.added(duration, &AbstractGregorian(IsoEra), options)
     }
 
@@ -289,7 +291,7 @@ macro_rules! impl_with_abstract_gregorian {
                 date: &Self::DateInner,
                 duration: crate::types::DateDuration,
                 options: crate::options::DateAddOptions,
-            ) -> Result<Self::DateInner, DateError> {
+            ) -> Result<Self::DateInner, $crate::error::DateAddError> {
                 let $self_ident = self;
                 crate::cal::abstract_gregorian::AbstractGregorian($eras_expr)
                     .add(&date.0, duration, options)

components/calendar/src/cal/buddhist.rs

@@ -8,7 +8,7 @@ use crate::preferences::CalendarAlgorithm;
 use crate::{
     cal::abstract_gregorian::{impl_with_abstract_gregorian, GregorianYears},
     calendar_arithmetic::ArithmeticDate,
-    types, Date, DateError, RangeError,
+    types, Date, RangeError,
 };
 use tinystr::tinystr;
 

components/calendar/src/cal/coptic.rs

@@ -4,7 +4,9 @@
 
 use crate::calendar_arithmetic::ArithmeticDate;
 use crate::calendar_arithmetic::DateFieldsResolver;
-use crate::error::{DateError, DateFromFieldsError, EcmaReferenceYearError, UnknownEraError};
+use crate::error::{
+    DateAddError, DateError, DateFromFieldsError, EcmaReferenceYearError, UnknownEraError,
+};
 use crate::options::DateFromFieldsOptions;
 use crate::options::{DateAddOptions, DateDifferenceOptions};
 use crate::{types, Calendar, Date, RangeError};
@@ -66,11 +68,11 @@ impl DateFieldsResolver for Coptic {
     }
 
     #[inline]
-    fn year_info_from_era(
+    fn extended_year_from_era_year(
         &self,
         era: &[u8],
         era_year: i32,
-    ) -> Result<Self::YearInfo, UnknownEraError> {
+    ) -> Result<i32, UnknownEraError> {
         match era {
             b"am" => Ok(era_year),
             _ => Err(UnknownEraError),
@@ -184,7 +186,7 @@ impl Calendar for Coptic {
         date: &Self::DateInner,
         duration: types::DateDuration,
         options: DateAddOptions,
-    ) -> Result<Self::DateInner, DateError> {
+    ) -> Result<Self::DateInner, DateAddError> {
         date.0.added(duration, self, options).map(CopticDateInner)
     }
 

components/calendar/src/cal/east_asian_traditional.rs

@@ -5,8 +5,8 @@
 use crate::calendar_arithmetic::{ArithmeticDate, ToExtendedYear};
 use crate::calendar_arithmetic::{DateFieldsResolver, PackWithMD};
 use crate::error::{
-    DateError, DateFromFieldsError, EcmaReferenceYearError, LunisolarDateError, MonthError,
-    UnknownEraError,
+    DateAddError, DateError, DateFromFieldsError, EcmaReferenceYearError, LunisolarDateError,
+    MonthError, UnknownEraError,
 };
 use crate::options::{DateAddOptions, DateDifferenceOptions};
 use crate::options::{DateFromFieldsOptions, Overflow};
@@ -588,18 +588,18 @@ impl<R: Rules> DateFieldsResolver for EastAsianTraditional<R> {
     }
 
     #[inline]
-    fn year_info_from_era(
+    fn extended_year_from_era_year(
         &self,
         _era: &[u8],
         _era_year: i32,
-    ) -> Result<Self::YearInfo, UnknownEraError> {
+    ) -> Result<i32, UnknownEraError> {
         // This calendar has no era codes
         Err(UnknownEraError)
     }
 
     #[inline]
     fn year_info_from_extended(&self, extended_year: i32) -> Self::YearInfo {
-        debug_assert!(crate::calendar_arithmetic::VALID_YEAR_RANGE.contains(&extended_year));
+        debug_assert!(crate::calendar_arithmetic::GENEROUS_YEAR_RANGE.contains(&extended_year));
         self.0.year(extended_year)
     }
 
@@ -724,7 +724,7 @@ impl<R: Rules> Calendar for EastAsianTraditional<R> {
         date: &Self::DateInner,
         duration: types::DateDuration,
         options: DateAddOptions,
-    ) -> Result<Self::DateInner, DateError> {
+    ) -> Result<Self::DateInner, DateAddError> {
         date.0.added(duration, self, options).map(ChineseDateInner)
     }
 

components/calendar/src/cal/ethiopian.rs

@@ -5,7 +5,9 @@
 use crate::cal::coptic::CopticDateInner;
 use crate::cal::Coptic;
 use crate::calendar_arithmetic::{ArithmeticDate, DateFieldsResolver};
-use crate::error::{DateError, DateFromFieldsError, EcmaReferenceYearError, UnknownEraError};
+use crate::error::{
+    DateAddError, DateError, DateFromFieldsError, EcmaReferenceYearError, UnknownEraError,
+};
 use crate::options::DateFromFieldsOptions;
 use crate::options::{DateAddOptions, DateDifferenceOptions};
 use crate::types::DateFields;
@@ -93,14 +95,17 @@ impl DateFieldsResolver for Ethiopian {
     }
 
     #[inline]
-    fn year_info_from_era(
+    fn extended_year_from_era_year(
         &self,
         era: &[u8],
         era_year: i32,
-    ) -> Result<Self::YearInfo, UnknownEraError> {
+    ) -> Result<i32, UnknownEraError> {
         match (self.era_style(), era) {
-            (EthiopianEraStyle::AmeteMihret, b"am") => Ok(era_year + AMETE_MIHRET_OFFSET),
-            (_, b"aa") => Ok(era_year + AMETE_ALEM_OFFSET),
+            (EthiopianEraStyle::AmeteMihret, b"am") => Ok(era_year),
+            (EthiopianEraStyle::AmeteMihret, b"aa") => {
+                Ok(era_year - AMETE_MIHRET_OFFSET + AMETE_ALEM_OFFSET)
+            }
+            (EthiopianEraStyle::AmeteAlem, b"aa") => Ok(era_year),
             (_, _) => Err(UnknownEraError),
         }
     }
@@ -190,7 +195,7 @@ impl Calendar for Ethiopian {
         date: &Self::DateInner,
         duration: types::DateDuration,
         options: DateAddOptions,
-    ) -> Result<Self::DateInner, DateError> {
+    ) -> Result<Self::DateInner, DateAddError> {
         Coptic
             .add(&date.0, duration, options)
             .map(EthiopianDateInner)

components/calendar/src/cal/gregorian.rs

@@ -8,7 +8,7 @@ use crate::cal::abstract_gregorian::{
 use crate::calendar_arithmetic::ArithmeticDate;
 use crate::error::UnknownEraError;
 use crate::preferences::CalendarAlgorithm;
-use crate::{types, Date, DateError, RangeError};
+use crate::{types, Date, RangeError};
 use tinystr::tinystr;
 
 impl_with_abstract_gregorian!(Gregorian, GregorianDateInner, CeBce, _x, CeBce);

components/calendar/src/cal/hebrew.rs

@@ -4,8 +4,8 @@
 
 use crate::calendar_arithmetic::{ArithmeticDate, DateFieldsResolver, PackWithMD, ToExtendedYear};
 use crate::error::{
-    DateError, DateFromFieldsError, EcmaReferenceYearError, LunisolarDateError, MonthError,
-    UnknownEraError,
+    DateAddError, DateError, DateFromFieldsError, EcmaReferenceYearError, LunisolarDateError,
+    MonthError, UnknownEraError,
 };
 use crate::options::{DateAddOptions, DateDifferenceOptions};
 use crate::options::{DateFromFieldsOptions, Overflow};
@@ -135,13 +135,13 @@ impl DateFieldsResolver for Hebrew {
     }
 
     #[inline]
-    fn year_info_from_era(
+    fn extended_year_from_era_year(
         &self,
         era: &[u8],
         era_year: i32,
-    ) -> Result<Self::YearInfo, UnknownEraError> {
+    ) -> Result<i32, UnknownEraError> {
         match era {
-            b"am" => Ok(HebrewYear::compute(era_year)),
+            b"am" => Ok(era_year),
             _ => Err(UnknownEraError),
         }
     }
@@ -290,7 +290,7 @@ impl Calendar for Hebrew {
         date: &Self::DateInner,
         duration: types::DateDuration,
         options: DateAddOptions,
-    ) -> Result<Self::DateInner, DateError> {
+    ) -> Result<Self::DateInner, DateAddError> {
         date.0.added(duration, self, options).map(HebrewDateInner)
     }
 

components/calendar/src/cal/hijri.rs

@@ -6,7 +6,9 @@ use crate::calendar_arithmetic::ArithmeticDate;
 use crate::calendar_arithmetic::DateFieldsResolver;
 use crate::calendar_arithmetic::PackWithMD;
 use crate::calendar_arithmetic::ToExtendedYear;
-use crate::error::{DateError, DateFromFieldsError, EcmaReferenceYearError, UnknownEraError};
+use crate::error::{
+    DateAddError, DateError, DateFromFieldsError, EcmaReferenceYearError, UnknownEraError,
+};
 use crate::options::DateFromFieldsOptions;
 use crate::options::{DateAddOptions, DateDifferenceOptions};
 use crate::types::DateFields;
@@ -844,22 +846,22 @@ impl<R: Rules> DateFieldsResolver for Hijri<R> {
     }
 
     #[inline]
-    fn year_info_from_era(
+    fn extended_year_from_era_year(
         &self,
         era: &[u8],
         era_year: i32,
-    ) -> Result<Self::YearInfo, UnknownEraError> {
+    ) -> Result<i32, UnknownEraError> {
         let extended_year = match era {
             b"ah" => era_year,
             b"bh" => 1 - era_year,
             _ => return Err(UnknownEraError),
         };
-        Ok(self.year_info_from_extended(extended_year))
+        Ok(extended_year)
     }
 
     #[inline]
     fn year_info_from_extended(&self, extended_year: i32) -> Self::YearInfo {
-        debug_assert!(crate::calendar_arithmetic::VALID_YEAR_RANGE.contains(&extended_year));
+        debug_assert!(crate::calendar_arithmetic::GENEROUS_YEAR_RANGE.contains(&extended_year));
         self.0.year(extended_year)
     }
 
@@ -940,7 +942,7 @@ impl<R: Rules> Calendar for Hijri<R> {
         date: &Self::DateInner,
         duration: types::DateDuration,
         options: DateAddOptions,
-    ) -> Result<Self::DateInner, DateError> {
+    ) -> Result<Self::DateInner, DateAddError> {
         date.0.added(duration, self, options).map(HijriDateInner)
     }
 

components/calendar/src/cal/indian.rs

@@ -4,7 +4,9 @@
 
 use crate::calendar_arithmetic::ArithmeticDate;
 use crate::calendar_arithmetic::DateFieldsResolver;
-use crate::error::{DateError, DateFromFieldsError, EcmaReferenceYearError, UnknownEraError};
+use crate::error::{
+    DateAddError, DateError, DateFromFieldsError, EcmaReferenceYearError, UnknownEraError,
+};
 use crate::options::DateFromFieldsOptions;
 use crate::options::{DateAddOptions, DateDifferenceOptions};
 use crate::types::DateFields;
@@ -69,11 +71,11 @@ impl DateFieldsResolver for Indian {
     }
 
     #[inline]
-    fn year_info_from_era(
+    fn extended_year_from_era_year(
         &self,
         era: &[u8],
         era_year: i32,
-    ) -> Result<Self::YearInfo, UnknownEraError> {
+    ) -> Result<i32, UnknownEraError> {
         match era {
             b"shaka" => Ok(era_year),
             _ => Err(UnknownEraError),
@@ -223,7 +225,7 @@ impl Calendar for Indian {
         date: &Self::DateInner,
         duration: types::DateDuration,
         options: DateAddOptions,
-    ) -> Result<Self::DateInner, DateError> {
+    ) -> Result<Self::DateInner, DateAddError> {
         date.0.added(duration, self, options).map(IndianDateInner)
     }