Factor out ICU4X list formatter creation

Author: Xiretza

compiler/rustc_error_messages/src/lib.rs

@@ -19,6 +19,7 @@ pub use fluent_bundle::types::FluentType;
 use fluent_bundle::FluentResource;
 pub use fluent_bundle::{self, FluentArgs, FluentError, FluentValue};
 use fluent_syntax::parser::ParserError;
+use icu_list::ListFormatter;
 use icu_provider_adapters::fallback::{LocaleFallbackProvider, LocaleFallbacker};
 #[cfg(parallel_compiler)]
 use intl_memoizer::concurrent::IntlLangMemoizer;
@@ -528,85 +529,104 @@ fn icu_locale_from_unic_langid(lang: LanguageIdentifier) -> Option<icu_locid::Lo
     icu_locid::Locale::try_from_bytes(lang.to_string().as_bytes()).ok()
 }
 
-pub fn fluent_value_from_str_list_sep_by_and(l: Vec<Cow<'_, str>>) -> FluentValue<'_> {
-    // Fluent requires 'static value here for its AnyEq usages.
-    #[derive(Clone, PartialEq, Debug)]
-    struct FluentStrListSepByAnd(Vec<String>);
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+enum Separator {
+    And,
+}
 
-    impl FluentType for FluentStrListSepByAnd {
-        fn duplicate(&self) -> Box<dyn FluentType + Send> {
-            Box::new(self.clone())
+impl Separator {
+    fn list_formatter(
+        &self,
+        data_provider: &LocaleFallbackProvider<rustc_baked_icu_data::BakedDataProvider>,
+        locale: icu_locid::Locale,
+    ) -> ListFormatter {
+        match self {
+            Separator::And => icu_list::ListFormatter::try_new_and_with_length_with_any_provider(
+                &data_provider,
+                &locale.into(),
+                icu_list::ListLength::Wide,
+            ),
         }
+        .expect("Failed to create list formatter")
+    }
+}
 
-        fn as_string(&self, intls: &intl_memoizer::IntlLangMemoizer) -> Cow<'static, str> {
-            let result = intls
-                .with_try_get::<MemoizableListFormatter, _, _>((), |list_formatter| {
-                    list_formatter.format_to_string(self.0.iter())
-                })
-                .unwrap();
-            Cow::Owned(result)
-        }
+#[derive(Clone, PartialEq, Debug)]
+struct FluentStrListSepBy {
+    sep: Separator,
+    items: Vec<String>,
+}
 
-        #[cfg(not(parallel_compiler))]
-        fn as_string_threadsafe(
-            &self,
-            _intls: &intl_memoizer::concurrent::IntlLangMemoizer,
-        ) -> Cow<'static, str> {
-            unreachable!("`as_string_threadsafe` is not used in non-parallel rustc")
-        }
+impl FluentType for FluentStrListSepBy {
+    fn duplicate(&self) -> Box<dyn FluentType + Send> {
+        Box::new(self.clone())
+    }
 
-        #[cfg(parallel_compiler)]
-        fn as_string_threadsafe(
-            &self,
-            intls: &intl_memoizer::concurrent::IntlLangMemoizer,
-        ) -> Cow<'static, str> {
-            let result = intls
-                .with_try_get::<MemoizableListFormatter, _, _>((), |list_formatter| {
-                    list_formatter.format_to_string(self.0.iter())
-                })
-                .unwrap();
-            Cow::Owned(result)
-        }
+    fn as_string(&self, intls: &intl_memoizer::IntlLangMemoizer) -> Cow<'static, str> {
+        let result = intls
+            .with_try_get::<MemoizableListFormatter, _, _>(self.sep, |list_formatter| {
+                list_formatter.format_to_string(self.items.iter())
+            })
+            .unwrap();
+        Cow::Owned(result)
+    }
+
+    #[cfg(not(parallel_compiler))]
+    fn as_string_threadsafe(
+        &self,
+        _intls: &intl_memoizer::concurrent::IntlLangMemoizer,
+    ) -> Cow<'static, str> {
+        unreachable!("`as_string_threadsafe` is not used in non-parallel rustc")
+    }
+
+    #[cfg(parallel_compiler)]
+    fn as_string_threadsafe(
+        &self,
+        intls: &intl_memoizer::concurrent::IntlLangMemoizer,
+    ) -> Cow<'static, str> {
+        let result = intls
+            .with_try_get::<MemoizableListFormatter, _, _>(self.sep, |list_formatter| {
+                list_formatter.format_to_string(self.items.iter())
+            })
+            .unwrap();
+        Cow::Owned(result)
     }
+}
 
-    struct MemoizableListFormatter(icu_list::ListFormatter);
+struct MemoizableListFormatter(icu_list::ListFormatter);
 
-    impl std::ops::Deref for MemoizableListFormatter {
-        type Target = icu_list::ListFormatter;
-        fn deref(&self) -> &Self::Target {
-            &self.0
-        }
+impl std::ops::Deref for MemoizableListFormatter {
+    type Target = icu_list::ListFormatter;
+    fn deref(&self) -> &Self::Target {
+        &self.0
     }
+}
 
-    impl intl_memoizer::Memoizable for MemoizableListFormatter {
-        type Args = ();
-        type Error = ();
-
-        fn construct(lang: LanguageIdentifier, _args: Self::Args) -> Result<Self, Self::Error>
-        where
-            Self: Sized,
-        {
-            let baked_data_provider = rustc_baked_icu_data::baked_data_provider();
-            let locale_fallbacker =
-                LocaleFallbacker::try_new_with_any_provider(&baked_data_provider)
-                    .expect("Failed to create fallback provider");
-            let data_provider =
-                LocaleFallbackProvider::new_with_fallbacker(baked_data_provider, locale_fallbacker);
-            let locale = icu_locale_from_unic_langid(lang)
-                .unwrap_or_else(|| rustc_baked_icu_data::supported_locales::EN);
-            let list_formatter =
-                icu_list::ListFormatter::try_new_and_with_length_with_any_provider(
-                    &data_provider,
-                    &locale.into(),
-                    icu_list::ListLength::Wide,
-                )
-                .expect("Failed to create list formatter");
-
-            Ok(MemoizableListFormatter(list_formatter))
-        }
+impl intl_memoizer::Memoizable for MemoizableListFormatter {
+    type Args = Separator;
+    type Error = ();
+
+    fn construct(lang: LanguageIdentifier, separator: Separator) -> Result<Self, Self::Error>
+    where
+        Self: Sized,
+    {
+        let baked_data_provider = rustc_baked_icu_data::baked_data_provider();
+        let locale_fallbacker = LocaleFallbacker::try_new_with_any_provider(&baked_data_provider)
+            .expect("Failed to create fallback provider");
+        let data_provider =
+            LocaleFallbackProvider::new_with_fallbacker(baked_data_provider, locale_fallbacker);
+        let locale = icu_locale_from_unic_langid(lang)
+            .unwrap_or_else(|| rustc_baked_icu_data::supported_locales::EN);
+
+        let list_formatter = separator.list_formatter(&data_provider, locale);
+
+        Ok(MemoizableListFormatter(list_formatter))
     }
+}
 
-    let l = l.into_iter().map(|x| x.into_owned()).collect();
+pub fn fluent_value_from_str_list_sep_by_and(l: Vec<Cow<'_, str>>) -> FluentValue<'_> {
+    // Fluent requires 'static value here for its AnyEq usages.
+    let items = l.into_iter().map(|x| x.into_owned()).collect();
 
-    FluentValue::Custom(Box::new(FluentStrListSepByAnd(l)))
+    FluentValue::Custom(Box::new(FluentStrListSepBy { sep: Separator::And, items }))
 }