Remove IterableDataProvider::supports_request and rename supported_requests to iter_requests

components/experimental/src/transliterate/compile/mod.rs

@@ -466,7 +466,7 @@ where
         + DataProvider<XidStartV1Marker>,
     NP: ?Sized,
 {
-    fn supported_requests(&self) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
+    fn iter_requests(&self) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         let exclusive_data = self.collection.data.borrow();
         Ok(exclusive_data
             .0

provider/adapters/src/either.rs

@@ -71,14 +71,14 @@ impl<
     > datagen::IterableDynamicDataProvider<M> for EitherProvider<P0, P1>
 {
     #[inline]
-    fn supported_requests_for_marker(
+    fn iter_requests_for_marker(
         &self,
         marker: DataMarkerInfo,
     ) -> Result<std::collections::HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         use EitherProvider::*;
         match self {
-            A(p) => p.supported_requests_for_marker(marker),
-            B(p) => p.supported_requests_for_marker(marker),
+            A(p) => p.iter_requests_for_marker(marker),
+            B(p) => p.iter_requests_for_marker(marker),
         }
     }
 }
@@ -88,13 +88,13 @@ impl<M: DataMarker, P0: datagen::IterableDataProvider<M>, P1: datagen::IterableD
     datagen::IterableDataProvider<M> for EitherProvider<P0, P1>
 {
     #[inline]
-    fn supported_requests(
+    fn iter_requests(
         &self,
     ) -> Result<std::collections::HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         use EitherProvider::*;
         match self {
-            A(p) => p.supported_requests(),
-            B(p) => p.supported_requests(),
+            A(p) => p.iter_requests(),
+            B(p) => p.iter_requests(),
         }
     }
 }

provider/adapters/src/empty.rs

@@ -91,7 +91,7 @@ impl<M> icu_provider::datagen::IterableDataProvider<M> for EmptyDataProvider
 where
     M: DataMarker,
 {
-    fn supported_requests(
+    fn iter_requests(
         &self,
     ) -> Result<std::collections::HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         Ok(Default::default())
@@ -103,7 +103,7 @@ impl<M> icu_provider::datagen::IterableDynamicDataProvider<M> for EmptyDataProvi
 where
     M: DynamicDataMarker,
 {
-    fn supported_requests_for_marker(
+    fn iter_requests_for_marker(
         &self,
         _: DataMarkerInfo,
     ) -> Result<std::collections::HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {

provider/adapters/src/filter/impls.rs

@@ -60,8 +60,8 @@ where
     /// ));
     ///
     /// // English should not appear in the iterator result:
-    /// let supported_langids = provider
-    ///     .supported_requests()
+    /// let available_langids = provider
+    ///     .iter_requests()
     ///     .expect("Should successfully make an iterator of supported locales")
     ///     .into_iter()
     ///     .map(|(locale, _)| locale.get_langid())

provider/adapters/src/filter/mod.rs

@@ -44,7 +44,7 @@ use icu_provider::prelude::*;
 ///
 /// Data requests that are rejected by the filter will return a [`DataError`] with kind
 /// [`FilteredResource`](DataErrorKind::FilteredResource), and they will not be returned
-/// by [`datagen::IterableDynamicDataProvider::supported_requests_for_marker`].
+/// by [`datagen::IterableDynamicDataProvider::iter_requests_for_marker`].
 ///
 /// Although this struct can be created directly, the traits in this module provide helper
 /// functions for common filtering patterns.
@@ -126,11 +126,11 @@ where
     F: Fn(DataRequest) -> bool,
     D: datagen::IterableDynamicDataProvider<M>,
 {
-    fn supported_requests_for_marker(
+    fn iter_requests_for_marker(
         &self,
         marker: DataMarkerInfo,
     ) -> Result<std::collections::HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
-        self.inner.supported_requests_for_marker(marker).map(|set| {
+        self.inner.iter_requests_for_marker(marker).map(|set| {
             // Use filter_map instead of filter to avoid cloning the locale
             set.into_iter()
                 .filter(|(locale, marker_attributes)| {
@@ -152,10 +152,10 @@ where
     F: Fn(DataRequest) -> bool,
     D: datagen::IterableDataProvider<M>,
 {
-    fn supported_requests(
+    fn iter_requests(
         &self,
     ) -> Result<std::collections::HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
-        self.inner.supported_requests().map(|vec| {
+        self.inner.iter_requests().map(|vec| {
             // Use filter_map instead of filter to avoid cloning the locale
             vec.into_iter()
                 .filter(|(locale, marker_attributes)| {

provider/adapters/src/fork/by_error.rs

@@ -110,17 +110,17 @@ where
     P1: datagen::IterableDynamicDataProvider<M>,
     F: ForkByErrorPredicate,
 {
-    fn supported_requests_for_marker(
+    fn iter_requests_for_marker(
         &self,
         marker: DataMarkerInfo,
     ) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
-        let result = self.0.supported_requests_for_marker(marker);
+        let result = self.0.iter_requests_for_marker(marker);
         match result {
             Ok(ok) => return Ok(ok),
             Err(err) if !self.2.test(marker, None, err) => return Err(err),
             _ => (),
         };
-        self.1.supported_requests_for_marker(marker)
+        self.1.iter_requests_for_marker(marker)
     }
 }
 
@@ -240,13 +240,13 @@ where
     P: datagen::IterableDynamicDataProvider<M>,
     F: ForkByErrorPredicate,
 {
-    fn supported_requests_for_marker(
+    fn iter_requests_for_marker(
         &self,
         marker: DataMarkerInfo,
     ) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         let mut last_error = F::UNIT_ERROR.with_marker(marker);
         for provider in self.providers.iter() {
-            let result = provider.supported_requests_for_marker(marker);
+            let result = provider.iter_requests_for_marker(marker);
             match result {
                 Ok(ok) => return Ok(ok),
                 Err(err) if !self.predicate.test(marker, None, err) => return Err(err),

provider/baked/src/export.rs

@@ -415,7 +415,7 @@ impl DataExporter for BakedExporter {
         }, quote! {
             #maybe_msrv
             impl icu_provider::datagen::IterableDataProvider<#marker_bake> for $provider {
-                fn supported_requests(&self) -> Result<std::collections::HashSet<(icu_provider::DataLocale, icu_provider::DataMarkerAttributes)>, icu_provider::DataError> {
+                fn iter_requests(&self) -> Result<std::collections::HashSet<(icu_provider::DataLocale, icu_provider::DataMarkerAttributes)>, icu_provider::DataError> {
                     Ok(HashSet::from_iter([Default::default()]))
                 }
             }
@@ -451,7 +451,7 @@ impl DataExporter for BakedExporter {
                 quote! {
                     #maybe_msrv
                     impl icu_provider::datagen::IterableDataProvider<#marker_bake> for $provider {
-                        fn supported_requests(&self) -> Result<std::collections::HashSet<(icu_provider::DataLocale, icu_provider::DataMarkerAttributes)>, icu_provider::DataError> {
+                        fn iter_requests(&self) -> Result<std::collections::HashSet<(icu_provider::DataLocale, icu_provider::DataMarkerAttributes)>, icu_provider::DataError> {
                             Ok(Default::default())
                         }
                     }
@@ -568,7 +568,7 @@ impl DataExporter for BakedExporter {
                 quote! {
                     #maybe_msrv
                     impl icu_provider::datagen::IterableDataProvider<#marker_bake> for $provider {
-                        fn supported_requests(&self) -> Result<std::collections::HashSet<(icu_provider::DataLocale, icu_provider::DataMarkerAttributes)>, icu_provider::DataError> {
+                        fn iter_requests(&self) -> Result<std::collections::HashSet<(icu_provider::DataLocale, icu_provider::DataMarkerAttributes)>, icu_provider::DataError> {
                             Ok(icu_provider_baked::DataStore::iter(&Self::#data_ident).collect())
                         }
                     }

provider/baked/tests/data/hello_world_v1_marker.rs.data

@@ -55,7 +55,7 @@ macro_rules! __impl_hello_world_v1_marker {
         __impl_hello_world_v1_marker!($provider);
         #[clippy::msrv = "1.70"]
         impl icu_provider::datagen::IterableDataProvider<icu_provider::hello_world::HelloWorldV1Marker> for $provider {
-            fn supported_requests(&self) -> Result<std::collections::HashSet<(icu_provider::DataLocale, icu_provider::DataMarkerAttributes)>, icu_provider::DataError> {
+            fn iter_requests(&self) -> Result<std::collections::HashSet<(icu_provider::DataLocale, icu_provider::DataMarkerAttributes)>, icu_provider::DataError> {
                 Ok(icu_provider_baked::DataStore::iter(&Self::DATA_HELLO_WORLD_V1_MARKER).collect())
             }
         }

provider/baked/tests/test-baked-source.rs

@@ -21,10 +21,7 @@ const _: () = {
 fn iter() {
     use icu_provider::datagen::IterableDataProvider;
     use icu_provider::hello_world::HelloWorldProvider;
-    assert_eq!(
-        Baked.supported_requests(),
-        HelloWorldProvider.supported_requests(),
-    )
+    assert_eq!(Baked.iter_requests(), HelloWorldProvider.iter_requests(),)
 }
 
 #[test]
@@ -33,7 +30,7 @@ fn load() {
     use icu_provider::hello_world::HelloWorldProvider;
     use icu_provider::prelude::*;
 
-    for (locale, marker_attributes) in HelloWorldProvider.supported_requests().unwrap().iter() {
+    for (locale, marker_attributes) in HelloWorldProvider.iter_requests().unwrap().iter() {
         let req = DataRequest {
             locale,
             marker_attributes,

provider/bikeshed/src/calendar/chinese_based.rs

@@ -7,7 +7,6 @@ use std::collections::HashSet;
 use crate::DatagenProvider;
 use calendrical_calculations::chinese_based::{Chinese, ChineseBased, Dangi};
 use icu::calendar::provider::chinese_based::*;
-use icu_provider::datagen::IterableDataProvider;
 use icu_provider::prelude::*;
 
 const YEARS: i32 = 250;
@@ -41,14 +40,18 @@ impl DataProvider<DangiCacheV1Marker> for DatagenProvider {
     }
 }
 
-impl IterableDataProvider<ChineseCacheV1Marker> for DatagenProvider {
-    fn supported_requests(&self) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
+impl crate::IterableDataProviderCached<ChineseCacheV1Marker> for DatagenProvider {
+    fn iter_requests_cached(
+        &self,
+    ) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         Ok(HashSet::from_iter([Default::default()]))
     }
 }
 
-impl IterableDataProvider<DangiCacheV1Marker> for DatagenProvider {
-    fn supported_requests(&self) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
+impl crate::IterableDataProviderCached<DangiCacheV1Marker> for DatagenProvider {
+    fn iter_requests_cached(
+        &self,
+    ) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         Ok(HashSet::from_iter([Default::default()]))
     }
 }

provider/bikeshed/src/calendar/islamic.rs

@@ -10,7 +10,6 @@ use calendrical_calculations::islamic::{
 };
 use calendrical_calculations::iso;
 use icu::calendar::provider::islamic::*;
-use icu_provider::datagen::IterableDataProvider;
 use icu_provider::prelude::*;
 
 const YEARS: i32 = 250;
@@ -36,8 +35,10 @@ impl DataProvider<IslamicObservationalCacheV1Marker> for DatagenProvider {
     }
 }
 
-impl IterableDataProvider<IslamicObservationalCacheV1Marker> for DatagenProvider {
-    fn supported_requests(&self) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
+impl crate::IterableDataProviderCached<IslamicObservationalCacheV1Marker> for DatagenProvider {
+    fn iter_requests_cached(
+        &self,
+    ) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         Ok(HashSet::from_iter([Default::default()]))
     }
 }
@@ -56,8 +57,10 @@ impl DataProvider<IslamicUmmAlQuraCacheV1Marker> for crate::DatagenProvider {
     }
 }
 
-impl IterableDataProvider<IslamicUmmAlQuraCacheV1Marker> for DatagenProvider {
-    fn supported_requests(&self) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
+impl crate::IterableDataProviderCached<IslamicUmmAlQuraCacheV1Marker> for DatagenProvider {
+    fn iter_requests_cached(
+        &self,
+    ) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         Ok(HashSet::from_iter([Default::default()]))
     }
 }

provider/bikeshed/src/calendar/japanese.rs

@@ -6,7 +6,6 @@ use crate::cldr_serde;
 use crate::DatagenProvider;
 use icu::calendar::provider::*;
 use icu::locale::langid;
-use icu_provider::datagen::IterableDataProvider;
 use icu_provider::prelude::*;
 use std::collections::BTreeMap;
 use std::collections::HashSet;
@@ -179,14 +178,18 @@ fn era_to_code(original: &str, year: i32) -> Result<TinyStr16, String> {
     Ok(code)
 }
 
-impl IterableDataProvider<JapaneseErasV1Marker> for DatagenProvider {
-    fn supported_requests(&self) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
+impl crate::IterableDataProviderCached<JapaneseErasV1Marker> for DatagenProvider {
+    fn iter_requests_cached(
+        &self,
+    ) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         Ok(HashSet::from_iter([Default::default()]))
     }
 }
 
-impl IterableDataProvider<JapaneseExtendedErasV1Marker> for DatagenProvider {
-    fn supported_requests(&self) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
+impl crate::IterableDataProviderCached<JapaneseExtendedErasV1Marker> for DatagenProvider {
+    fn iter_requests_cached(
+        &self,
+    ) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         Ok(HashSet::from_iter([Default::default()]))
     }
 }

provider/bikeshed/src/characters/mod.rs

@@ -48,7 +48,7 @@ macro_rules! exemplar_chars_impls {
         }
 
         impl IterableDataProviderCached<$data_marker_name> for DatagenProvider {
-            fn supported_requests_cached(
+            fn iter_requests_cached(
                 &self,
             ) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
                 Ok(self

provider/bikeshed/src/collator/mod.rs

@@ -17,7 +17,6 @@ use icu::locale::subtags::Language;
 use icu::locale::subtags::Region;
 use icu::locale::subtags::Script;
 use icu::locale::LanguageIdentifier;
-use icu_provider::datagen::IterableDataProvider;
 use icu_provider::prelude::*;
 use std::collections::HashSet;
 use std::convert::TryFrom;
@@ -106,8 +105,10 @@ impl DataProvider<CollationFallbackSupplementV1Marker> for DatagenProvider {
     }
 }
 
-impl IterableDataProvider<CollationFallbackSupplementV1Marker> for DatagenProvider {
-    fn supported_requests(&self) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
+impl crate::IterableDataProviderCached<CollationFallbackSupplementV1Marker> for DatagenProvider {
+    fn iter_requests_cached(
+        &self,
+    ) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         Ok(HashSet::from_iter([Default::default()]))
     }
 }
@@ -205,7 +206,7 @@ macro_rules! collation_provider {
             }
 
             impl IterableDataProviderCached<$marker> for DatagenProvider {
-                fn supported_requests_cached(&self) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
+                fn iter_requests_cached(&self) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
                     Ok(self
                         .icuexport()?
                         .list(&format!(

provider/bikeshed/src/currency/essentials.rs

@@ -103,7 +103,7 @@ impl DataProvider<CurrencyEssentialsV1Marker> for DatagenProvider {
 }
 
 impl IterableDataProviderCached<CurrencyEssentialsV1Marker> for DatagenProvider {
-    fn supported_requests_cached(
+    fn iter_requests_cached(
         &self,
     ) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         Ok(self

provider/bikeshed/src/currency/extended.rs

@@ -10,7 +10,6 @@ use std::collections::BTreeMap;
 use std::collections::HashSet;
 
 use icu::experimental::dimension::provider::extended_currency::Count;
-use icu_provider::datagen::IterableDataProvider;
 use tinystr::TinyAsciiStr;
 
 use icu::experimental::dimension::provider::extended_currency::*;
@@ -80,8 +79,10 @@ impl DataProvider<CurrencyExtendedDataV1Marker> for crate::DatagenProvider {
     }
 }
 
-impl IterableDataProvider<CurrencyExtendedDataV1Marker> for DatagenProvider {
-    fn supported_requests(&self) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
+impl crate::IterableDataProviderCached<CurrencyExtendedDataV1Marker> for DatagenProvider {
+    fn iter_requests_cached(
+        &self,
+    ) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
         // TODO: This is a temporary implementation until we have a better way to handle large number of json files.
         let currencies_to_support: HashSet<_> =
             ["USD", "CAD", "EUR", "GBP", "EGP"].into_iter().collect();

provider/bikeshed/src/datetime/mod.rs

@@ -225,7 +225,7 @@ macro_rules! impl_data_provider {
         }
 
         impl IterableDataProviderCached<$marker> for DatagenProvider {
-            fn supported_requests_cached(
+            fn iter_requests_cached(
                 &self,
             ) -> Result<HashSet<(DataLocale, DataMarkerAttributes)>, DataError> {
                 let mut r = HashSet::new();