Use PotentialUtf8 for era code in DateFields

components/calendar/Cargo.toml

@@ -25,6 +25,7 @@ displaydoc = { workspace = true }
 icu_provider = { workspace = true }
 icu_locale_core = { workspace = true }
 ixdtf = { workspace = true, optional = true }
+potential_utf = { workspace = true }
 tinystr = { workspace = true, features = ["zerovec"] }
 zerovec = { workspace = true, features = ["derive"] }
 

components/calendar/src/cal/abstract_gregorian.rs

@@ -22,7 +22,11 @@ pub(crate) trait GregorianYears: Clone + core::fmt::Debug {
     // Positive if after 0 CE
     const EXTENDED_YEAR_OFFSET: i32 = 0;
 
-    fn extended_from_era_year(&self, era: Option<&str>, year: i32) -> Result<i32, UnknownEraError>;
+    fn extended_from_era_year(
+        &self,
+        era: Option<&PotentialUtf8>,
+        year: i32,
+    ) -> Result<i32, UnknownEraError>;
 
     fn era_year_from_extended(&self, extended_year: i32, month: u8, day: u8) -> EraYear;
 
@@ -90,7 +94,7 @@ impl<Y: GregorianYears> DateFieldsResolver for AbstractGregorian<Y> {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &PotentialUtf8,
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
         Ok(self.0.extended_from_era_year(Some(era), era_year)? + Y::EXTENDED_YEAR_OFFSET)
@@ -345,3 +349,4 @@ macro_rules! impl_with_abstract_gregorian {
     };
 }
 pub(crate) use impl_with_abstract_gregorian;
+use potential_utf::PotentialUtf8;

components/calendar/src/cal/buddhist.rs

@@ -9,6 +9,7 @@ use crate::{
     calendar_arithmetic::ArithmeticDate,
     types, Date, DateError, RangeError,
 };
+use potential_utf::PotentialUtf8;
 use tinystr::tinystr;
 
 #[derive(Copy, Clone, Debug, Default)]
@@ -48,8 +49,12 @@ pub(crate) struct BuddhistEra;
 impl GregorianYears for BuddhistEra {
     const EXTENDED_YEAR_OFFSET: i32 = -543;
 
-    fn extended_from_era_year(&self, era: Option<&str>, year: i32) -> Result<i32, UnknownEraError> {
-        match era {
+    fn extended_from_era_year(
+        &self,
+        era: Option<&PotentialUtf8>,
+        year: i32,
+    ) -> Result<i32, UnknownEraError> {
+        match era.and_then(|s| s.try_as_str().ok()) {
             Some("be") | None => Ok(year),
             _ => Err(UnknownEraError),
         }

components/calendar/src/cal/chinese.rs

@@ -22,6 +22,7 @@ use calendrical_calculations::chinese_based::{
 use calendrical_calculations::rata_die::RataDie;
 use icu_locale_core::preferences::extensions::unicode::keywords::CalendarAlgorithm;
 use icu_provider::prelude::*;
+use potential_utf::PotentialUtf8;
 use tinystr::tinystr;
 
 #[path = "chinese/china_data.rs"]
@@ -562,7 +563,7 @@ impl<R: Rules> DateFieldsResolver for LunarChinese<R> {
     #[inline]
     fn year_info_from_era(
         &self,
-        _era: &str,
+        _era: &PotentialUtf8,
         _era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
         // This calendar has no era codes

components/calendar/src/cal/coptic.rs

@@ -13,6 +13,7 @@ use crate::options::{DateAddOptions, DateDifferenceOptions};
 use crate::{types, Calendar, Date, RangeError};
 use calendrical_calculations::helpers::I32CastError;
 use calendrical_calculations::rata_die::RataDie;
+use potential_utf::PotentialUtf8;
 use tinystr::tinystr;
 
 /// The [Coptic Calendar]
@@ -89,11 +90,11 @@ impl DateFieldsResolver for Coptic {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &PotentialUtf8,
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
-        match era {
-            "am" => Ok(era_year),
+        match era.try_as_str() {
+            Ok("am") => Ok(era_year),
             _ => Err(UnknownEraError),
         }
     }

components/calendar/src/cal/ethiopian.rs

@@ -14,6 +14,7 @@ use crate::options::{DateAddOptions, DateDifferenceOptions};
 use crate::types::DateFields;
 use crate::{types, Calendar, Date, RangeError};
 use calendrical_calculations::rata_die::RataDie;
+use potential_utf::PotentialUtf8;
 use tinystr::tinystr;
 
 /// The Coptic year of the Amete Mihret epoch
@@ -79,12 +80,12 @@ impl DateFieldsResolver for Ethiopian {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &PotentialUtf8,
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
-        match (self.era_style(), era) {
-            (EthiopianEraStyle::AmeteMihret, "am") => Ok(era_year + AMETE_MIHRET_OFFSET),
-            (_, "aa") => Ok(era_year + AMETE_ALEM_OFFSET),
+        match (self.era_style(), era.try_as_str()) {
+            (EthiopianEraStyle::AmeteMihret, Ok("am")) => Ok(era_year + AMETE_MIHRET_OFFSET),
+            (_, Ok("aa")) => Ok(era_year + AMETE_ALEM_OFFSET),
             (_, _) => Err(UnknownEraError),
         }
     }

components/calendar/src/cal/gregorian.rs

@@ -7,6 +7,7 @@ use crate::calendar_arithmetic::ArithmeticDate;
 use crate::error::UnknownEraError;
 use crate::preferences::CalendarAlgorithm;
 use crate::{types, Date, DateError, RangeError};
+use potential_utf::PotentialUtf8;
 use tinystr::tinystr;
 
 impl_with_abstract_gregorian!(crate::cal::Gregorian, GregorianDateInner, CeBce, _x, CeBce);
@@ -15,8 +16,12 @@ impl_with_abstract_gregorian!(crate::cal::Gregorian, GregorianDateInner, CeBce,
 pub(crate) struct CeBce;
 
 impl GregorianYears for CeBce {
-    fn extended_from_era_year(&self, era: Option<&str>, year: i32) -> Result<i32, UnknownEraError> {
-        match era {
+    fn extended_from_era_year(
+        &self,
+        era: Option<&PotentialUtf8>,
+        year: i32,
+    ) -> Result<i32, UnknownEraError> {
+        match era.and_then(|s| s.try_as_str().ok()) {
             None => Ok(year),
             Some("ad" | "ce") => Ok(year),
             Some("bce" | "bc") => Ok(1 - year),

components/calendar/src/cal/hebrew.rs

@@ -18,6 +18,7 @@ use crate::{types, Calendar, Date};
 use ::tinystr::tinystr;
 use calendrical_calculations::hebrew_keviyah::{Keviyah, YearInfo};
 use calendrical_calculations::rata_die::RataDie;
+use potential_utf::PotentialUtf8;
 
 /// The [Hebrew Calendar](https://en.wikipedia.org/wiki/Hebrew_calendar)
 ///
@@ -123,11 +124,11 @@ impl DateFieldsResolver for Hebrew {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &PotentialUtf8,
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
-        match era {
-            "am" => Ok(HebrewYearInfo::compute(era_year)),
+        match era.try_as_str() {
+            Ok("am") => Ok(HebrewYearInfo::compute(era_year)),
             _ => Err(UnknownEraError),
         }
     }

components/calendar/src/cal/hijri.rs

@@ -22,6 +22,7 @@ use icu_locale_core::preferences::extensions::unicode::keywords::{
     CalendarAlgorithm, HijriCalendarAlgorithm,
 };
 use icu_provider::prelude::*;
+use potential_utf::PotentialUtf8;
 use tinystr::tinystr;
 
 #[path = "hijri/simulated_mecca_data.rs"]
@@ -725,12 +726,12 @@ impl<R: Rules> DateFieldsResolver for Hijri<R> {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &PotentialUtf8,
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
-        let extended_year = match era {
-            "ah" => era_year,
-            "bh" => 1 - era_year,
+        let extended_year = match era.try_as_str() {
+            Ok("ah") => era_year,
+            Ok("bh") => 1 - era_year,
             _ => return Err(UnknownEraError),
         };
         Ok(self.year_info_from_extended(extended_year))

components/calendar/src/cal/indian.rs

@@ -11,6 +11,7 @@ use crate::options::{DateAddOptions, DateDifferenceOptions};
 use crate::types::DateFields;
 use crate::{types, Calendar, Date, RangeError};
 use calendrical_calculations::rata_die::RataDie;
+use potential_utf::PotentialUtf8;
 use tinystr::tinystr;
 
 /// The [Indian National (Śaka) Calendar](https://en.wikipedia.org/wiki/Indian_national_calendar)
@@ -82,11 +83,11 @@ impl DateFieldsResolver for Indian {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &PotentialUtf8,
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
-        match era {
-            "shaka" => Ok(era_year),
+        match era.try_as_str() {
+            Ok("shaka") => Ok(era_year),
             _ => Err(UnknownEraError),
         }
     }

components/calendar/src/cal/iso.rs

@@ -6,6 +6,7 @@ use crate::cal::abstract_gregorian::{impl_with_abstract_gregorian, GregorianYear
 use crate::calendar_arithmetic::ArithmeticDate;
 use crate::error::UnknownEraError;
 use crate::{types, Date, DateError, RangeError};
+use potential_utf::PotentialUtf8;
 use tinystr::tinystr;
 
 /// The [ISO-8601 Calendar](https://en.wikipedia.org/wiki/ISO_8601#Dates)
@@ -31,8 +32,12 @@ impl_with_abstract_gregorian!(crate::cal::Iso, IsoDateInner, IsoEra, _x, IsoEra)
 pub(crate) struct IsoEra;
 
 impl GregorianYears for IsoEra {
-    fn extended_from_era_year(&self, era: Option<&str>, year: i32) -> Result<i32, UnknownEraError> {
-        match era {
+    fn extended_from_era_year(
+        &self,
+        era: Option<&PotentialUtf8>,
+        year: i32,
+    ) -> Result<i32, UnknownEraError> {
+        match era.and_then(|s| s.try_as_str().ok()) {
             Some("default") | None => Ok(year),
             Some(_) => Err(UnknownEraError),
         }

components/calendar/src/cal/japanese.rs

@@ -9,6 +9,7 @@ use crate::error::{DateError, UnknownEraError};
 use crate::provider::{CalendarJapaneseExtendedV1, CalendarJapaneseModernV1, EraStartDate};
 use crate::{types, AsCalendar, Date};
 use icu_provider::prelude::*;
+use potential_utf::PotentialUtf8;
 use tinystr::tinystr;
 
 /// The [Japanese Calendar] (with modern eras only)
@@ -169,11 +170,15 @@ const REIWA_START: EraStartDate = EraStartDate {
 };
 
 impl GregorianYears for &'_ Japanese {
-    fn extended_from_era_year(&self, era: Option<&str>, year: i32) -> Result<i32, UnknownEraError> {
+    fn extended_from_era_year(
+        &self,
+        era: Option<&PotentialUtf8>,
+        year: i32,
+    ) -> Result<i32, UnknownEraError> {
         if let Ok(g) = CeBce.extended_from_era_year(era, year) {
             return Ok(g);
         }
-        let Some(era) = era else {
+        let Some(era) = era.and_then(|s| s.try_as_str().ok()) else {
             // unreachable, handled by CeBce
             return Err(UnknownEraError);
         };
@@ -341,7 +346,7 @@ impl Date<Japanese> {
     ) -> Result<Date<A>, DateError> {
         let extended = japanese_calendar
             .as_calendar()
-            .extended_from_era_year(Some(era), year)?;
+            .extended_from_era_year(Some(era.into()), year)?;
         Ok(Date::from_raw(
             JapaneseDateInner(ArithmeticDate::new_gregorian::<&Japanese>(
                 extended, month, day,
@@ -393,7 +398,7 @@ impl Date<JapaneseExtended> {
         japanext_calendar: A,
     ) -> Result<Date<A>, DateError> {
         let extended =
-            (&japanext_calendar.as_calendar().0).extended_from_era_year(Some(era), year)?;
+            (&japanext_calendar.as_calendar().0).extended_from_era_year(Some(era.into()), year)?;
         Ok(Date::from_raw(
             JapaneseExtendedDateInner(ArithmeticDate::new_gregorian::<&Japanese>(
                 extended, month, day,

components/calendar/src/cal/julian.rs

@@ -12,6 +12,7 @@ use crate::types::DateFields;
 use crate::{types, Calendar, Date, RangeError};
 use calendrical_calculations::helpers::I32CastError;
 use calendrical_calculations::rata_die::RataDie;
+use potential_utf::PotentialUtf8;
 use tinystr::tinystr;
 
 /// The [Julian Calendar](https://en.wikipedia.org/wiki/Julian_calendar).
@@ -107,12 +108,12 @@ impl DateFieldsResolver for Julian {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &PotentialUtf8,
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
-        match era {
-            "ad" | "ce" => Ok(era_year),
-            "bc" | "bce" => Ok(1 - era_year),
+        match era.try_as_str() {
+            Ok("ad") | Ok("ce") => Ok(era_year),
+            Ok("bc") | Ok("bce") => Ok(1 - era_year),
             _ => Err(UnknownEraError),
         }
     }

components/calendar/src/cal/persian.rs

@@ -13,6 +13,7 @@ use crate::{types, Calendar, Date, RangeError};
 use ::tinystr::tinystr;
 use calendrical_calculations::helpers::I32CastError;
 use calendrical_calculations::rata_die::RataDie;
+use potential_utf::PotentialUtf8;
 
 /// The [Persian Calendar](https://en.wikipedia.org/wiki/Solar_Hijri_calendar)
 ///
@@ -81,11 +82,11 @@ impl DateFieldsResolver for Persian {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &PotentialUtf8,
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
-        match era {
-            "ap" | "sh" | "hs" => Ok(era_year),
+        match era.try_as_str() {
+            Ok("ap") | Ok("sh") | Ok("hs") => Ok(era_year),
             _ => Err(UnknownEraError),
         }
     }

components/calendar/src/cal/roc.rs

@@ -7,6 +7,7 @@ use crate::calendar_arithmetic::ArithmeticDate;
 use crate::error::UnknownEraError;
 use crate::preferences::CalendarAlgorithm;
 use crate::{types, Date, DateError, RangeError};
+use potential_utf::PotentialUtf8;
 use tinystr::tinystr;
 
 /// The [Republic of China Calendar](https://en.wikipedia.org/wiki/Republic_of_China_calendar)
@@ -41,8 +42,12 @@ pub(crate) struct RocEra;
 impl GregorianYears for RocEra {
     const EXTENDED_YEAR_OFFSET: i32 = 1911;
 
-    fn extended_from_era_year(&self, era: Option<&str>, year: i32) -> Result<i32, UnknownEraError> {
-        match era {
+    fn extended_from_era_year(
+        &self,
+        era: Option<&PotentialUtf8>,
+        year: i32,
+    ) -> Result<i32, UnknownEraError> {
+        match era.and_then(|s| s.try_as_str().ok()) {
             None => Ok(year),
             Some("roc") => Ok(year),
             Some("broc") => Ok(1 - year),

components/calendar/src/calendar.rs

@@ -49,7 +49,7 @@ pub trait Calendar: crate::cal::scaffold::UnstableSealed {
     ) -> Result<Self::DateInner, DateError> {
         let mut fields = types::DateFields::default();
         if era.is_some() {
-            fields.era = era;
+            fields.era = era.map(Into::into);
             fields.era_year = Some(year);
         } else {
             fields.extended_year = Some(year);

components/calendar/src/calendar_arithmetic.rs

@@ -16,6 +16,7 @@ use core::fmt::Debug;
 use core::hash::{Hash, Hasher};
 use core::marker::PhantomData;
 use core::ops::RangeInclusive;
+use potential_utf::PotentialUtf8;
 use tinystr::tinystr;
 
 /// The range ±2²⁷. We use i32::MIN since it is -2³¹
@@ -152,7 +153,7 @@ pub(crate) trait DateFieldsResolver: Calendar {
     /// this should always return an Err result.
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &PotentialUtf8,
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError>;