Merge branch 'main' into stateful-surpasses

Author: poulsbo

Cargo.toml

@@ -407,9 +407,11 @@ rust.unused_qualifications = "warn"
 # rust.unsafe_op_in_unsafe_fn = "forbid"
 
 [workspace.metadata.cargo-semver-checks.lints]
-type_method_marked_deprecated.level = "allow" # allow deprecation in patch releases
-trait_method_marked_deprecated.level = "allow" # allow deprecation in patch releases
-type_marked_deprecated.level = "allow" # allow deprecation in patch releases
+copy_impl_added = "allow"
+enum_no_repr_variant_discriminant_changed = "allow" # we don't consider this breaking https://github.com/obi1kenobi/cargo-semver-checks/issues/1376
+enum_variant_marked_deprecated = "allow"
 struct_field_marked_deprecated = "allow" # allow deprecation in patch releases
+trait_method_marked_deprecated = "allow" # allow deprecation in patch releases
 type_associated_const_marked_deprecated = "allow" # allow deprecation in patch releases
-enum_no_repr_variant_discriminant_changed = "allow" # we don't consider this breaking https://github.com/obi1kenobi/cargo-semver-checks/issues/1376
+type_marked_deprecated = "allow" # allow deprecation in patch releases
+type_method_marked_deprecated = "allow" # allow deprecation in patch releases

components/calendar/src/any_calendar.rs

@@ -423,13 +423,19 @@ impl<A: AsCalendar> Date<A> {
         Ok(self)
     }
 
-    /// Calculating the duration between `other - self`
+    /// Calculating the duration between `other - self`, counting from `self`
     ///
     /// Although this returns a [`Result`], with most fixed calendars, this operation can't fail.
     /// In such cases, the error type is [`Infallible`], and the inner value can be safely
     /// unwrapped using [`Result::into_ok()`], which is available in nightly Rust as of this
     /// writing. In stable Rust, the value can be unwrapped using [pattern matching].
     ///
+    /// Note that `a.try_until_with_options(b, ..)` is not necessarily the same as
+    /// `-b.try_until_with_options(a, ..)`. `a.try_until_with_options(b, ..)`
+    /// computes a duration starting at `a` by adding years, months, sometimes weeks, and days in order
+    /// (based on the options) until it reaches `b`. So, `(Sep 30).until(Oct 31)` with `largest_unit = DateDurationUnit::Months`
+    /// will be a duration of 1 month and 1 day, but `(Oct 31).until(Sep 30)` will be a duration of -1 months.
+    ///
     /// # Examples
     ///
     /// ```
@@ -446,6 +452,25 @@ impl<A: AsCalendar> Date<A> {
     /// assert_eq!(duration, DateDuration::for_days(2101));
     /// ```
     ///
+    /// Reversing the order of parameters does not necessarily produce the inverse result:
+    ///
+    /// ```
+    /// use icu::calendar::types::DateDuration;
+    /// use icu::calendar::options::{DateDifferenceOptions, DateDurationUnit};
+    /// use icu::calendar::Date;
+    ///
+    /// let d1 = Date::try_new_iso(2025, 9, 30).unwrap();
+    /// let d2 = Date::try_new_iso(2025, 10, 31).unwrap();
+    /// let mut options = DateDifferenceOptions::default();
+    /// options.largest_unit = Some(DateDurationUnit::Months);
+    ///
+    /// let Ok(duration_forward) = d1.try_until_with_options(&d2, options);
+    /// let Ok(duration_backward) = d2.try_until_with_options(&d1, options);
+    ///
+    /// assert_eq!(duration_forward, DateDuration {months: 1, days: 1, ..Default::default()});
+    /// assert_eq!(duration_backward, DateDuration::for_months(-1));
+    /// ```
+    ///
     /// [`Infallible`]: core::convert::Infallible
     /// [pattern matching]: https://doc.rust-lang.org/book/ch19-03-pattern-syntax.html
     ///

components/calendar/src/date.rs

@@ -352,6 +352,13 @@ impl FormattableAnyCalendarKind {
 
 #[test]
 fn test_calendar_fallback() {
+    #[allow(non_local_definitions)] // only used in this test
+    impl PartialEq for FormattableAnyCalendar {
+        fn eq(&self, other: &Self) -> bool {
+            self.any_calendar.kind() == other.any_calendar.kind()
+        }
+    }
+
     use icu_locale_core::{locale, Locale};
     assert_eq!(
         FormattableAnyCalendar::try_new(locale!("en-TH-u-ca-iso8601").into()),
@@ -380,7 +387,7 @@ fn test_calendar_fallback() {
 }
 
 /// A version of [`AnyCalendar`] for the calendars supported in the any-calendar formatter.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone)]
 pub(crate) struct FormattableAnyCalendar {
     any_calendar: AnyCalendar,
 }

components/datetime/src/scaffold/calendar.rs

@@ -265,12 +265,7 @@ impl GetField<Option<UtcOffset>> for time::OffsetDateTime {
 impl GetField<ZoneNameTimestamp> for time::OffsetDateTime {
     #[inline]
     fn get_field(&self) -> ZoneNameTimestamp {
-        ZoneNameTimestamp::from_zoned_date_time_iso(
-            ZonedDateTime::from_epoch_milliseconds_and_utc_offset(
-                self.unix_timestamp(),
-                UtcOffset::zero(),
-            ),
-        )
+        ZoneNameTimestamp::from_epoch_seconds(self.unix_timestamp())
     }
 }
 

components/datetime/src/time_crate.rs

@@ -312,7 +312,7 @@ where
 
 const UNIX_EPOCH: RataDie = calendrical_calculations::gregorian::fixed_from_gregorian(1970, 1, 1);
 
-impl Ord for ZonedDateTime<Iso, UtcOffset> {
+impl<A: AsCalendar> Ord for ZonedDateTime<A, UtcOffset> {
     fn cmp(&self, other: &Self) -> core::cmp::Ordering {
         let mut srd = self.date.to_rata_die();
         let mut ord = other.date.to_rata_die();
@@ -357,8 +357,13 @@ impl Ord for ZonedDateTime<Iso, UtcOffset> {
             .then(self.time.subsecond.cmp(&other.time.subsecond))
     }
 }
-impl PartialOrd for ZonedDateTime<Iso, UtcOffset> {
-    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
+
+impl<A> PartialOrd<ZonedDateTime<A, UtcOffset>> for ZonedDateTime<A, UtcOffset>
+where
+    A: AsCalendar,
+    Date<A>: PartialEq<Date<A>>,
+{
+    fn partial_cmp(&self, other: &ZonedDateTime<A, UtcOffset>) -> Option<core::cmp::Ordering> {
         Some(self.cmp(other))
     }
 }

components/time/src/types.rs

@@ -53,6 +53,7 @@ pub mod windows;
 mod zone_name_timestamp;
 
 use icu_calendar::types::RataDie;
+use icu_calendar::AsCalendar;
 #[cfg(feature = "compiled_data")]
 use icu_locale_core::subtags::Region;
 #[doc(inline)]
@@ -285,8 +286,8 @@ impl<'a> zerovec::maps::ZeroMapKV<'a> for TimeZone {
 /// );
 ///
 /// // ... or by adding a local time
-/// let time_zone_at_time = time_zone.at_date_time_iso(DateTime {
-///     date: Date::try_new_iso(2023, 12, 2).unwrap(),
+/// let time_zone_at_time = time_zone.at_date_time(DateTime {
+///     date: Date::try_new_coptic(1996, 12, 2).unwrap(),
 ///     time: Time::start_of_day(),
 /// });
 /// ```
@@ -451,16 +452,25 @@ impl TimeZoneInfo<models::Base> {
 
     /// Sets the [`ZoneNameTimestamp`] to the given datetime.
     ///
-    /// If the offset is knonw, the datetime is interpreted as a local time,
+    /// If the offset is known, the datetime is interpreted as a local time,
     /// otherwise as UTC. This produces correct results for the vast majority
     /// of cases, however close to metazone changes (Eastern Time -> Central Time)
     /// it might be incorrect if the offset is not known.
     ///
     /// Also see [`Self::with_zone_name_timestamp`].
-    pub fn at_date_time_iso(self, date_time: DateTime<Iso>) -> TimeZoneInfo<models::AtTime> {
+    pub fn at_date_time<C: AsCalendar>(
+        self,
+        date_time: DateTime<C>,
+    ) -> TimeZoneInfo<models::AtTime> {
         self.at_rd_time(date_time.date.to_rata_die(), date_time.time)
     }
 
+    /// Use [`Self::at_date_time`].
+    #[deprecated(since = "2.2.0", note = "use `Self::at_date_time`")]
+    pub fn at_date_time_iso(self, date_time: DateTime<Iso>) -> TimeZoneInfo<models::AtTime> {
+        self.at_date_time(date_time)
+    }
+
     pub(crate) fn at_rd_time(self, rd: RataDie, time: Time) -> TimeZoneInfo<models::AtTime> {
         self.with_zone_name_timestamp(ZoneNameTimestamp::from_rd_time_zone(
             rd,

components/time/src/zone/mod.rs

@@ -5,7 +5,7 @@
 use core::fmt;
 
 use icu_calendar::types::RataDie;
-use icu_calendar::Iso;
+use icu_calendar::{AsCalendar, Iso};
 use zerovec::ule::AsULE;
 
 use crate::Time;
@@ -84,7 +84,7 @@ impl ZoneNameTimestamp {
     ///     zone: UtcOffset::zero(),
     /// };
     ///
-    /// let zone_name_timestamp = ZoneNameTimestamp::from_zoned_date_time_iso(zoned_date_time);
+    /// let zone_name_timestamp = ZoneNameTimestamp::from_zoned_date_time(zoned_date_time);
     ///
     /// let recovered_zoned_date_time = zone_name_timestamp.to_zoned_date_time_iso();
     ///
@@ -106,14 +106,22 @@ impl ZoneNameTimestamp {
     }
 
     /// Creates an instance of [`ZoneNameTimestamp`] from a [`ZonedDateTime`] with an explicit [`UtcOffset`].
-    pub fn from_zoned_date_time_iso(zoned_date_time: ZonedDateTime<Iso, UtcOffset>) -> Self {
+    pub fn from_zoned_date_time<C: AsCalendar>(
+        zoned_date_time: ZonedDateTime<C, UtcOffset>,
+    ) -> Self {
         Self::from_rd_time_zone(
             zoned_date_time.date.to_rata_die(),
             zoned_date_time.time,
             zoned_date_time.zone,
         )
     }
 
+    /// Use [`Self::from_zoned_date_time`].
+    #[deprecated(since = "2.2.0", note = "use `Self::from_zoned_date_time`")]
+    pub fn from_zoned_date_time_iso(zoned_date_time: ZonedDateTime<Iso, UtcOffset>) -> Self {
+        Self::from_zoned_date_time(zoned_date_time)
+    }
+
     pub(crate) fn from_rd_time_zone(rd: RataDie, time: Time, zone: UtcOffset) -> Self {
         Self::from_epoch_seconds(
             (rd - RD_EPOCH) * 24 * 60 * 60 + time.seconds_since_midnight() as i64
@@ -186,7 +194,7 @@ impl ZoneNameTimestamp {
         note = "implicitly interprets the DateTime as UTC. Use `from_zoned_date_time_iso` instead."
     )]
     pub fn from_date_time_iso(DateTime { date, time }: DateTime<Iso>) -> Self {
-        Self::from_zoned_date_time_iso(ZonedDateTime {
+        Self::from_zoned_date_time(ZonedDateTime {
             date,
             time,
             zone: UtcOffset::zero(),
@@ -280,7 +288,7 @@ impl<'de> serde::Deserialize<'de> for ZoneNameTimestamp {
             let day = parts[8..10].parse::<u8>().map_err(e1)?;
             let hour = parts[11..13].parse::<u8>().map_err(e1)?;
             let minute = parts[14..16].parse::<u8>().map_err(e1)?;
-            return Ok(Self::from_zoned_date_time_iso(ZonedDateTime {
+            return Ok(Self::from_zoned_date_time(ZonedDateTime {
                 date: icu_calendar::Date::try_new_iso(year, month, day).map_err(e2)?,
                 time: Time::try_new(hour, minute, 0, 0).map_err(e3)?,
                 zone: UtcOffset::zero(),
@@ -360,7 +368,7 @@ mod test {
                 output: "2025-04-30T15:15Z",
             },
         ] {
-            let znt = ZoneNameTimestamp::from_zoned_date_time_iso(
+            let znt = ZoneNameTimestamp::from_zoned_date_time(
                 ZonedDateTime::try_offset_only_from_str(test_case.input, Iso).unwrap(),
             );
             let actual = znt.to_zoned_date_time_iso();