Make FFI DataProvider only support BufferProvider

components/datetime/src/error.rs

@@ -30,6 +30,12 @@ pub enum DateTimeFormatterLoadError {
     Data(DataError),
 }
 
+impl From<DataError> for DateTimeFormatterLoadError {
+    fn from(error: DataError) -> Self {
+        Self::Data(error)
+    }
+}
+
 /// An error from mixing calendar types in a formatter.
 #[derive(Display, Debug, Copy, Clone, PartialEq)]
 #[displaydoc("DateTimeFormatter for {this_kind} calendar was given a {date_kind:?} calendar")]

ffi/capi/src/bidi.rs

@@ -10,8 +10,8 @@ pub mod ffi {
     use alloc::vec::Vec;
     use core::fmt::Write;
 
-    use crate::errors::ffi::DataError;
-    use crate::provider::ffi::DataProvider;
+    #[cfg(feature = "buffer_provider")]
+    use crate::{errors::ffi::DataError, provider::ffi::DataProvider};
 
     pub enum BidiDirection {
         Ltr,
@@ -39,9 +39,9 @@ pub mod ffi {
         /// Creates a new [`Bidi`] from locale data, and a particular data source.
         #[diplomat::rust_link(icu::properties::bidi::BidiClassAdapter::new, FnInStruct)]
         #[diplomat::attr(supports = fallible_constructors, named_constructor = "with_provider")]
+        #[cfg(feature = "buffer_provider")]
         pub fn create_with_provider(provider: &DataProvider) -> Result<Box<Bidi>, DataError> {
             Ok(Box::new(Bidi(call_constructor_unstable!(
-                icu_properties::CodePointMapData::new [m => Ok(m.static_to_owned())],
                 icu_properties::CodePointMapData::try_new_unstable,
                 provider,
             )?)))

ffi/capi/src/calendar.rs

@@ -10,8 +10,10 @@ pub mod ffi {
     use alloc::sync::Arc;
     use core::fmt::Write;
 
+    #[cfg(any(feature = "compiled_data", feature = "buffer_provider"))]
     use crate::errors::ffi::DataError;
     use crate::locale_core::ffi::Locale;
+    #[cfg(feature = "buffer_provider")]
     use crate::provider::ffi::DataProvider;
 
     /// The various calendar types currently supported by [`Calendar`]
@@ -126,34 +128,33 @@ pub mod ffi {
         #[diplomat::rust_link(icu::calendar::AnyCalendar::try_new, FnInEnum)]
         #[diplomat::attr(supports = fallible_constructors, named_constructor = "for_locale_with_provider")]
         #[diplomat::demo(default_constructor)]
+        #[cfg(feature = "buffer_provider")]
         pub fn create_for_locale_with_provider(
             provider: &DataProvider,
             locale: &Locale,
         ) -> Result<Box<Calendar>, DataError> {
             let prefs = (&locale.0).into();
 
-            Ok(Box::new(Calendar(Arc::new(call_constructor!(
-                icu_calendar::AnyCalendar::try_new,
-                icu_calendar::AnyCalendar::try_new_with_any_provider,
-                icu_calendar::AnyCalendar::try_new_with_buffer_provider,
-                provider,
-                prefs
+            Ok(Box::new(Calendar(Arc::new(provider.call_constructor(
+                |provider| icu_calendar::AnyCalendar::try_new_with_buffer_provider(provider, prefs),
             )?))))
         }
 
         /// Creates a new [`Calendar`] from the specified date and time, using a particular data source.
         #[diplomat::rust_link(icu::calendar::AnyCalendar::new_for_kind, FnInEnum)]
         #[diplomat::attr(supports = fallible_constructors, named_constructor = "for_kind_with_provider")]
+        #[cfg(feature = "buffer_provider")]
         pub fn create_for_kind_with_provider(
             provider: &DataProvider,
             kind: AnyCalendarKind,
         ) -> Result<Box<Calendar>, DataError> {
-            Ok(Box::new(Calendar(Arc::new(call_constructor!(
-                icu_calendar::AnyCalendar::new_for_kind [r => Ok(r)],
-                icu_calendar::AnyCalendar::try_new_for_kind_with_any_provider,
-                icu_calendar::AnyCalendar::try_new_for_kind_with_buffer_provider,
-                provider,
-                kind.into()
+            Ok(Box::new(Calendar(Arc::new(provider.call_constructor(
+                |provider| {
+                    icu_calendar::AnyCalendar::try_new_for_kind_with_buffer_provider(
+                        provider,
+                        kind.into(),
+                    )
+                },
             )?))))
         }
 

ffi/capi/src/casemap.rs

@@ -10,7 +10,11 @@ use icu_casemap::titlecase::TitlecaseOptions;
 pub mod ffi {
     use alloc::boxed::Box;
 
-    use crate::{errors::ffi::DataError, locale_core::ffi::Locale, provider::ffi::DataProvider};
+    #[cfg(any(feature = "compiled_data", feature = "buffer_provider"))]
+    use crate::errors::ffi::DataError;
+    use crate::locale_core::ffi::Locale;
+    #[cfg(feature = "buffer_provider")]
+    use crate::provider::ffi::DataProvider;
     use diplomat_runtime::DiplomatOption;
 
     use writeable::Writeable;
@@ -65,12 +69,10 @@ pub mod ffi {
         /// Construct a new CaseMapper instance using a particular data source.
         #[diplomat::rust_link(icu::casemap::CaseMapper::new, FnInStruct)]
         #[diplomat::attr(supports = fallible_constructors, named_constructor = "with_provider")]
+        #[cfg(feature = "buffer_provider")]
         pub fn create_with_provider(provider: &DataProvider) -> Result<Box<CaseMapper>, DataError> {
-            Ok(Box::new(CaseMapper(call_constructor!(
-                icu_casemap::CaseMapper::new [r => Ok(r)],
-                icu_casemap::CaseMapper::try_new_with_any_provider,
+            Ok(Box::new(CaseMapper(provider.call_constructor(
                 icu_casemap::CaseMapper::try_new_with_buffer_provider,
-                provider,
             )?)))
         }
         /// Returns the full lowercase mapping of the given string
@@ -230,14 +232,12 @@ pub mod ffi {
         #[diplomat::rust_link(icu::casemap::CaseMapCloser::new, FnInStruct)]
         #[diplomat::rust_link(icu::casemap::CaseMapCloser::new_with_mapper, FnInStruct, hidden)]
         #[diplomat::attr(supports = fallible_constructors, named_constructor = "with_provider")]
+        #[cfg(feature = "buffer_provider")]
         pub fn create_with_provider(
             provider: &DataProvider,
         ) -> Result<Box<CaseMapCloser>, DataError> {
-            Ok(Box::new(CaseMapCloser(call_constructor!(
-                icu_casemap::CaseMapCloser::new [r => Ok(r)],
-                icu_casemap::CaseMapCloser::try_new_with_any_provider,
+            Ok(Box::new(CaseMapCloser(provider.call_constructor(
                 icu_casemap::CaseMapCloser::try_new_with_buffer_provider,
-                provider,
             )?)))
         }
         /// Adds all simple case mappings and the full case folding for `c` to `builder`.
@@ -289,14 +289,12 @@ pub mod ffi {
         #[diplomat::rust_link(icu::casemap::TitlecaseMapper::new, FnInStruct)]
         #[diplomat::rust_link(icu::casemap::TitlecaseMapper::new_with_mapper, FnInStruct, hidden)]
         #[diplomat::attr(supports = fallible_constructors, named_constructor = "with_provider")]
+        #[cfg(feature = "buffer_provider")]
         pub fn create_with_provider(
             provider: &DataProvider,
         ) -> Result<Box<TitlecaseMapper>, DataError> {
-            Ok(Box::new(TitlecaseMapper(call_constructor!(
-                icu_casemap::TitlecaseMapper::new [r => Ok(r)],
-                icu_casemap::TitlecaseMapper::try_new_with_any_provider,
+            Ok(Box::new(TitlecaseMapper(provider.call_constructor(
                 icu_casemap::TitlecaseMapper::try_new_with_buffer_provider,
-                provider,
             )?)))
         }
         /// Returns the full titlecase mapping of the given string

ffi/capi/src/collator.rs

@@ -8,7 +8,10 @@
 pub mod ffi {
     use alloc::boxed::Box;
 
-    use crate::{errors::ffi::DataError, locale_core::ffi::Locale, provider::ffi::DataProvider};
+    #[cfg(feature = "buffer_provider")]
+    use crate::provider::ffi::DataProvider;
+    #[cfg(any(feature = "compiled_data", feature = "buffer_provider"))]
+    use crate::{errors::ffi::DataError, locale_core::ffi::Locale};
     use diplomat_runtime::DiplomatOption;
 
     #[diplomat::opaque]
@@ -131,18 +134,21 @@ pub mod ffi {
         #[diplomat::rust_link(icu::collator::CollatorPreferences, Struct, hidden)]
         #[diplomat::attr(supports = fallible_constructors, constructor)]
         #[diplomat::attr(supports = non_exhaustive_structs, rename = "create_with_provider")]
+        #[cfg(feature = "buffer_provider")]
         pub fn create_v1_with_provider(
             provider: &DataProvider,
             locale: &Locale,
             options: CollatorOptionsV1,
         ) -> Result<Box<Collator>, DataError> {
-            Ok(Box::new(Collator(call_constructor!(
-                icu_collator::Collator::try_new [r => Ok(r?.static_to_owned())],
-                icu_collator::Collator::try_new_with_any_provider,
-                icu_collator::Collator::try_new_with_buffer_provider,
-                provider,
-                icu_collator::CollatorPreferences::from(&locale.0),
-                icu_collator::CollatorOptions::from(options),
+            let options = options.into();
+            Ok(Box::new(Collator(provider.call_constructor(
+                |provider| {
+                    icu_collator::Collator::try_new_with_buffer_provider(
+                        provider,
+                        (&locale.0).into(),
+                        options,
+                    )
+                },
             )?)))
         }
         /// Compare two strings.