Change ConflictingField error to contain the previously loaded field

components/datetime/src/pattern/mod.rs

@@ -73,8 +73,13 @@ pub enum PatternLoadError {
     /// Fields conflict if they require the same type of data, for example the
     /// `EEE` and `EEEE` fields (short vs long weekday) conflict, or the `M`
     /// and `L` (format vs standalone month) conflict.
-    #[displaydoc("A field {0:?} conflicts with a previous field.")]
-    ConflictingField(ErrorField),
+    #[displaydoc("A field {field:?} conflicts with a previously loaded field {previous_field:?}.")]
+    ConflictingField {
+        /// The field that was not able to be loaded.
+        field: ErrorField,
+        /// The field that prevented the new field from being loaded.
+        previous_field: ErrorField,
+    },
     /// The field symbol is not supported in that length.
     ///
     /// Some fields, such as `O` are not defined for all lengths (e.g. `OO`).

components/datetime/src/pattern/names.rs

@@ -1247,7 +1247,7 @@ impl<C: CldrCalendar, FSet: DateTimeNamesMarker> FixedCalendarDateTimeNames<C, F
     /// // But loading a new length fails:
     /// assert!(matches!(
     ///     names.include_year_names(YearNameLength::Abbreviated),
-    ///     Err(PatternLoadError::ConflictingField(_))
+    ///     Err(PatternLoadError::ConflictingField { .. })
     /// ));
     /// ```
     #[cfg(feature = "compiled_data")]
@@ -1309,11 +1309,11 @@ impl<C: CldrCalendar, FSet: DateTimeNamesMarker> FixedCalendarDateTimeNames<C, F
     /// // But loading a new symbol or length fails:
     /// assert!(matches!(
     ///     names.include_month_names(MonthNameLength::StandaloneWide),
-    ///     Err(PatternLoadError::ConflictingField(_))
+    ///     Err(PatternLoadError::ConflictingField { .. })
     /// ));
     /// assert!(matches!(
     ///     names.include_month_names(MonthNameLength::Abbreviated),
-    ///     Err(PatternLoadError::ConflictingField(_))
+    ///     Err(PatternLoadError::ConflictingField { .. })
     /// ));
     /// ```
     #[cfg(feature = "compiled_data")]
@@ -1382,7 +1382,7 @@ impl<C, FSet: DateTimeNamesMarker> FixedCalendarDateTimeNames<C, FSet> {
     /// // But loading a new length fails:
     /// assert!(matches!(
     ///     names.include_day_period_names(DayPeriodNameLength::Abbreviated),
-    ///     Err(PatternLoadError::ConflictingField(_))
+    ///     Err(PatternLoadError::ConflictingField { .. })
     /// ));
     /// ```
     #[cfg(feature = "compiled_data")]
@@ -1445,11 +1445,11 @@ impl<C, FSet: DateTimeNamesMarker> FixedCalendarDateTimeNames<C, FSet> {
     /// // But loading a new symbol or length fails:
     /// assert!(matches!(
     ///     names.include_weekday_names(WeekdayNameLength::StandaloneWide),
-    ///     Err(PatternLoadError::ConflictingField(_))
+    ///     Err(PatternLoadError::ConflictingField { .. })
     /// ));
     /// assert!(matches!(
     ///     names.include_weekday_names(WeekdayNameLength::Abbreviated),
-    ///     Err(PatternLoadError::ConflictingField(_))
+    ///     Err(PatternLoadError::ConflictingField { .. })
     /// ));
     /// ```
     #[cfg(feature = "compiled_data")]

components/datetime/src/scaffold/names_storage.rs

@@ -43,6 +43,45 @@ pub trait DateTimeNamesMarker: UnstableSealed {
     type MetazoneLookup: NamesContainer<tz::MzPeriodV1, ()>;
 }
 
+/// A trait for `Variables` that can be converted to [`ErrorField`]
+pub trait MaybeAsErrorField: UnstableSealed {
+    fn maybe_as_error_field(&self) -> Option<ErrorField>;
+}
+
+impl MaybeAsErrorField for () {
+    fn maybe_as_error_field(&self) -> Option<ErrorField> {
+        None
+    }
+}
+
+impl UnstableSealed for YearNameLength {}
+impl MaybeAsErrorField for YearNameLength {
+    fn maybe_as_error_field(&self) -> Option<ErrorField> {
+        Some(self.to_approximate_error_field())
+    }
+}
+
+impl UnstableSealed for MonthNameLength {}
+impl MaybeAsErrorField for MonthNameLength {
+    fn maybe_as_error_field(&self) -> Option<ErrorField> {
+        Some(self.to_approximate_error_field())
+    }
+}
+
+impl UnstableSealed for WeekdayNameLength {}
+impl MaybeAsErrorField for WeekdayNameLength {
+    fn maybe_as_error_field(&self) -> Option<ErrorField> {
+        Some(self.to_approximate_error_field())
+    }
+}
+
+impl UnstableSealed for DayPeriodNameLength {}
+impl MaybeAsErrorField for DayPeriodNameLength {
+    fn maybe_as_error_field(&self) -> Option<ErrorField> {
+        Some(self.to_approximate_error_field())
+    }
+}
+
 /// Trait that associates a container for a payload parameterized by the given variables.
 ///
 /// <div class="stab unstable">
@@ -69,7 +108,7 @@ macro_rules! impl_holder_trait {
         impl UnstableSealed for $marker {}
         impl<Variables> NamesContainer<$marker, Variables> for $marker
         where
-            Variables: PartialEq + Copy + fmt::Debug,
+            Variables: PartialEq + Copy + MaybeAsErrorField + fmt::Debug,
         {
             type Container = DataPayloadWithVariables<$marker, Variables>;
         }
@@ -97,10 +136,10 @@ impl_holder_trait!(tz::MzPeriodV1);
 #[derive(Debug, displaydoc::Display)]
 #[non_exhaustive]
 pub enum MaybePayloadError {
-    /// TODO
+    /// The container's field set doesn't support the field
     FormatterTooSpecific,
-    /// TODO
-    ConflictingField,
+    /// The field is already loaded with a different length
+    ConflictingField(ErrorField),
 }
 
 impl core::error::Error for MaybePayloadError {}
@@ -109,7 +148,10 @@ impl MaybePayloadError {
     pub(crate) fn into_load_error(self, error_field: ErrorField) -> PatternLoadError {
         match self {
             Self::FormatterTooSpecific => PatternLoadError::FormatterTooSpecific(error_field),
-            Self::ConflictingField => PatternLoadError::ConflictingField(error_field),
+            Self::ConflictingField(loaded_field) => PatternLoadError::ConflictingField {
+                field: error_field,
+                previous_field: loaded_field,
+            },
         }
     }
 }
@@ -200,7 +242,7 @@ where
 impl<M: DynamicDataMarker, Variables> MaybePayload<M, Variables>
     for DataPayloadWithVariables<M, Variables>
 where
-    Variables: PartialEq + Copy,
+    Variables: PartialEq + Copy + MaybeAsErrorField,
 {
     #[inline]
     fn new_empty() -> Self {
@@ -224,8 +266,19 @@ where
                 // TODO(#6063): probably not correct
                 return Ok(Ok(Default::default()));
             }
-            OptionalNames::SingleLength { .. } => {
-                return Err(MaybePayloadError::ConflictingField);
+            OptionalNames::SingleLength { variables, .. } => {
+                let loaded_field = match variables.maybe_as_error_field() {
+                    Some(x) => x,
+                    None => {
+                        debug_assert!(false, "all non-unit variables implement this trait");
+                        use crate::provider::fields::*;
+                        ErrorField(Field {
+                            symbol: FieldSymbol::Era,
+                            length: FieldLength::Six,
+                        })
+                    }
+                };
+                return Err(MaybePayloadError::ConflictingField(loaded_field));
             }
             OptionalNames::None => (),
         };

ffi/capi/src/errors.rs

@@ -204,7 +204,7 @@ impl From<icu_datetime::DateTimeFormatterLoadError> for DateTimeFormatterLoadErr
     fn from(e: icu_datetime::DateTimeFormatterLoadError) -> Self {
         match e {
             icu_datetime::DateTimeFormatterLoadError::Names(
-                icu_datetime::pattern::PatternLoadError::ConflictingField(_),
+                icu_datetime::pattern::PatternLoadError::ConflictingField { .. },
             ) => Self::ConflictingField,
             icu_datetime::DateTimeFormatterLoadError::Names(
                 icu_datetime::pattern::PatternLoadError::UnsupportedLength(_),
@@ -246,7 +246,9 @@ impl From<icu_provider::DataError> for DateTimeFormatterLoadError {
 impl From<icu_datetime::pattern::PatternLoadError> for ffi::DateTimeFormatterLoadError {
     fn from(value: icu_datetime::pattern::PatternLoadError) -> Self {
         match value {
-            icu_datetime::pattern::PatternLoadError::ConflictingField(_) => Self::ConflictingField,
+            icu_datetime::pattern::PatternLoadError::ConflictingField { .. } => {
+                Self::ConflictingField
+            }
             icu_datetime::pattern::PatternLoadError::UnsupportedLength(_) => {
                 Self::UnsupportedLength
             }