Move DateFields::era over to being a byte slice (#7115)

Progress on #7104. I didn't
touch MonthCode yet since it becomes easier after
#7105 lands.

Author: Manishearth

components/calendar/src/cal/abstract_gregorian.rs

@@ -22,7 +22,8 @@ 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<&[u8]>, year: i32)
+        -> Result<i32, UnknownEraError>;
 
     fn era_year_from_extended(&self, extended_year: i32, month: u8, day: u8) -> EraYear;
 
@@ -90,7 +91,7 @@ impl<Y: GregorianYears> DateFieldsResolver for AbstractGregorian<Y> {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &[u8],
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
         Ok(self.0.extended_from_era_year(Some(era), era_year)? + Y::EXTENDED_YEAR_OFFSET)

components/calendar/src/cal/buddhist.rs

@@ -48,9 +48,13 @@ 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> {
+    fn extended_from_era_year(
+        &self,
+        era: Option<&[u8]>,
+        year: i32,
+    ) -> Result<i32, UnknownEraError> {
         match era {
-            Some("be") | None => Ok(year),
+            Some(b"be") | None => Ok(year),
             _ => Err(UnknownEraError),
         }
     }

components/calendar/src/cal/chinese.rs

@@ -562,7 +562,7 @@ impl<R: Rules> DateFieldsResolver for LunarChinese<R> {
     #[inline]
     fn year_info_from_era(
         &self,
-        _era: &str,
+        _era: &[u8],
         _era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
         // This calendar has no era codes

components/calendar/src/cal/coptic.rs

@@ -89,11 +89,11 @@ impl DateFieldsResolver for Coptic {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &[u8],
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
         match era {
-            "am" => Ok(era_year),
+            b"am" => Ok(era_year),
             _ => Err(UnknownEraError),
         }
     }

components/calendar/src/cal/ethiopian.rs

@@ -79,12 +79,12 @@ impl DateFieldsResolver for Ethiopian {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &[u8],
         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),
+            (EthiopianEraStyle::AmeteMihret, b"am") => Ok(era_year + AMETE_MIHRET_OFFSET),
+            (_, b"aa") => Ok(era_year + AMETE_ALEM_OFFSET),
             (_, _) => Err(UnknownEraError),
         }
     }

components/calendar/src/cal/gregorian.rs

@@ -15,11 +15,15 @@ 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> {
+    fn extended_from_era_year(
+        &self,
+        era: Option<&[u8]>,
+        year: i32,
+    ) -> Result<i32, UnknownEraError> {
         match era {
             None => Ok(year),
-            Some("ad" | "ce") => Ok(year),
-            Some("bce" | "bc") => Ok(1 - year),
+            Some(b"ad" | b"ce") => Ok(year),
+            Some(b"bce" | b"bc") => Ok(1 - year),
             Some(_) => Err(UnknownEraError),
         }
     }

components/calendar/src/cal/hebrew.rs

@@ -123,11 +123,11 @@ impl DateFieldsResolver for Hebrew {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &[u8],
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
         match era {
-            "am" => Ok(HebrewYearInfo::compute(era_year)),
+            b"am" => Ok(HebrewYearInfo::compute(era_year)),
             _ => Err(UnknownEraError),
         }
     }

components/calendar/src/cal/hijri.rs

@@ -725,12 +725,12 @@ impl<R: Rules> DateFieldsResolver for Hijri<R> {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &[u8],
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
         let extended_year = match era {
-            "ah" => era_year,
-            "bh" => 1 - era_year,
+            b"ah" => era_year,
+            b"bh" => 1 - era_year,
             _ => return Err(UnknownEraError),
         };
         Ok(self.year_info_from_extended(extended_year))

components/calendar/src/cal/indian.rs

@@ -82,11 +82,11 @@ impl DateFieldsResolver for Indian {
     #[inline]
     fn year_info_from_era(
         &self,
-        era: &str,
+        era: &[u8],
         era_year: i32,
     ) -> Result<Self::YearInfo, UnknownEraError> {
         match era {
-            "shaka" => Ok(era_year),
+            b"shaka" => Ok(era_year),
             _ => Err(UnknownEraError),
         }
     }

components/calendar/src/cal/iso.rs

@@ -31,9 +31,13 @@ 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> {
+    fn extended_from_era_year(
+        &self,
+        era: Option<&[u8]>,
+        year: i32,
+    ) -> Result<i32, UnknownEraError> {
         match era {
-            Some("default") | None => Ok(year),
+            Some(b"default") | None => Ok(year),
             Some(_) => Err(UnknownEraError),
         }
     }