Separate sync feature

Author: zbraniecki

fluent-bundle/Cargo.toml

@@ -45,8 +45,8 @@ rand = "0.8"
 serde_yaml = "0.8"
 
 [features]
-default = ["icu_provider/sync"]
-sync = ["icu_provider/sync"]
+default = []
+sync = ["intl-memoizer/sync", "icu_provider/sync"]
 all-benchmarks = []
 
 [[bench]]

fluent-bundle/examples/custom_type.rs

@@ -112,6 +112,8 @@ impl FluentType for DateTime {
             })
             .expect("Failed to format a date.")
     }
+
+    #[cfg(feature = "sync")]
     fn as_string_threadsafe(
         &self,
         _: &intl_memoizer::concurrent::IntlLangMemoizer,

fluent-bundle/src/bundle.rs

@@ -598,6 +598,7 @@ impl crate::memoizer::MemoizerKind for IntlLangMemoizer {
         Self::new(lang)
     }
 
+    #[cfg(feature = "sync")]
     fn with_try_get_threadsafe<I, R, U>(&self, args: I::Args, cb: U) -> Result<R, I::Error>
     where
         Self: Sized,
@@ -608,6 +609,17 @@ impl crate::memoizer::MemoizerKind for IntlLangMemoizer {
         self.with_try_get(args, cb)
     }
 
+    #[cfg(not(feature = "sync"))]
+    fn with_try_get<I, R, U>(&self, args: I::Args, cb: U) -> Result<R, I::Error>
+    where
+        Self: Sized,
+        I: intl_memoizer::Memoizable + 'static,
+        I::Args: 'static,
+        U: FnOnce(&I) -> R,
+    {
+        self.with_try_get(args, cb)
+    }
+
     fn stringify_value(
         &self,
         value: &dyn crate::types::FluentType,

fluent-bundle/src/concurrent.rs

@@ -1,5 +1,9 @@
 use icu_locid::LanguageIdentifier;
-use intl_memoizer::{concurrent::IntlLangMemoizer, Memoizable};
+#[cfg(feature = "sync")]
+use intl_memoizer::concurrent::IntlLangMemoizer;
+#[cfg(not(feature = "sync"))]
+use intl_memoizer::IntlLangMemoizer;
+use intl_memoizer::Memoizable;
 use rustc_hash::FxHashMap;
 
 use crate::memoizer::MemoizerKind;
@@ -51,14 +55,26 @@ impl MemoizerKind for IntlLangMemoizer {
         Self::new(lang)
     }
 
+    #[cfg(feature = "sync")]
     fn with_try_get_threadsafe<I, R, U>(&self, args: I::Args, cb: U) -> Result<R, I::Error>
     where
         Self: Sized,
         I: Memoizable + Send + Sync + 'static,
         I::Args: Send + Sync + 'static,
         U: FnOnce(&I) -> R,
     {
-        self.with_try_get(args, cb)
+        Self::with_try_get(self, args, cb)
+    }
+
+    #[cfg(not(feature = "sync"))]
+    fn with_try_get<I, R, U>(&self, args: I::Args, cb: U) -> Result<R, I::Error>
+    where
+        Self: Sized,
+        I: Memoizable + 'static,
+        I::Args: 'static,
+        U: FnOnce(&I) -> R,
+    {
+        Self::with_try_get(self, args, cb)
     }
 
     fn stringify_value(&self, value: &dyn FluentType) -> std::borrow::Cow<'static, str> {

fluent-bundle/src/lib.rs

@@ -100,6 +100,7 @@
 //! matures and higher level APIs are being developed.
 mod args;
 pub mod bundle;
+#[cfg(feature = "sync")]
 pub mod concurrent;
 mod entry;
 mod errors;

fluent-bundle/src/memoizer.rs

@@ -18,13 +18,22 @@ pub trait MemoizerKind: 'static {
     ///
     /// `U` - The callback that accepts the instance of the intl formatter, and generates
     ///       some kind of results `R`.
+    #[cfg(feature = "sync")]
     fn with_try_get_threadsafe<I, R, U>(&self, args: I::Args, callback: U) -> Result<R, I::Error>
     where
         Self: Sized,
         I: Memoizable + Send + Sync + 'static,
         I::Args: Send + Sync + 'static,
         U: FnOnce(&I) -> R;
 
+    #[cfg(not(feature = "sync"))]
+    fn with_try_get<I, R, U>(&self, args: I::Args, callback: U) -> Result<R, I::Error>
+    where
+        Self: Sized,
+        I: Memoizable + 'static,
+        I::Args: 'static,
+        U: FnOnce(&I) -> R;
+
     /// Wires up the `as_string` or `as_string_threadsafe` variants for [`FluentType`].
     fn stringify_value(&self, value: &dyn FluentType) -> std::borrow::Cow<'static, str>;
 }

fluent-bundle/src/types/mod.rs

@@ -41,6 +41,7 @@ pub trait FluentType: fmt::Debug + AnyEq + 'static {
     /// Convert the custom type into a string value, for instance a custom DateTime
     /// type could return "Oct. 27, 2022". This operation is provided the threadsafe
     /// [IntlLangMemoizer](intl_memoizer::concurrent::IntlLangMemoizer).
+    #[cfg(feature = "sync")]
     fn as_string_threadsafe(
         &self,
         intls: &intl_memoizer::concurrent::IntlLangMemoizer,
@@ -199,14 +200,25 @@ impl<'source> FluentValue<'source> {
                 };
                 // This string matches a plural rule keyword. Check if the number
                 // matches the plural rule category.
-                scope
+                #[cfg(feature = "sync")]
+                let result = scope
                     .bundle
                     .intls
                     .with_try_get_threadsafe::<PluralRules, _, _>(
                         (PluralRuleType::Cardinal,),
                         |pr| pr.0.category_for(b) == cat,
                     )
-                    .unwrap()
+                    .unwrap();
+
+                #[cfg(not(feature = "sync"))]
+                let result = scope
+                    .bundle
+                    .intls
+                    .with_try_get::<PluralRules, _, _>((PluralRuleType::Cardinal,), |pr| {
+                        pr.0.category_for(b) == cat
+                    })
+                    .unwrap();
+                result
             }
             _ => false,
         }

fluent-bundle/tests/custom_types.rs

@@ -26,6 +26,8 @@ fn fluent_custom_type() {
         fn as_string(&self, _: &intl_memoizer::IntlLangMemoizer) -> std::borrow::Cow<'static, str> {
             format!("{}", self.epoch).into()
         }
+
+        #[cfg(feature = "sync")]
         fn as_string_threadsafe(
             &self,
             _: &intl_memoizer::concurrent::IntlLangMemoizer,
@@ -123,6 +125,8 @@ fn fluent_date_time_builtin() {
         fn as_string(&self, _: &intl_memoizer::IntlLangMemoizer) -> std::borrow::Cow<'static, str> {
             format!("2020-01-20 {}:00", self.epoch).into()
         }
+
+        #[cfg(feature = "sync")]
         fn as_string_threadsafe(
             &self,
             _intls: &intl_memoizer::concurrent::IntlLangMemoizer,

intl-memoizer/src/lib.rs

@@ -11,6 +11,7 @@ use std::collections::HashMap;
 use std::hash::Hash;
 use std::rc::{Rc, Weak};
 
+#[cfg(feature = "sync")]
 pub mod concurrent;
 
 /// The trait that needs to be implemented for each intl formatter that needs to be