Making IterableDataProvider #[no_std] (#5176)

By using `BTreeSet` instead of `HashSet`. This removes the `std` feature from `icu_provider_adapters`. Also removed `DataLocale::is_empty`, which is the same as `DataLocale::is_und`, but "und" is a better description of that state.
unicode-org · Jul 8, 2024 · c8a8801 · c8a8801
1 parent 81884c3
commit c8a8801
Show file tree

Hide file tree

Showing 623 changed files with 1,326 additions and 1,395 deletions.
diff --git a/components/experimental/src/transliterate/compile/mod.rs b/components/experimental/src/transliterate/compile/mod.rs
@@ -13,8 +13,6 @@ use icu_locale_core::Locale;
 use icu_normalizer::provider::*;
 use icu_properties::{provider::*, sets};
 use icu_provider::prelude::*;
-#[cfg(feature = "datagen")]
-use std::collections::HashSet;
 
 mod parse;
 mod pass1;
@@ -465,7 +463,7 @@ where
         + DataProvider<XidStartV1Marker>,
     NP: ?Sized,
 {
-    fn iter_ids(&self) -> Result<HashSet<DataIdentifierCow>, DataError> {
+    fn iter_ids(&self) -> Result<std::collections::BTreeSet<DataIdentifierCow>, DataError> {
         let exclusive_data = self.collection.data.borrow();
         Ok(exclusive_data
             .0

diff --git a/provider/adapters/Cargo.toml b/provider/adapters/Cargo.toml
@@ -31,5 +31,4 @@ icu_locale = { path = "../../components/locale" }
 writeable = { path = "../../utils/writeable" }
 
 [features]
-std = ["icu_locale/std", "icu_provider/std"]
 serde = ["dep:serde", "zerovec/serde", "icu_locale/serde", "icu_provider/serde"]
diff --git a/provider/adapters/src/either.rs b/provider/adapters/src/either.rs
@@ -4,6 +4,7 @@
 
 //! Helpers for switching between multiple providers.
 
+use alloc::collections::BTreeSet;
 use icu_provider::prelude::*;
 
 /// A provider that is one of two types determined at runtime.
@@ -90,7 +91,6 @@ impl<M: DataMarker, P0: DryDataProvider<M>, P1: DryDataProvider<M>> DryDataProvi
     }
 }
 
-#[cfg(feature = "std")]
 impl<
         M: DynamicDataMarker,
         P0: IterableDynamicDataProvider<M>,
@@ -101,7 +101,7 @@ impl<
     fn iter_ids_for_marker(
         &self,
         marker: DataMarkerInfo,
-    ) -> Result<std::collections::HashSet<DataIdentifierCow>, DataError> {
+    ) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
         use EitherProvider::*;
         match self {
             A(p) => p.iter_ids_for_marker(marker),
@@ -110,12 +110,11 @@ impl<
     }
 }
 
-#[cfg(feature = "std")]
 impl<M: DataMarker, P0: IterableDataProvider<M>, P1: IterableDataProvider<M>>
     IterableDataProvider<M> for EitherProvider<P0, P1>
 {
     #[inline]
-    fn iter_ids(&self) -> Result<std::collections::HashSet<DataIdentifierCow>, DataError> {
+    fn iter_ids(&self) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
         use EitherProvider::*;
         match self {
             A(p) => p.iter_ids(),

diff --git a/provider/adapters/src/empty.rs b/provider/adapters/src/empty.rs
@@ -6,6 +6,7 @@
 //!
 //! Use [`EmptyDataProvider`] as a stand-in for a provider that always fails.
 
+use alloc::collections::BTreeSet;
 use icu_provider::prelude::*;
 
 /// A data provider that always returns an error.
@@ -86,25 +87,23 @@ where
     }
 }
 
-#[cfg(feature = "std")]
 impl<M> IterableDataProvider<M> for EmptyDataProvider
 where
     M: DataMarker,
 {
-    fn iter_ids(&self) -> Result<std::collections::HashSet<DataIdentifierCow>, DataError> {
+    fn iter_ids(&self) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
         Ok(Default::default())
     }
 }
 
-#[cfg(feature = "std")]
 impl<M> IterableDynamicDataProvider<M> for EmptyDataProvider
 where
     M: DynamicDataMarker,
 {
     fn iter_ids_for_marker(
         &self,
         _: DataMarkerInfo,
-    ) -> Result<std::collections::HashSet<DataIdentifierCow>, DataError> {
+    ) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
         Ok(Default::default())
     }
 }
diff --git a/provider/adapters/src/filter/mod.rs b/provider/adapters/src/filter/mod.rs
@@ -22,6 +22,7 @@
 
 mod impls;
 
+use alloc::collections::BTreeSet;
 use icu_provider::prelude::*;
 
 /// A data provider that selectively filters out data requests.
@@ -130,7 +131,6 @@ where
     }
 }
 
-#[cfg(feature = "std")]
 impl<M, D, F> IterableDynamicDataProvider<M> for FilterDataProvider<D, F>
 where
     M: DynamicDataMarker,
@@ -140,7 +140,7 @@ where
     fn iter_ids_for_marker(
         &self,
         marker: DataMarkerInfo,
-    ) -> Result<std::collections::HashSet<DataIdentifierCow>, DataError> {
+    ) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
         self.inner.iter_ids_for_marker(marker).map(|set| {
             // Use filter_map instead of filter to avoid cloning the locale
             set.into_iter()
@@ -150,14 +150,13 @@ where
     }
 }
 
-#[cfg(feature = "std")]
 impl<M, D, F> IterableDataProvider<M> for FilterDataProvider<D, F>
 where
     M: DataMarker,
     F: Fn(DataIdentifierBorrowed) -> bool,
     D: IterableDataProvider<M>,
 {
-    fn iter_ids(&self) -> Result<std::collections::HashSet<DataIdentifierCow>, DataError> {
+    fn iter_ids(&self) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
         self.inner.iter_ids().map(|vec| {
             // Use filter_map instead of filter to avoid cloning the locale
             vec.into_iter()

diff --git a/provider/adapters/src/fork/by_error.rs b/provider/adapters/src/fork/by_error.rs
@@ -3,7 +3,7 @@
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
 use super::ForkByErrorPredicate;
-use alloc::vec::Vec;
+use alloc::{collections::BTreeSet, vec::Vec};
 use icu_provider::prelude::*;
 
 /// A provider that returns data from one of two child providers based on a predicate function.
@@ -138,7 +138,6 @@ where
     }
 }
 
-#[cfg(feature = "std")]
 impl<M, P0, P1, F> IterableDynamicDataProvider<M> for ForkByErrorProvider<P0, P1, F>
 where
     M: DynamicDataMarker,
@@ -149,7 +148,7 @@ where
     fn iter_ids_for_marker(
         &self,
         marker: DataMarkerInfo,
-    ) -> Result<std::collections::HashSet<DataIdentifierCow>, DataError> {
+    ) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
         let result = self.0.iter_ids_for_marker(marker);
         match result {
             Ok(ok) => return Ok(ok),
@@ -313,7 +312,6 @@ where
     }
 }
 
-#[cfg(feature = "std")]
 impl<M, P, F> IterableDynamicDataProvider<M> for MultiForkByErrorProvider<P, F>
 where
     M: DynamicDataMarker,
@@ -323,7 +321,7 @@ where
     fn iter_ids_for_marker(
         &self,
         marker: DataMarkerInfo,
-    ) -> Result<std::collections::HashSet<DataIdentifierCow>, DataError> {
+    ) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
         let mut last_error = F::UNIT_ERROR.with_marker(marker);
         for provider in self.providers.iter() {
             let result = provider.iter_ids_for_marker(marker);

diff --git a/provider/adapters/src/lib.rs b/provider/adapters/src/lib.rs
@@ -10,7 +10,7 @@
 //! - Use the [`fallback`] module to automatically resolve arbitrary locales for data loading.
 
 // https://github.com/unicode-org/icu4x/blob/main/documents/process/boilerplate.md#library-annotations
-#![cfg_attr(not(any(test, feature = "std")), no_std)]
+#![cfg_attr(not(test), no_std)]
 #![cfg_attr(
     not(test),
     deny(

diff --git a/provider/baked/src/export.rs b/provider/baked/src/export.rs
@@ -448,7 +448,7 @@ impl DataExporter for BakedExporter {
                     &self,
                     req: icu_provider::DataRequest,
                 ) -> Result<icu_provider::DataResponse<#marker_bake>, icu_provider::DataError> {
-                    if req.id.locale.is_empty() {
+                    if req.id.locale.is_und() {
                         Ok(icu_provider::DataResponse {
                             payload: icu_provider::DataPayload::from_static_ref(Self::#singleton_ident),
                             metadata: Default::default(),
@@ -461,8 +461,8 @@ impl DataExporter for BakedExporter {
         }, quote! {
             #maybe_msrv
             impl icu_provider::IterableDataProvider<#marker_bake> for $provider {
-                fn iter_ids(&self) -> Result<std::collections::HashSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
-                    Ok(HashSet::from_iter([Default::default()]))
+                fn iter_ids(&self) -> Result<std::collections::BtreeSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
+                    Ok([Default::default()].into_iter().collect())
                 }
             }
         })
@@ -498,7 +498,7 @@ impl DataExporter for BakedExporter {
                 quote! {
                     #maybe_msrv
                     impl icu_provider::IterableDataProvider<#marker_bake> for $provider {
-                        fn iter_ids(&self) -> Result<std::collections::HashSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
+                        fn iter_ids(&self) -> Result<std::collections::BTreeSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
                             Ok(Default::default())
                         }
                     }
@@ -603,7 +603,7 @@ impl DataExporter for BakedExporter {
                 quote! {
                     #maybe_msrv
                     impl icu_provider::IterableDataProvider<#marker_bake> for $provider {
-                        fn iter_ids(&self) -> Result<std::collections::HashSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
+                        fn iter_ids(&self) -> Result<std::collections::BTreeSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
                             Ok(icu_provider_baked::DataStore::iter(&Self::#data_ident).collect())
                         }
                     }

diff --git a/provider/baked/tests/data/hello_world_v1_marker.rs.data b/provider/baked/tests/data/hello_world_v1_marker.rs.data
@@ -31,7 +31,7 @@ macro_rules! __impl_hello_world_v1_marker {
         __impl_hello_world_v1_marker!($provider);
         #[clippy::msrv = "1.70"]
         impl icu_provider::IterableDataProvider<icu_provider::hello_world::HelloWorldV1Marker> for $provider {
-            fn iter_ids(&self) -> Result<std::collections::HashSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
+            fn iter_ids(&self) -> Result<std::collections::BTreeSet<icu_provider::DataIdentifierCow<'static>>, icu_provider::DataError> {
                 Ok(icu_provider_baked::DataStore::iter(&Self::DATA_HELLO_WORLD_V1_MARKER).collect())
             }
         }

diff --git a/provider/blob/Cargo.toml b/provider/blob/Cargo.toml
@@ -25,7 +25,7 @@ postcard = { workspace = true, features = ["alloc"] }
 serde = { workspace = true, features = ["alloc"] }
 writeable = {workspace = true }
 zerovec = { workspace = true, features = ["serde", "yoke"] }
-zerotrie = { workspace = true, features = ["serde", "zerovec"] }
+zerotrie = { workspace = true, features = ["serde", "zerovec", "alloc"] }
 
 log = { workspace = true, optional = true }
 
@@ -47,11 +47,7 @@ std = ["icu_provider/std"]
 export = [
     "icu_provider/export",
     "log",
-    "postcard/alloc",
     "std",
-    "zerovec/serde",
-    "zerotrie/alloc",
-    "zerotrie/litemap",
 ]
 
 [lib]

diff --git a/provider/blob/benches/auxkey_bench.rs b/provider/blob/benches/auxkey_bench.rs
@@ -11,6 +11,7 @@ use icu_provider::prelude::*;
 use icu_provider_adapters::fallback::LocaleFallbackProvider;
 use icu_provider_blob::export::BlobExporter;
 use icu_provider_blob::BlobDataProvider;
+use std::collections::BTreeSet;
 
 #[icu_provider::data_struct(
     marker(MarkerA, "a@1"),
@@ -35,7 +36,7 @@ macro_rules! implement {
             }
         }
         impl IterableDataProvider<$marker> for Baked {
-            fn iter_ids(&self) -> Result<std::collections::HashSet<DataIdentifierCow>, DataError> {
+            fn iter_ids(&self) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
                 const LOCALES: &[LanguageIdentifier] = &[
                     langid!("af"),
                     langid!("am"),

diff --git a/provider/blob/src/blob_data_provider.rs b/provider/blob/src/blob_data_provider.rs
@@ -4,6 +4,7 @@
 
 use crate::blob_schema::BlobSchema;
 use alloc::boxed::Box;
+use alloc::collections::BTreeSet;
 use icu_provider::buf::BufferFormat;
 use icu_provider::prelude::*;
 use icu_provider::Cart;
@@ -148,6 +149,15 @@ impl DynamicDryDataProvider<BufferMarker> for BlobDataProvider {
     }
 }
 
+impl IterableDynamicDataProvider<BufferMarker> for BlobDataProvider {
+    fn iter_ids_for_marker(
+        &self,
+        marker: DataMarkerInfo,
+    ) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
+        self.data.get().iter_ids(marker)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

diff --git a/provider/blob/src/blob_schema.rs b/provider/blob/src/blob_schema.rs
@@ -2,9 +2,9 @@
 // called LICENSE at the top level of the ICU4X source tree
 // (online at: https://github.com/unicode-org/icu4x/blob/main/LICENSE ).
 
-use core::fmt::Write;
-
 use alloc::boxed::Box;
+use alloc::collections::BTreeSet;
+use core::fmt::Write;
 use icu_provider::{marker::DataMarkerPathHash, prelude::*};
 use serde::Deserialize;
 use writeable::Writeable;
@@ -47,15 +47,14 @@ impl<'data> BlobSchema<'data> {
         }
     }
 
-    #[cfg(feature = "export")]
-    pub fn list_requests(
+    pub fn iter_ids(
         &self,
         marker: DataMarkerInfo,
-    ) -> Result<std::collections::HashSet<DataIdentifierCow>, DataError> {
+    ) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
         match self {
-            BlobSchema::V001(s) => s.list_requests(marker),
-            BlobSchema::V002(s) => s.list_requests(marker),
-            BlobSchema::V002Bigger(s) => s.list_requests(marker),
+            BlobSchema::V001(s) => s.iter_ids(marker),
+            BlobSchema::V002(s) => s.iter_ids(marker),
+            BlobSchema::V002Bigger(s) => s.iter_ids(marker),
         }
     }
 
@@ -100,7 +99,7 @@ impl<'data> BlobSchemaV1<'data> {
             .get0(&marker.path.hashed())
             .ok_or(DataErrorKind::MarkerNotFound)
             .and_then(|cursor| {
-                if marker.is_singleton && !req.id.locale.is_empty() {
+                if marker.is_singleton && !req.id.locale.is_und() {
                     return Err(DataErrorKind::InvalidRequest);
                 }
                 cursor
@@ -131,18 +130,19 @@ impl<'data> BlobSchemaV1<'data> {
             .ok_or_else(|| DataError::custom("Invalid blob bytes").with_req(marker, req))
     }
 
-    #[cfg(feature = "export")]
-    pub fn list_requests(
+    pub fn iter_ids(
         &self,
         marker: DataMarkerInfo,
-    ) -> Result<std::collections::HashSet<DataIdentifierCow>, DataError> {
+    ) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
         Ok(self
             .markers
             .get0(&marker.path.hashed())
             .ok_or_else(|| DataErrorKind::MarkerNotFound.with_marker(marker))?
             .iter1_copied()
-            .filter_map(|(s, _)| std::str::from_utf8(&s.0).ok())
+            .filter_map(|(s, _)| core::str::from_utf8(&s.0).ok())
             .filter_map(|s| {
+                #[allow(unused_imports)]
+                use alloc::borrow::ToOwned;
                 if let Some((locale, attrs)) = s.split_once(REQUEST_SEPARATOR) {
                     Some(DataIdentifierCow::from_owned(
                         DataMarkerAttributes::try_from_str(attrs).ok()?.to_owned(),
@@ -224,7 +224,7 @@ impl<'data, LocaleVecFormat: VarZeroVecFormat> BlobSchemaV2<'data, LocaleVecForm
             .binary_search(&marker.path.hashed())
             .ok()
             .ok_or_else(|| DataErrorKind::MarkerNotFound.with_req(marker, req))?;
-        if marker.is_singleton && !req.id.locale.is_empty() {
+        if marker.is_singleton && !req.id.locale.is_und() {
             return Err(DataErrorKind::InvalidRequest.with_req(marker, req));
         }
         let zerotrie = self
@@ -250,11 +250,10 @@ impl<'data, LocaleVecFormat: VarZeroVecFormat> BlobSchemaV2<'data, LocaleVecForm
         Ok(buffer)
     }
 
-    #[cfg(feature = "export")]
-    pub fn list_requests(
+    pub fn iter_ids(
         &self,
         marker: DataMarkerInfo,
-    ) -> Result<std::collections::HashSet<DataIdentifierCow>, DataError> {
+    ) -> Result<BTreeSet<DataIdentifierCow>, DataError> {
         let marker_index = self
             .markers
             .binary_search(&marker.path.hashed())
@@ -267,6 +266,8 @@ impl<'data, LocaleVecFormat: VarZeroVecFormat> BlobSchemaV2<'data, LocaleVecForm
         Ok(ZeroTrieSimpleAscii::from_store(zerotrie)
             .iter()
             .filter_map(|(s, _)| {
+                #[allow(unused_imports)]
+                use alloc::borrow::ToOwned;
                 if let Some((locale, attrs)) = s.split_once(REQUEST_SEPARATOR) {
                     Some(DataIdentifierCow::from_owned(
                         DataMarkerAttributes::try_from_str(attrs).ok()?.to_owned(),