Use YearNames::FixedEras for Japanese (#7700)

robertbastian · web-flow · commit 38b9b79a7eab · 2026-03-13T13:34:18.000-04:00
diff --git a/components/datetime/src/pattern/names.rs b/components/datetime/src/pattern/names.rs
@@ -3871,6 +3871,7 @@ impl RawDateTimeNamesBorrowed<'_> {
             .ok_or(GetNameForEraError::NotLoaded)?;
 
         match year_names {
+            #[cfg(feature = "serde")]
             YearNames::VariableEras(era_names) => {
                 get_year_name_from_map(era_names, era_year.era.as_str().into())
                     .ok_or(GetNameForEraError::InvalidEraCode)
diff --git a/components/datetime/src/provider/names.rs b/components/datetime/src/provider/names.rs
@@ -8,8 +8,11 @@ use crate::size_test_macro::size_test;
 use alloc::borrow::Cow;
 use icu_pattern::SinglePlaceholderPattern;
 use icu_provider::prelude::*;
+#[cfg(feature = "serde")]
 use potential_utf::PotentialUtf8;
-use zerovec::{ule::tuplevar::Tuple2VarULE, VarZeroCow, VarZeroSlice, VarZeroVec};
+use zerovec::VarZeroVec;
+#[cfg(feature = "serde")]
+use zerovec::{ule::tuplevar::Tuple2VarULE, VarZeroCow, VarZeroSlice};
 
 icu_provider::data_marker!(
     /// `DatetimeNamesYearBuddhistV1`
@@ -231,7 +234,7 @@ size_test!(YearNames, year_names_v1_size, 32);
 /// to be stable, their Rust representation might not be. Use with caution.
 /// </div>
 #[derive(Debug, PartialEq, Clone, yoke::Yokeable, zerofrom::ZeroFrom)]
-#[cfg_attr(feature = "datagen", derive(serde::Serialize, databake::Bake))]
+#[cfg_attr(feature = "datagen", derive(databake::Bake))]
 #[cfg_attr(feature = "datagen", databake(path = icu_datetime::provider::names))]
 #[cfg_attr(feature = "serde", derive(serde::Deserialize))]
 #[yoke(prove_covariance_manually)]
@@ -242,19 +245,68 @@ pub enum YearNames<'data> {
     FixedEras(#[cfg_attr(feature = "serde", serde(borrow))] VarZeroVec<'data, str>),
     /// This calendar has a variable set of eras with numeric years, this stores the era names mapped from
     /// era code to the name.
+    #[cfg(feature = "serde")]
     VariableEras(#[cfg_attr(feature = "serde", serde(borrow))] YearNamesMap<'data>),
     /// This calendar is cyclic (Chinese, Dangi), so it uses cyclic year names without any eras
     Cyclic(#[cfg_attr(feature = "serde", serde(borrow))] VarZeroVec<'data, str>),
 }
 
+#[cfg(feature = "serde")]
+impl serde::Serialize for YearNames<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use alloc::vec::Vec;
+
+        #[derive(serde::Serialize)]
+        enum Raw<'a> {
+            FixedEras(&'a VarZeroVec<'a, str>),
+            VariableEras(&'a YearNamesMap<'a>),
+            Cyclic(&'a VarZeroVec<'a, str>),
+        }
+
+        let x: YearNamesMap;
+
+        match self {
+            // Japanese eras are now generated as `FixedEras`, but we want to keep serializing
+            // them as VariableEras. It's the only calendar with 7 eras.
+            Self::FixedEras(e) if e.len() == 7 => {
+                let mut kvs = [
+                    PotentialUtf8::from_str("bce"),
+                    PotentialUtf8::from_str("ce"),
+                    PotentialUtf8::from_str("meiji"),
+                    PotentialUtf8::from_str("taisho"),
+                    PotentialUtf8::from_str("showa"),
+                    PotentialUtf8::from_str("heisei"),
+                    PotentialUtf8::from_str("reiwa"),
+                ]
+                .into_iter()
+                .zip(e.iter())
+                .collect::<Vec<_>>();
+                kvs.sort_unstable();
+                let (ks, vs) = kvs.into_iter().unzip::<_, _, Vec<_>, Vec<_>>();
+                x = VarZeroCow::from_encodeable(&(ks, vs));
+                Raw::VariableEras(&x)
+            }
+            Self::FixedEras(e) => Raw::FixedEras(e),
+            Self::VariableEras(e) => Raw::VariableEras(e),
+            Self::Cyclic(c) => Raw::Cyclic(c),
+        }
+        .serialize(serializer)
+    }
+}
+
 icu_provider::data_struct!(
     YearNames<'_>,
     #[cfg(feature = "datagen")]
 );
 
+#[cfg(feature = "serde")]
 type YearNamesMap<'data> =
     VarZeroCow<'data, Tuple2VarULE<VarZeroSlice<PotentialUtf8>, VarZeroSlice<str>>>;
 
+#[cfg(feature = "serde")]
 pub(crate) fn get_year_name_from_map<'a>(
     map: &'a YearNamesMap<'_>,
     year: &PotentialUtf8,
diff --git a/provider/data/datetime/data/datetime_names_year_japanese_v1.rs.data b/provider/data/datetime/data/datetime_names_year_japanese_v1.rs.data
diff --git a/provider/data/datetime/fingerprints.csv b/provider/data/datetime/fingerprints.csv
diff --git a/provider/source/src/calendar/eras.rs b/provider/source/src/calendar/eras.rs
@@ -59,12 +59,16 @@ impl SourceDataProvider {
                         .map(|(key, data)| {
                             let mut data = data.clone();
                             let date = data.start.or(data.end).unwrap();
-                            let era_year = Date::try_new_gregorian(date.year, date.month, date.day)
-                                .unwrap()
-                                .to_calendar(icu::calendar::Ref(&any_cal))
-                                .year()
-                                .era()
-                                .unwrap();
+                            let era_year = Date::try_new_gregorian(
+                                date.year + data.offset,
+                                date.month,
+                                date.day,
+                            )
+                            .unwrap()
+                            .to_calendar(icu::calendar::Ref(&any_cal))
+                            .year()
+                            .era()
+                            .unwrap();
                             if era_year.era != data.code {
                                 log::warn!("mismatched era code {era_year:?} - {data:?}");
                             }
@@ -90,6 +94,13 @@ fn process_era_dates_map(
         .unwrap()
         .eras
         .retain(|_, era| !era.code.is_empty());
+    // Meiji needs an offset of 5
+    data.get_mut(DatagenCalendar::Japanese.cldr_name())
+        .unwrap()
+        .eras
+        .get_mut("232")
+        .unwrap()
+        .offset = 5;
     data
 }
 
@@ -184,13 +195,8 @@ fn test_calendar_eras() {
         for (idx, (_, era)) in data.eras.iter().enumerate() {
             let (in_era_iso, not_in_era_iso) = match (era.start, era.end) {
                 (Some(start), None) => {
-                    let year = if era.code == "meiji" {
-                        // Meiji starts roundtripping only after Meiji 6
-                        start.year + 5
-                    } else {
-                        start.year
-                    };
-                    let start = Date::try_new_iso(year, start.month, start.day).unwrap();
+                    let start =
+                        Date::try_new_iso(start.year + era.offset, start.month, start.day).unwrap();
                     (start, Date::from_rata_die(start.to_rata_die() - 1, Iso))
                 }
                 (None, Some(end)) => {
@@ -236,15 +242,10 @@ fn test_calendar_eras() {
                 assert_eq!(era_year.era, era.code);
             }
 
-            // Check that the start/end date uses year 1, and minimal/maximal month/day
-            let expected_year = if era.code == "meiji" {
-                // We started at Meiji 6 for Meiji only, above
-                6
-            } else {
-                1
-            };
+            // Check that the start/end date uses year 1 + offset, and minimal/maximal month/day
             assert_eq!(
-                era_year.year, expected_year,
+                era_year.year,
+                1 + era.offset,
                 "Didn't get correct year for {in_era:?}"
             );
 
diff --git a/provider/source/src/cldr_serde/eras.rs b/provider/source/src/cldr_serde/eras.rs
@@ -42,6 +42,10 @@ pub(crate) struct EraData {
     pub(crate) code: String,
     #[serde(rename = "_aliases", default)]
     pub(crate) aliases: String,
+    /// The offset from the arithmetic start of the era to when it was started
+    /// to be used. CLDR doesn't track this, we manually set this for Meiji.
+    #[serde(default)]
+    pub(crate) offset: i32,
     /// `EraYear::era_index`
     #[serde(skip)]
     pub(crate) icu4x_era_index: Option<u8>,
diff --git a/provider/source/src/datetime/names.rs b/provider/source/src/datetime/names.rs
@@ -16,10 +16,8 @@ use icu::datetime::provider::semantic_skeletons::marker_attrs::{
 use icu::datetime::provider::semantic_skeletons::{DatetimePatternsGlueV1, GluePattern};
 use icu_pattern::SinglePlaceholderPattern;
 use icu_provider::prelude::*;
-use potential_utf::PotentialUtf8;
 use std::borrow::Cow;
 use std::collections::{BTreeMap, HashSet};
-use zerovec::VarZeroCow;
 
 /// Most keys don't have short symbols (except weekdays)
 ///
@@ -276,21 +274,11 @@ fn years_convert(
             .max()
             .unwrap_or_default();
 
-        if calendar == DatagenCalendar::Japanese {
-            // The Japanese calendar didn't produce era indices until 2.2.0. To keep
-            // new-data-old-code working, we need to produce `YearNames::VariableEras`.
-            let kv = eras
-                .iter()
-                .map(|(&(k, _), &v)| (PotentialUtf8::from_str(k), v))
-                .unzip::<_, _, Vec<_>, Vec<_>>();
-            Ok(YearNames::VariableEras(VarZeroCow::from_encodeable(&kv)))
-        } else {
-            let mut out_eras = vec![""; max_icu4x_era_index];
-            for ((_, idx), era) in eras {
-                out_eras[idx] = era;
-            }
-            Ok(YearNames::FixedEras((&out_eras).into()))
+        let mut out_eras = vec![""; max_icu4x_era_index];
+        for ((_, idx), era) in eras {
+            out_eras[idx] = era;
         }
+        Ok(YearNames::FixedEras((&out_eras).into()))
     } else if let Some(years) = data
         .cyclic_name_sets
         .as_ref()
diff --git a/provider/source/src/tests/make_testdata.rs b/provider/source/src/tests/make_testdata.rs
@@ -226,9 +226,10 @@ impl DataExporter for ZeroCopyCheckExporter {
     fn close(&mut self) -> Result<ExporterCloseMetadata, DataError> {
         let rountrip_errors = self.rountrip_errors.get_mut().expect("poison");
         // These serialize to a different variant for stability
-        rountrip_errors.remove(&icu::datetime::provider::names::DatetimeNamesMonthDangiV1::INFO);
         rountrip_errors.remove(&icu::datetime::provider::names::DatetimeNamesMonthChineseV1::INFO);
+        rountrip_errors.remove(&icu::datetime::provider::names::DatetimeNamesMonthDangiV1::INFO);
         rountrip_errors.remove(&icu::datetime::provider::names::DatetimeNamesMonthHebrewV1::INFO);
+        rountrip_errors.remove(&icu::datetime::provider::names::DatetimeNamesYearJapaneseV1::INFO);
         assert_eq!(rountrip_errors, &mut BTreeMap::default());
 
         let violations = self
