Remove lifetime from FluentBundle

Author: zbraniecki

fluent-bundle/src/bundle.rs

@@ -84,15 +84,15 @@ pub struct Message<'m> {
 /// [`compound`]: ./struct.FluentBundle.html#method.compound
 /// [`add_resource`]: ./struct.FluentBundle.html#method.add_resource
 /// [`Option<T>`]: http://doc.rust-lang.org/std/option/enum.Option.html
-pub struct FluentBundle<'bundle, R> {
+pub struct FluentBundle<R> {
     pub locales: Vec<String>,
     pub(crate) resources: Vec<R>,
-    pub(crate) entries: HashMap<String, Entry<'bundle>>,
+    pub(crate) entries: HashMap<String, Entry>,
     pub(crate) plural_rules: IntlPluralRules,
     pub(crate) use_isolating: bool,
 }
 
-impl<'bundle, R> FluentBundle<'bundle, R> {
+impl<R> FluentBundle<R> {
     /// Constructs a FluentBundle. `locales` is the fallback chain of locales
     /// to use for formatters like date and time. `locales` does not influence
     /// message selection.
@@ -277,7 +277,7 @@ impl<'bundle, R> FluentBundle<'bundle, R> {
     /// ```
     ///
     /// [FTL syntax guide]: https://projectfluent.org/fluent/guide/functions.html
-    pub fn add_function<F: 'bundle>(&mut self, id: &str, func: F) -> Result<(), FluentError>
+    pub fn add_function<F: 'static>(&mut self, id: &str, func: F) -> Result<(), FluentError>
     where
         F: for<'a> Fn(&[FluentValue<'a>], &HashMap<&str, FluentValue<'a>>) -> FluentValue<'a>
             + Sync
@@ -372,7 +372,7 @@ impl<'bundle, R> FluentBundle<'bundle, R> {
     ///     .expect("Failed to format a message.");
     /// assert_eq!(&value, "a foo b");
     /// ```
-    pub fn format(
+    pub fn format<'bundle>(
         &'bundle self,
         path: &str,
         args: Option<&'bundle HashMap<&str, FluentValue>>,
@@ -452,7 +452,7 @@ impl<'bundle, R> FluentBundle<'bundle, R> {
     /// The second term of the tuple will contain any extra error information
     /// gathered during formatting. A caller may safely ignore the extra errors
     /// if the fallback formatting policies are acceptable.
-    pub fn compound(
+    pub fn compound<'bundle>(
         &'bundle self,
         message_id: &str,
         args: Option<&'bundle HashMap<&str, FluentValue>>,

fluent-bundle/src/entry.rs

@@ -9,17 +9,16 @@ use crate::bundle::FluentBundle;
 use crate::resource::FluentResource;
 use crate::types::FluentValue;
 
-pub type FluentFunction<'bundle> = Box<
-    dyn 'bundle
-        + for<'a> Fn(&[FluentValue<'a>], &HashMap<&str, FluentValue<'a>>) -> FluentValue<'a>
+pub type FluentFunction = Box<
+    dyn for<'a> Fn(&[FluentValue<'a>], &HashMap<&str, FluentValue<'a>>) -> FluentValue<'a>
         + Send
         + Sync,
 >;
 
-pub enum Entry<'bundle> {
+pub enum Entry {
     Message([usize; 2]),
     Term([usize; 2]),
-    Function(FluentFunction<'bundle>),
+    Function(FluentFunction),
 }
 
 pub trait GetEntry {
@@ -28,7 +27,7 @@ pub trait GetEntry {
     fn get_function(&self, id: &str) -> Option<&FluentFunction>;
 }
 
-impl<'bundle, R: Borrow<FluentResource>> GetEntry for FluentBundle<'_, R> {
+impl<'bundle, R: Borrow<FluentResource>> GetEntry for FluentBundle<R> {
     fn get_message(&self, id: &str) -> Option<&ast::Message> {
         self.entries.get(id).and_then(|entry| match *entry {
             Entry::Message(pos) => {

fluent-bundle/src/resolve.rs

@@ -34,7 +34,7 @@ pub enum ResolverError {
 /// State for a single `ResolveValue::to_value` call.
 pub struct Scope<'bundle, R: Borrow<FluentResource>> {
     /// The current `FluentBundle` instance.
-    pub bundle: &'bundle FluentBundle<'bundle, R>,
+    pub bundle: &'bundle FluentBundle<R>,
     /// The current arguments passed by the developer.
     pub args: Option<&'bundle HashMap<&'bundle str, FluentValue<'bundle>>>,
     /// Local args

fluent-fallback/src/lib.rs

@@ -8,11 +8,11 @@ use fluent_bundle::FluentValue;
 use reiterate::Reiterate;
 
 struct FluentBundleIterator<'loc, R> {
-    iter: Box<dyn Iterator<Item = FluentBundle<'loc, R>> + 'loc>,
+    iter: Box<dyn Iterator<Item = FluentBundle<R>> + 'loc>,
 }
 
 impl<'loc, R> Iterator for FluentBundleIterator<'loc, R> {
-    type Item = Box<FluentBundle<'loc, R>>;
+    type Item = Box<FluentBundle<R>>;
     fn next(&mut self) -> Option<Self::Item> {
         self.iter.next().map(Box::new)
     }
@@ -28,7 +28,7 @@ impl<'loc, R> Localization<'loc, R> {
     pub fn new<F, I>(resource_ids: Vec<String>, mut generate_bundles: F) -> Self
     where
         F: FnMut(&[String]) -> I + 'loc,
-        I: Iterator<Item = FluentBundle<'loc, R>> + 'loc,
+        I: Iterator<Item = FluentBundle<R>> + 'loc,
     {
         let mut generate2 = move |x: &[String]| FluentBundleIterator {
             iter: Box::new(generate_bundles(x)),

fluent-resmgr/src/resource_manager.rs

@@ -55,7 +55,7 @@ impl ResourceManager {
         &'l self,
         locales: Vec<String>,
         resource_ids: Vec<String>,
-    ) -> impl Iterator<Item = FluentBundle<'l, &FluentResource>> {
+    ) -> impl Iterator<Item = FluentBundle<&FluentResource>> {
         let res_mgr = self;
         let mut ptr = 0;