Tests compiling; lots of docs tests

Author: sffc

components/calendar/benches/date.rs

@@ -20,18 +20,22 @@ pub struct Test {
 use criterion::{
     black_box, criterion_group, criterion_main, measurement::WallTime, BenchmarkGroup, Criterion,
 };
-use icu_calendar::{AsCalendar, Calendar, Date, DateDuration};
+use icu_calendar::{types, AsCalendar, Calendar, Date};
 
 fn bench_date<A: AsCalendar>(date: &mut Date<A>) {
     // black_box used to avoid compiler optimization.
     // Arithmetic
-    date.add(DateDuration {
-        is_negative: false,
-        years: black_box(1),
-        months: black_box(2),
-        weeks: black_box(3),
-        days: black_box(4),
-    });
+    date.add_with_options(
+        types::DateDuration {
+            is_negative: false,
+            years: black_box(1),
+            months: black_box(2),
+            weeks: black_box(3),
+            days: black_box(4),
+        },
+        Default::default(),
+    )
+    .unwrap();
 
     // Retrieving vals
     let _ = black_box(date.year());

components/calendar/src/any_calendar.rs

@@ -6,11 +6,11 @@
 
 use crate::cal::iso::IsoDateInner;
 use crate::cal::*;
-use crate::duration::{DateAddOptions, DateUntilOptions};
 use crate::error::DateError;
 use crate::options::DateFromFieldsOptions;
+use crate::options::{DateAddOptions, DateUntilOptions};
 use crate::types::{DateFields, YearInfo};
-use crate::{types, AsCalendar, Calendar, Date, DateDuration, Ref};
+use crate::{types, AsCalendar, Calendar, Date, Ref};
 
 use crate::preferences::{CalendarAlgorithm, HijriCalendarAlgorithm};
 use icu_locale_core::preferences::define_preferences;
@@ -244,8 +244,36 @@ macro_rules! match_cal {
     };
 }
 
+/// Error returned when comparing two [`Date`]s with [`AnyCalendar`].
+#[derive(Debug, Copy, Clone)]
 #[non_exhaustive]
 pub enum AnyCalendarUntilError {
+    /// The calendars of the two dates being compared are not equal.
+    ///
+    /// To compare dates in different calendars, convert them to the same calendar first.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use icu::calendar::Date;
+    /// use icu::calendar::cal::AnyCalendarUntilError;
+    ///
+    /// let d1 = Date::try_new_gregorian(2000, 1, 1).unwrap().to_any();
+    /// let d2 = Date::try_new_hebrew(5780, 1, 1).unwrap().to_any();
+    ///
+    /// assert!(matches!(
+    ///     d1.until(&d2, Default::default()),
+    ///     Err(AnyCalendarUntilError::MismatchedCalendars),
+    /// ));
+    ///
+    /// // To compare the dates, convert them to the same calendar,
+    /// // such as ISO.
+    ///
+    /// assert!(matches!(
+    ///     d1.to_iso().until(&d2.to_iso(), Default::default()),
+    ///     Ok(_)
+    /// ));
+    /// ```
     MismatchedCalendars,
 }
 
@@ -294,7 +322,7 @@ impl Calendar for AnyCalendar {
     fn add(
         &self,
         date: &Self::DateInner,
-        duration: DateDuration,
+        duration: types::DateDuration,
         options: DateAddOptions,
     ) -> Result<Self::DateInner, DateError> {
         Ok(match_cal_and_date!(match (self, date): (c, d) wrap => c.add(d, duration, options)?))
@@ -304,12 +332,12 @@ impl Calendar for AnyCalendar {
         &self,
         date1: &Self::DateInner,
         date2: &Self::DateInner,
-        options: DateUntilOptions
-    ) -> Result<DateDuration, Self::UntilError> {
+        options: DateUntilOptions,
+    ) -> Result<types::DateDuration, Self::UntilError> {
         let result = match_cal_and_date_date!(match (self, date1, date2): (c, d1, d2) => c.until(d1, d2, options)).0;
         // map from Result<DateDuration, Infallible> to Result<DateDuration, Self::UntilError>
         match result {
-            Ok(duration) => Ok(duration)
+            Ok(duration) => Ok(duration),
         }
     }
 

components/calendar/src/cal/abstract_gregorian.rs

@@ -6,12 +6,12 @@ use crate::cal::iso::{IsoDateInner, IsoEra};
 use crate::calendar_arithmetic::{
     ArithmeticDate, ArithmeticDateBuilder, CalendarArithmetic, DateFieldsResolver,
 };
-use crate::duration::{DateAddOptions, DateUntilOptions};
 use crate::error::DateError;
 use crate::options::DateFromFieldsOptions;
+use crate::options::{DateAddOptions, DateUntilOptions};
 use crate::preferences::CalendarAlgorithm;
 use crate::types::EraYear;
-use crate::{types, Calendar, DateDuration, RangeError};
+use crate::{types, Calendar, RangeError};
 use calendrical_calculations::helpers::I32CastError;
 use calendrical_calculations::rata_die::RataDie;
 
@@ -155,7 +155,12 @@ impl<Y: GregorianYears> Calendar for AbstractGregorian<Y> {
         date.days_in_month()
     }
 
-    fn add(&self, date: &Self::DateInner, duration: DateDuration, options: DateAddOptions) -> Result<Self::DateInner, DateError> {
+    fn add(
+        &self,
+        date: &Self::DateInner,
+        duration: types::DateDuration,
+        options: DateAddOptions,
+    ) -> Result<Self::DateInner, DateError> {
         date.added(duration, &AbstractGregorian(IsoEra), options)
     }
 
@@ -164,7 +169,7 @@ impl<Y: GregorianYears> Calendar for AbstractGregorian<Y> {
         date1: &Self::DateInner,
         date2: &Self::DateInner,
         options: DateUntilOptions,
-    ) -> Result<DateDuration, Self::UntilError> {
+    ) -> Result<types::DateDuration, Self::UntilError> {
         Ok(date1.until(date2, &AbstractGregorian(IsoEra), options))
     }
 
@@ -263,19 +268,27 @@ macro_rules! impl_with_abstract_gregorian {
                 crate::cal::abstract_gregorian::AbstractGregorian($eras_expr).days_in_month(&date.0)
             }
 
-            fn add(&self, date: &Self::DateInner, duration: crate::duration::DateDuration, options: crate::duration::DateAddOptions) -> Result<Self::DateInner, DateError> {
+            fn add(
+                &self,
+                date: &Self::DateInner,
+                duration: crate::types::DateDuration,
+                options: crate::options::DateAddOptions,
+            ) -> Result<Self::DateInner, DateError> {
                 let $self_ident = self;
-                crate::cal::abstract_gregorian::AbstractGregorian($eras_expr).add(&date.0, duration, options).map($inner_date_ty)
+                crate::cal::abstract_gregorian::AbstractGregorian($eras_expr)
+                    .add(&date.0, duration, options)
+                    .map($inner_date_ty)
             }
 
             fn until(
                 &self,
                 date1: &Self::DateInner,
                 date2: &Self::DateInner,
-                options: crate::duration::DateUntilOptions,
-            ) -> Result<crate::duration::DateDuration, Self::UntilError> {
+                options: crate::options::DateUntilOptions,
+            ) -> Result<crate::types::DateDuration, Self::UntilError> {
                 let $self_ident = self;
-                crate::cal::abstract_gregorian::AbstractGregorian($eras_expr).until(&date1.0, &date2.0, options)
+                crate::cal::abstract_gregorian::AbstractGregorian($eras_expr)
+                    .until(&date1.0, &date2.0, options)
             }
 
             fn year_info(&self, date: &Self::DateInner) -> Self::Year {

components/calendar/src/cal/chinese.rs

@@ -7,13 +7,13 @@ use crate::calendar_arithmetic::{
     ArithmeticDate, ArithmeticDateBuilder, CalendarArithmetic, ToExtendedYear,
 };
 use crate::calendar_arithmetic::{DateFieldsResolver, PrecomputedDataSource};
-use crate::duration::{DateAddOptions, DateUntilOptions};
 use crate::error::DateError;
+use crate::options::{DateAddOptions, DateUntilOptions};
 use crate::options::{DateFromFieldsOptions, Overflow};
 use crate::provider::chinese_based::{ChineseBasedCache, PackedChineseBasedYearInfo};
 use crate::types::{MonthCode, MonthInfo};
 use crate::AsCalendar;
-use crate::{types, Calendar, Date, DateDuration};
+use crate::{types, Calendar, Date};
 use calendrical_calculations::chinese_based::{
     self, ChineseBased, YearBounds, WELL_BEHAVED_ASTRONOMICAL_RANGE,
 };
@@ -635,7 +635,12 @@ impl<X: Rules> Calendar for LunarChinese<X> {
         date.0.days_in_month()
     }
 
-    fn add(&self, date: &Self::DateInner, duration: DateDuration, options: DateAddOptions) -> Result<Self::DateInner, DateError> {
+    fn add(
+        &self,
+        date: &Self::DateInner,
+        duration: types::DateDuration,
+        options: DateAddOptions,
+    ) -> Result<Self::DateInner, DateError> {
         date.0.added(duration, self, options).map(ChineseDateInner)
     }
 
@@ -644,7 +649,7 @@ impl<X: Rules> Calendar for LunarChinese<X> {
         date1: &Self::DateInner,
         date2: &Self::DateInner,
         options: DateUntilOptions,
-    ) -> Result<DateDuration, Self::UntilError> {
+    ) -> Result<types::DateDuration, Self::UntilError> {
         Ok(date1.0.until(&date2.0, self, options))
     }
 

components/calendar/src/cal/coptic.rs

@@ -5,10 +5,10 @@
 use crate::cal::iso::{Iso, IsoDateInner};
 use crate::calendar_arithmetic::{ArithmeticDate, CalendarArithmetic};
 use crate::calendar_arithmetic::{ArithmeticDateBuilder, DateFieldsResolver};
-use crate::duration::{DateAddOptions, DateUntilOptions};
 use crate::error::DateError;
 use crate::options::DateFromFieldsOptions;
-use crate::{types, Calendar, Date, DateDuration, RangeError};
+use crate::options::{DateAddOptions, DateUntilOptions};
+use crate::{types, Calendar, Date, RangeError};
 use calendrical_calculations::helpers::I32CastError;
 use calendrical_calculations::rata_die::RataDie;
 use tinystr::tinystr;
@@ -179,7 +179,12 @@ impl Calendar for Coptic {
         date.0.days_in_month()
     }
 
-    fn add(&self, date: &Self::DateInner, duration: DateDuration, options: DateAddOptions) -> Result<Self::DateInner, DateError> {
+    fn add(
+        &self,
+        date: &Self::DateInner,
+        duration: types::DateDuration,
+        options: DateAddOptions,
+    ) -> Result<Self::DateInner, DateError> {
         date.0.added(duration, self, options).map(CopticDateInner)
     }
 
@@ -188,7 +193,7 @@ impl Calendar for Coptic {
         date1: &Self::DateInner,
         date2: &Self::DateInner,
         options: DateUntilOptions,
-    ) -> Result<DateDuration, Self::UntilError> {
+    ) -> Result<types::DateDuration, Self::UntilError> {
         Ok(date1.0.until(&date2.0, self, options))
     }
 

components/calendar/src/cal/ethiopian.rs

@@ -6,11 +6,11 @@ use crate::cal::coptic::CopticDateInner;
 use crate::cal::iso::IsoDateInner;
 use crate::cal::Coptic;
 use crate::calendar_arithmetic::{ArithmeticDate, ArithmeticDateBuilder, DateFieldsResolver};
-use crate::duration::{DateAddOptions, DateUntilOptions};
 use crate::error::DateError;
 use crate::options::DateFromFieldsOptions;
+use crate::options::{DateAddOptions, DateUntilOptions};
 use crate::types::DateFields;
-use crate::{types, Calendar, Date, DateDuration, RangeError};
+use crate::{types, Calendar, Date, RangeError};
 use calendrical_calculations::rata_die::RataDie;
 use tinystr::tinystr;
 
@@ -146,16 +146,23 @@ impl Calendar for Ethiopian {
         Coptic.days_in_month(&date.0)
     }
 
-    fn add(&self, date: &Self::DateInner, duration: DateDuration, options: DateAddOptions) -> Result<Self::DateInner, DateError> {
-        Coptic.add(&date.0, duration, options).map(EthiopianDateInner)
+    fn add(
+        &self,
+        date: &Self::DateInner,
+        duration: types::DateDuration,
+        options: DateAddOptions,
+    ) -> Result<Self::DateInner, DateError> {
+        Coptic
+            .add(&date.0, duration, options)
+            .map(EthiopianDateInner)
     }
 
     fn until(
         &self,
         date1: &Self::DateInner,
         date2: &Self::DateInner,
         options: DateUntilOptions,
-    ) -> Result<DateDuration, Self::UntilError> {
+    ) -> Result<types::DateDuration, Self::UntilError> {
         Coptic.until(&date1.0, &date2.0, options)
     }
 

components/calendar/src/cal/hebrew.rs

@@ -7,12 +7,12 @@ use crate::calendar_arithmetic::{
     ArithmeticDate, CalendarArithmetic, DateFieldsResolver, ToExtendedYear,
 };
 use crate::calendar_arithmetic::{ArithmeticDateBuilder, PrecomputedDataSource};
-use crate::duration::{DateAddOptions, DateUntilOptions};
 use crate::error::DateError;
+use crate::options::{DateAddOptions, DateUntilOptions};
 use crate::options::{DateFromFieldsOptions, Overflow};
 use crate::types::{DateFields, MonthInfo};
 use crate::RangeError;
-use crate::{types, Calendar, Date, DateDuration};
+use crate::{types, Calendar, Date};
 use ::tinystr::tinystr;
 use calendrical_calculations::hebrew_keviyah::{Keviyah, YearInfo};
 use calendrical_calculations::rata_die::RataDie;
@@ -339,7 +339,12 @@ impl Calendar for Hebrew {
         date.0.days_in_month()
     }
 
-    fn add(&self, date: &Self::DateInner, duration: DateDuration, options: DateAddOptions) -> Result<Self::DateInner, DateError> {
+    fn add(
+        &self,
+        date: &Self::DateInner,
+        duration: types::DateDuration,
+        options: DateAddOptions,
+    ) -> Result<Self::DateInner, DateError> {
         date.0.added(duration, self, options).map(HebrewDateInner)
     }
 
@@ -348,7 +353,7 @@ impl Calendar for Hebrew {
         date1: &Self::DateInner,
         date2: &Self::DateInner,
         options: DateUntilOptions,
-    ) -> Result<DateDuration, Self::UntilError> {
+    ) -> Result<types::DateDuration, Self::UntilError> {
         Ok(date1.0.until(&date2.0, self, options))
     }
 

components/calendar/src/cal/hijri.rs

@@ -6,12 +6,12 @@ use crate::cal::iso::{Iso, IsoDateInner};
 use crate::calendar_arithmetic::{ArithmeticDate, CalendarArithmetic};
 use crate::calendar_arithmetic::{ArithmeticDateBuilder, DateFieldsResolver};
 use crate::calendar_arithmetic::{PrecomputedDataSource, ToExtendedYear};
-use crate::duration::{DateAddOptions, DateUntilOptions};
 use crate::error::DateError;
 use crate::options::DateFromFieldsOptions;
+use crate::options::{DateAddOptions, DateUntilOptions};
 use crate::provider::hijri::PackedHijriYearInfo;
 use crate::types::DateFields;
-use crate::{types, Calendar, Date, DateDuration};
+use crate::{types, Calendar, Date};
 use crate::{AsCalendar, RangeError};
 use calendrical_calculations::islamic::{
     ISLAMIC_EPOCH_FRIDAY, ISLAMIC_EPOCH_THURSDAY, WELL_BEHAVED_ASTRONOMICAL_RANGE,
@@ -665,7 +665,12 @@ impl<R: Rules> Calendar for Hijri<R> {
         date.0.days_in_month()
     }
 
-    fn add(&self, date: &Self::DateInner, duration: DateDuration, options: DateAddOptions) -> Result<Self::DateInner, DateError> {
+    fn add(
+        &self,
+        date: &Self::DateInner,
+        duration: types::DateDuration,
+        options: DateAddOptions,
+    ) -> Result<Self::DateInner, DateError> {
         date.0.added(duration, self, options).map(HijriDateInner)
     }
 
@@ -674,7 +679,7 @@ impl<R: Rules> Calendar for Hijri<R> {
         date1: &Self::DateInner,
         date2: &Self::DateInner,
         options: DateUntilOptions,
-    ) -> Result<DateDuration, Self::UntilError> {
+    ) -> Result<types::DateDuration, Self::UntilError> {
         Ok(date1.0.until(&date2.0, self, options))
     }