Add zoneinfo64 support to temporal_provider

Cargo.toml

@@ -35,6 +35,7 @@ zoneinfo_rs = { version = "~0.0.14", path = "./zoneinfo" }
 # Dependencies
 tinystr = "0.8.1"
 icu_calendar = { version = "2.0.3", default-features = false }
+icu_time = { version = "2.0.0", default-features = false }
 icu_locale = "2.0.0"
 rustc-hash = "2.1.0"
 num-traits = { version = "0.2.19", default-features = false }

provider/Cargo.toml

@@ -43,6 +43,10 @@ tzif = ["dep:tzif",
     "dep:combine",
     "std"]
 
+# Performing timezone resolution using the `zoneinfo64` crate
+# (ICU4C zoneinfo64.res)
+zoneinfo64 = ["dep:zoneinfo64", "dep:icu_time"]
+
 [dependencies]
 
 # Provider dependency
@@ -52,12 +56,16 @@ tinystr = { workspace = true, features = ["zerovec"] }
 
 # IANA dependency
 zoneinfo_rs = { workspace = true, features = ["std"], optional = true }
+icu_time = { workspace = true, optional = true}
 
 # tzif dependency
 tzif = { workspace = true, optional = true }
 jiff-tzdb = { workspace = true, optional = true }
 combine = { workspace = true, optional = true }
 
+# zoneinfo64 dependency
+zoneinfo64 = { version = "0.1.0", optional = true }
+
 # Databake dependencies
 serde = { version = "1.0.219", features = ["derive"], optional = true }
 databake = { version = "0.2.0", features = ["derive"], optional = true }

provider/src/epoch_nanoseconds.rs

@@ -4,7 +4,7 @@ use crate::TimeZoneProviderError;
 #[doc(hidden)]
 pub const NS_PER_DAY: u64 = MS_PER_DAY as u64 * 1_000_000;
 
-const NS_IN_S: i128 = 1_000_000_000;
+pub(crate) const NS_IN_S: i128 = 1_000_000_000;
 
 /// Milliseconds per day constant: 8.64e+7
 pub(crate) const MS_PER_DAY: u32 = 24 * 60 * 60 * 1000;
@@ -55,3 +55,9 @@ impl From<tzif::data::time::Seconds> for EpochNanoseconds {
         EpochNanoseconds::from_seconds(value.0)
     }
 }
+
+#[inline]
+#[cfg(any(feature = "tzif", feature = "zoneinfo64"))]
+pub(crate) fn seconds_to_nanoseconds(seconds: i64) -> i128 {
+    seconds as i128 * NS_IN_S
+}

provider/src/lib.rs

@@ -29,6 +29,9 @@ pub mod tzif;
 #[cfg(feature = "experimental_tzif")]
 pub mod experimental_tzif;
 
+#[cfg(feature = "zoneinfo64")]
+pub mod zoneinfo64;
+
 pub mod epoch_nanoseconds;
 
 #[doc(hidden)]

provider/src/provider.rs

@@ -7,6 +7,8 @@ use crate::utils;
 use crate::{epoch_nanoseconds::EpochNanoseconds, TimeZoneProviderError};
 use alloc::borrow::Cow;
 
+pub(crate) type TimeZoneProviderResult<T> = Result<T, TimeZoneProviderError>;
+
 /// `UtcOffsetSeconds` represents the amount of seconds we need to add to the UTC to reach the local time.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
 pub struct UtcOffsetSeconds(pub i64);
@@ -82,15 +84,6 @@ pub struct EpochNanosecondsAndOffset {
     pub offset: UtcOffsetSeconds,
 }
 
-/// `TimeZoneTransitionInfo` represents information about a timezone transition.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct TimeZoneTransitionInfo {
-    /// The transition time epoch at which the offset needs to be applied.
-    pub transition_epoch: Option<i64>,
-    /// The time zone offset in seconds.
-    pub offset: UtcOffsetSeconds,
-}
-
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum TransitionDirection {
     Next,
@@ -189,61 +182,52 @@ impl CandidateEpochNanoseconds {
 /// The `TimeZoneProvider` trait provides methods required for a provider
 /// to implement in order to source time zone data from that provider.
 pub trait TimeZoneProvider {
-    fn normalize_identifier(&self, ident: &'_ [u8]) -> Result<Cow<'_, str>, TimeZoneProviderError>;
+    fn normalize_identifier(&self, ident: &'_ [u8]) -> TimeZoneProviderResult<Cow<'_, str>>;
 
-    fn canonicalize_identifier(
-        &self,
-        ident: &'_ [u8],
-    ) -> Result<Cow<'_, str>, TimeZoneProviderError>;
+    fn canonicalize_identifier(&self, ident: &'_ [u8]) -> TimeZoneProviderResult<Cow<'_, str>>;
 
     fn get_named_tz_epoch_nanoseconds(
         &self,
         identifier: &str,
         local_datetime: IsoDateTime,
-    ) -> Result<CandidateEpochNanoseconds, TimeZoneProviderError>;
+    ) -> TimeZoneProviderResult<CandidateEpochNanoseconds>;
 
     fn get_named_tz_offset_nanoseconds(
         &self,
         identifier: &str,
         epoch_nanoseconds: i128,
-    ) -> Result<TimeZoneTransitionInfo, TimeZoneProviderError>;
+    ) -> TimeZoneProviderResult<UtcOffsetSeconds>;
 
     fn get_named_tz_transition(
         &self,
         identifier: &str,
         epoch_nanoseconds: i128,
         direction: TransitionDirection,
-    ) -> Result<Option<EpochNanoseconds>, TimeZoneProviderError>;
+    ) -> TimeZoneProviderResult<Option<EpochNanoseconds>>;
 }
 
 pub struct NeverProvider;
 
 impl TimeZoneProvider for NeverProvider {
-    fn normalize_identifier(
-        &self,
-        _ident: &'_ [u8],
-    ) -> Result<Cow<'_, str>, TimeZoneProviderError> {
+    fn normalize_identifier(&self, _ident: &'_ [u8]) -> TimeZoneProviderResult<Cow<'_, str>> {
         unimplemented!()
     }
-    fn canonicalize_identifier(
-        &self,
-        _ident: &'_ [u8],
-    ) -> Result<Cow<'_, str>, TimeZoneProviderError> {
+    fn canonicalize_identifier(&self, _ident: &'_ [u8]) -> TimeZoneProviderResult<Cow<'_, str>> {
         unimplemented!()
     }
     fn get_named_tz_epoch_nanoseconds(
         &self,
         _: &str,
         _: IsoDateTime,
-    ) -> Result<CandidateEpochNanoseconds, TimeZoneProviderError> {
+    ) -> TimeZoneProviderResult<CandidateEpochNanoseconds> {
         unimplemented!()
     }
 
     fn get_named_tz_offset_nanoseconds(
         &self,
         _: &str,
         _: i128,
-    ) -> Result<TimeZoneTransitionInfo, TimeZoneProviderError> {
+    ) -> TimeZoneProviderResult<UtcOffsetSeconds> {
         unimplemented!()
     }
 
@@ -252,7 +236,7 @@ impl TimeZoneProvider for NeverProvider {
         _: &str,
         _: i128,
         _: TransitionDirection,
-    ) -> Result<Option<EpochNanoseconds>, TimeZoneProviderError> {
+    ) -> TimeZoneProviderResult<Option<EpochNanoseconds>> {
         unimplemented!()
     }
 }

provider/src/tzdb.rs

@@ -10,6 +10,12 @@
 
 use alloc::borrow::Cow;
 
+#[cfg(any(feature = "tzif", feature = "zoneinfo64"))]
+use crate::provider::TimeZoneProviderResult;
+#[cfg(any(feature = "tzif", feature = "zoneinfo64"))]
+use crate::TimeZoneProviderError;
+#[cfg(any(feature = "tzif", feature = "zoneinfo64"))]
+use crate::SINGLETON_IANA_NORMALIZER;
 use zerotrie::ZeroAsciiIgnoreCaseTrie;
 use zerovec::{VarZeroVec, ZeroVec};
 
@@ -37,3 +43,38 @@ pub struct IanaIdentifierNormalizer<'data> {
     #[cfg_attr(feature = "datagen", serde(borrow))]
     pub normalized_identifiers: VarZeroVec<'data, str>,
 }
+
+#[cfg(any(feature = "tzif", feature = "zoneinfo64"))]
+pub(crate) fn normalize_identifier_with_compiled(
+    identifier: &[u8],
+) -> TimeZoneProviderResult<Cow<'static, str>> {
+    if let Some(index) = SINGLETON_IANA_NORMALIZER.available_id_index.get(identifier) {
+        return SINGLETON_IANA_NORMALIZER
+            .normalized_identifiers
+            .get(index)
+            .map(Cow::Borrowed)
+            .ok_or(TimeZoneProviderError::Range("Unknown time zone identifier"));
+    }
+
+    Err(TimeZoneProviderError::Range("Unknown time zone identifier"))
+}
+
+#[cfg(any(feature = "tzif", feature = "zoneinfo64"))]
+pub(crate) fn canonicalize_identifier_with_compiled(
+    identifier: &[u8],
+) -> TimeZoneProviderResult<Cow<'static, str>> {
+    let idx = SINGLETON_IANA_NORMALIZER
+        .non_canonical_identifiers
+        .get(identifier)
+        .or(SINGLETON_IANA_NORMALIZER.available_id_index.get(identifier));
+
+    if let Some(index) = idx {
+        return SINGLETON_IANA_NORMALIZER
+            .normalized_identifiers
+            .get(index)
+            .map(Cow::Borrowed)
+            .ok_or(TimeZoneProviderError::Range("Unknown time zone identifier"));
+    }
+
+    Err(TimeZoneProviderError::Range("Unknown time zone identifier"))
+}