Make some ZonedDateTime<Iso, UtcOffset> functions generic in calendar (#7630)

I don't know why we only had these for the `Iso` calendar, there's
nothing stopping us from having them for all calendars, because they
only need `.to_rata_die()`.

## Changelog
icu_time: 
* Make some `ZonedDateTime<Iso, UtcOffset>` functions generic in
calendar

Author: robertbastian

components/datetime/src/time_crate.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/time/src/types.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/zone/mod.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/zone_name_timestamp.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();

ffi/capi/bindings/c/TimeZoneInfo.h

@@ -10,7 +10,9 @@ pub mod ffi {
     use alloc::boxed::Box;
 
     use crate::unstable::{
-        date::ffi::IsoDate, datetime::ffi::IsoDateTime, time::ffi::Time,
+        date::ffi::{Date, IsoDate},
+        datetime::ffi::IsoDateTime,
+        time::ffi::Time,
         variant_offset::ffi::UtcOffset,
     };
 
@@ -180,7 +182,7 @@ pub mod ffi {
         /// - If the offset is not set, the datetime is interpreted as UTC.
         /// - The constraints are the same as with `ZoneNameTimestamp` in Rust.
         /// - Set to year 1000 or 9999 for a reference far in the past or future.
-        #[diplomat::rust_link(icu::time::TimeZoneInfo::at_date_time_iso, FnInStruct)]
+        #[diplomat::rust_link(icu::time::TimeZoneInfo::at_date_time, FnInStruct)]
         #[diplomat::rust_link(icu::time::zone::ZoneNameTimestamp, Struct, compact)]
         #[diplomat::rust_link(
             icu::time::TimeZoneInfo::with_zone_name_timestamp,
@@ -208,7 +210,7 @@ pub mod ffi {
                 zone_name_timestamp: Some(
                     self.id
                         .with_offset(self.offset)
-                        .at_date_time_iso(icu_time::DateTime {
+                        .at_date_time(icu_time::DateTime {
                             date: date.0,
                             time: time.0,
                         })
@@ -218,6 +220,53 @@ pub mod ffi {
             })
         }
 
+        /// Sets the datetime at which to interpret the time zone
+        /// for display name lookup.
+        ///
+        /// Notes:
+        ///
+        /// - If not set, the formatting datetime is used if possible.
+        /// - If the offset is not set, the datetime is interpreted as UTC.
+        /// - The constraints are the same as with `ZoneNameTimestamp` in Rust.
+        /// - Set to year 1000 or 9999 for a reference far in the past or future.
+        #[diplomat::rust_link(icu::time::TimeZoneInfo::at_date_time, FnInStruct)]
+        #[diplomat::rust_link(icu::time::zone::ZoneNameTimestamp, Struct, compact)]
+        #[diplomat::rust_link(
+            icu::time::TimeZoneInfo::with_zone_name_timestamp,
+            FnInStruct,
+            hidden
+        )]
+        #[diplomat::rust_link(
+            icu::time::zone::ZoneNameTimestamp::from_date_time,
+            FnInStruct,
+            hidden
+        )]
+        #[diplomat::rust_link(
+            icu::time::zone::ZoneNameTimestamp::from_zoned_date_time,
+            FnInStruct,
+            hidden
+        )]
+        #[diplomat::rust_link(
+            icu::time::zone::ZoneNameTimestamp::far_in_future,
+            FnInStruct,
+            hidden
+        )] // documented
+        #[diplomat::rust_link(icu::time::zone::ZoneNameTimestamp::far_in_past, FnInStruct, hidden)] // documented
+        pub fn at_date_time(&self, date: &Date, time: &Time) -> Box<Self> {
+            Box::new(Self {
+                zone_name_timestamp: Some(
+                    self.id
+                        .with_offset(self.offset)
+                        .at_date_time(icu_time::DateTime {
+                            date: date.0.clone(),
+                            time: time.0,
+                        })
+                        .zone_name_timestamp(),
+                ),
+                ..*self
+            })
+        }
+
         /// Sets the timestamp, in milliseconds since Unix epoch, at which to interpret the time zone
         /// for display name lookup.
         ///
@@ -308,8 +357,8 @@ impl ffi::TimeZoneInfo {
         if let Some(zone_name_timestamp) = self.zone_name_timestamp {
             base.with_zone_name_timestamp(zone_name_timestamp)
         } else if let Some(date) = date {
-            base.at_date_time_iso(icu_time::DateTime {
-                date: date.to_calendar(icu_calendar::Iso),
+            base.at_date_time(icu_time::DateTime {
+                date,
                 time: time.unwrap_or(icu_time::Time::noon()),
             })
         } else {

ffi/capi/bindings/cpp/icu4x/TimeZoneInfo.d.hpp

@@ -181,16 +181,6 @@ pub mod ffi {
             icu::time::zone::VariantOffsetsCalculatorBorrowed::compute_offsets_from_time_zone_and_name_timestamp,
             FnInStruct
         )]
-        #[diplomat::rust_link(
-            icu::time::zone::ZoneNameTimestamp::from_zoned_date_time_iso,
-            FnInStruct,
-            hidden
-        )]
-        #[diplomat::rust_link(
-            icu::time::ZonedDateTime::from_epoch_milliseconds_and_utc_offset,
-            FnInStruct,
-            hidden
-        )]
         pub fn compute_offsets_from_time_zone_and_timestamp(
             &self,
             time_zone: &TimeZone,