Fixed up clippy warnrings/errors (#296)

Co-authored-by: Niall McDonagh <nmcdonagh@vectra.ai>

fluent-bundle/benches/resolver.rs

@@ -25,7 +25,7 @@ fn get_strings(tests: &[&'static str]) -> HashMap<&'static str, String> {
         let path = format!("./benches/{}.ftl", test);
         ftl_strings.insert(*test, read_file(&path).expect("Couldn't load file"));
     }
-    return ftl_strings;
+    ftl_strings
 }
 
 fn get_ids(res: &FluentResource) -> Vec<String> {
@@ -62,7 +62,7 @@ fn add_functions<R>(name: &'static str, bundle: &mut FluentBundle<R>) {
         "preferences" => {
             bundle
                 .add_function("PLATFORM", |_args, _named_args| {
-                    return "linux".into();
+                    "linux".into()
                 })
                 .expect("Failed to add a function to the bundle.");
         }
@@ -133,7 +133,7 @@ fn resolver_bench(c: &mut Criterion) {
                             bundle.write_pattern(&mut s, attr.value(), args.as_ref(), &mut errors);
                         s.clear();
                     }
-                    assert!(errors.len() == 0, "Resolver errors: {:#?}", errors);
+                    assert!(errors.is_empty(), "Resolver errors: {:#?}", errors);
                 }
             })
         });
@@ -156,7 +156,7 @@ fn resolver_bench(c: &mut Criterion) {
                     for attr in msg.attributes() {
                         let _ = bundle.format_pattern(attr.value(), args.as_ref(), &mut errors);
                     }
-                    assert!(errors.len() == 0, "Resolver errors: {:#?}", errors);
+                    assert!(errors.is_empty(), "Resolver errors: {:#?}", errors);
                 }
             })
         });

fluent-bundle/benches/resolver_iai.rs

@@ -9,7 +9,7 @@ fn add_functions<R>(name: &'static str, bundle: &mut FluentBundle<R>) {
         "preferences" => {
             bundle
                 .add_function("PLATFORM", |_args, _named_args| {
-                    return "linux".into();
+                    "linux".into()
                 })
                 .expect("Failed to add a function to the bundle.");
         }
@@ -71,7 +71,7 @@ fn iai_resolve_preferences() {
                     .expect("Failed to write a pattern.");
                 s.clear();
             }
-            assert!(errors.len() == 0, "Resolver errors: {:#?}", errors);
+            assert!(errors.is_empty(), "Resolver errors: {:#?}", errors);
         }
     }
 }

fluent-bundle/examples/custom_formatter.rs

@@ -10,7 +10,7 @@ use fluent_bundle::{FluentArgs, FluentBundle, FluentResource, FluentValue};
 
 fn custom_formatter<M: MemoizerKind>(num: &FluentValue, _intls: &M) -> Option<String> {
     match num {
-        FluentValue::Number(n) => Some(format!("CUSTOM({})", n.value).into()),
+        FluentValue::Number(n) => Some(format!("CUSTOM({})", n.value)),
         _ => None,
     }
 }
@@ -59,7 +59,7 @@ key-var-with-arg = Here is a variable formatted with an argument { NUMBER($num,
         .get_message("key-implicit")
         .expect("Message doesn't exist.");
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, None, &mut errors);
+    let value = bundle.format_pattern(pattern, None, &mut errors);
     assert_eq!(value, "Here is an implicitly encoded number: 5.");
     println!("{}", value);
 
@@ -72,7 +72,7 @@ key-var-with-arg = Here is a variable formatted with an argument { NUMBER($num,
         .get_message("key-implicit")
         .expect("Message doesn't exist.");
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, None, &mut errors);
+    let value = bundle.format_pattern(pattern, None, &mut errors);
     assert_eq!(value, "Here is an implicitly encoded number: CUSTOM(5).");
     println!("{}", value);
 
@@ -82,7 +82,7 @@ key-var-with-arg = Here is a variable formatted with an argument { NUMBER($num,
         .get_message("key-explicit")
         .expect("Message doesn't exist.");
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, None, &mut errors);
+    let value = bundle.format_pattern(pattern, None, &mut errors);
     assert_eq!(value, "Here is an explicitly encoded number: CUSTOM(5).");
     println!("{}", value);
 
@@ -92,7 +92,7 @@ key-var-with-arg = Here is a variable formatted with an argument { NUMBER($num,
     let pattern = msg.value().expect("Message has no value.");
     let mut args = FluentArgs::new();
     args.set("num", FluentValue::from(-15));
-    let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
+    let value = bundle.format_pattern(pattern, Some(&args), &mut errors);
     assert_eq!(
         value,
         "Here is an implicitly encoded variable: CUSTOM(-15)."
@@ -105,7 +105,7 @@ key-var-with-arg = Here is a variable formatted with an argument { NUMBER($num,
     let pattern = msg.value().expect("Message has no value.");
     let mut args = FluentArgs::new();
     args.set("num", FluentValue::from(-15));
-    let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
+    let value = bundle.format_pattern(pattern, Some(&args), &mut errors);
     assert_eq!(
         value,
         "Here is an explicitly encoded variable: CUSTOM(-15)."
@@ -129,7 +129,7 @@ key-var-with-arg = Here is a variable formatted with an argument { NUMBER($num,
         },
     );
     args.set("num", num);
-    let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
+    let value = bundle.format_pattern(pattern, Some(&args), &mut errors);
 
     // Notice, that since we specificed minimum and maximum fraction digits options
     // to be 1 and 8 when construction the argument, and then the minimum fraction

fluent-bundle/examples/external_arguments.rs

@@ -28,13 +28,13 @@ unread-emails =
         .expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
+    let value = bundle.format_pattern(pattern, Some(&args), &mut errors);
     println!("{}", value);
 
     let msg = bundle.get_message("ref").expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
+    let value = bundle.format_pattern(pattern, Some(&args), &mut errors);
     println!("{}", value);
 
     let mut args = FluentArgs::new();
@@ -45,6 +45,6 @@ unread-emails =
         .expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
+    let value = bundle.format_pattern(pattern, Some(&args), &mut errors);
     println!("{}", value);
 }

fluent-bundle/examples/functions.rs

@@ -17,7 +17,7 @@ fn main() {
     // Test for a simple function that returns a string
     bundle
         .add_function("HELLO", |_args, _named_args| {
-            return "I'm a function!".into();
+            "I'm a function!".into()
         })
         .expect("Failed to add a function to the bundle.");
 
@@ -61,22 +61,22 @@ fn main() {
         .expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, None, &mut errors);
+    let value = bundle.format_pattern(pattern, None, &mut errors);
     assert_eq!(&value, "Hey there! \u{2068}I'm a function!\u{2069}");
 
     let msg = bundle
         .get_message("meaning-of-life")
         .expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, None, &mut errors);
+    let value = bundle.format_pattern(pattern, None, &mut errors);
     assert_eq!(&value, "The answer to life, the universe, and everything");
 
     let msg = bundle
         .get_message("all-your-base")
         .expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, None, &mut errors);
+    let value = bundle.format_pattern(pattern, None, &mut errors);
     assert_eq!(&value, "All your base belong to us");
 }

fluent-bundle/examples/hello.rs

@@ -13,6 +13,6 @@ fn main() {
         .expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, None, &mut errors);
+    let value = bundle.format_pattern(pattern, None, &mut errors);
     assert_eq!(&value, "Hello, world!");
 }

fluent-bundle/examples/message_reference.rs

@@ -20,14 +20,14 @@ bazbar = { baz } Bar
         .expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, None, &mut errors);
+    let value = bundle.format_pattern(pattern, None, &mut errors);
     println!("{}", value);
 
     let msg = bundle
         .get_message("bazbar")
         .expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, None, &mut errors);
+    let value = bundle.format_pattern(pattern, None, &mut errors);
     println!("{}", value);
 }

fluent-bundle/examples/selector.rs

@@ -25,7 +25,7 @@ hello-world2 = Hello { $name ->
         .expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, None, &mut errors);
+    let value = bundle.format_pattern(pattern, None, &mut errors);
     println!("{}", value);
 
     let mut args = FluentArgs::new();
@@ -36,6 +36,6 @@ hello-world2 = Hello { $name ->
         .expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
+    let value = bundle.format_pattern(pattern, Some(&args), &mut errors);
     println!("{}", value);
 }

fluent-bundle/examples/simple-app.rs

@@ -69,7 +69,7 @@ fn get_available_locales() -> Result<Vec<LanguageIdentifier>, io::Error> {
             }
         }
     }
-    return Ok(locales);
+    Ok(locales)
 }
 
 static L10N_RESOURCES: &[&str] = &["simple.ftl"];
@@ -82,7 +82,7 @@ fn main() {
     //    take the second argument as a comma-separated
     //    list of requested locales.
     let requested = args.get(2).map_or(vec![], |arg| {
-        arg.split(",")
+        arg.split(',')
             .map(|s| -> LanguageIdentifier { s.parse().expect("Parsing locale failed.") })
             .collect()
     });
@@ -126,7 +126,7 @@ fn main() {
     match args.get(1) {
         Some(input) => {
             // 7.1. Cast it to a number.
-            match isize::from_str(&input) {
+            match isize::from_str(input) {
                 Ok(i) => {
                     // 7.2. Construct a map of arguments
                     //      to format the message.
@@ -139,7 +139,7 @@ fn main() {
                         .get_message("response-msg")
                         .expect("Message doesn't exist.");
                     let pattern = msg.value().expect("Message has no value.");
-                    let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
+                    let value = bundle.format_pattern(pattern, Some(&args), &mut errors);
                     println!("{}", value);
                 }
                 Err(err) => {
@@ -151,7 +151,7 @@ fn main() {
                         .get_message("input-parse-error")
                         .expect("Message doesn't exist.");
                     let pattern = msg.value().expect("Message has no value.");
-                    let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
+                    let value = bundle.format_pattern(pattern, Some(&args), &mut errors);
                     println!("{}", value);
                 }
             }
@@ -162,7 +162,7 @@ fn main() {
                 .get_message("missing-arg-error")
                 .expect("Message doesn't exist.");
             let pattern = msg.value().expect("Message has no value.");
-            let value = bundle.format_pattern(&pattern, None, &mut errors);
+            let value = bundle.format_pattern(pattern, None, &mut errors);
             println!("{}", value);
         }
     }

fluent-bundle/src/entry.rs

@@ -35,7 +35,7 @@ pub trait GetEntry {
     fn get_entry_function(&self, id: &str) -> Option<&FluentFunction>;
 }
 
-impl<'bundle, R: Borrow<FluentResource>, M> GetEntry for FluentBundle<R, M> {
+impl<R: Borrow<FluentResource>, M> GetEntry for FluentBundle<R, M> {
     fn get_entry_message(&self, id: &str) -> Option<&ast::Message<&str>> {
         self.entries.get(id).and_then(|ref entry| match entry {
             Entry::Message((resource_idx, entry_idx)) => {

fluent-bundle/src/errors.rs

@@ -2,7 +2,7 @@ use crate::resolver::ResolverError;
 use fluent_syntax::parser::ParserError;
 use std::error::Error;
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum EntryKind {
     Message,
     Term,
@@ -23,7 +23,7 @@ impl std::fmt::Display for EntryKind {
 ///
 /// It contains three main types of errors that may come up
 /// during runtime use of the fluent-bundle crate.
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum FluentError {
     /// An error which occurs when
     /// [`FluentBundle::add_resource`](crate::bundle::FluentBundle::add_resource)

fluent-bundle/src/resolver/errors.rs

@@ -4,7 +4,7 @@ use std::error::Error;
 /// Maps an [`InlineExpression`] into the kind of reference, with owned strings
 /// that identify the expression. This makes it so that the [`InlineExpression`] can
 /// be used to generate an error string.
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum ReferenceKind {
     Function {
         id: String,
@@ -49,7 +49,7 @@ where
 
 /// Errors generated during the process of resolving a fluent message into a string.
 /// This process takes place in the `write` method of the `WriteValue` trait.
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub enum ResolverError {
     Reference(ReferenceKind),
     NoValue(String),

fluent-bundle/tests/function.rs

@@ -63,7 +63,7 @@ liked-count2 = { NUMBER($num) ->
 
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
+    let value = bundle.format_pattern(pattern, Some(&args), &mut errors);
     assert_eq!("\u{2068}1\u{2069} people liked your message", &value);
 
     // 3. Example with passing number, but without NUMBER call
@@ -75,7 +75,7 @@ liked-count2 = { NUMBER($num) ->
         .expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
+    let value = bundle.format_pattern(pattern, Some(&args), &mut errors);
     assert_eq!("One person liked your message", &value);
 
     // 4. Example with NUMBER call
@@ -87,7 +87,7 @@ liked-count2 = { NUMBER($num) ->
         .expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
+    let value = bundle.format_pattern(pattern, Some(&args), &mut errors);
     assert_eq!("One person liked your message", &value);
 
     // 5. Example with NUMBER call from number
@@ -99,6 +99,6 @@ liked-count2 = { NUMBER($num) ->
         .expect("Message doesn't exist.");
     let mut errors = vec![];
     let pattern = msg.value().expect("Message has no value.");
-    let value = bundle.format_pattern(&pattern, Some(&args), &mut errors);
+    let value = bundle.format_pattern(pattern, Some(&args), &mut errors);
     assert_eq!("One person liked your message", &value);
 }

fluent-bundle/tests/helpers/mod.rs

@@ -88,7 +88,7 @@ pub fn get_defaults(path: &str) -> Result<TestDefaults, io::Error> {
     Ok(serde_yaml::from_str(&s).expect("Parsing YAML failed."))
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
 #[serde(deny_unknown_fields)]
 pub struct TestBundle {
     pub name: Option<String>,
@@ -102,7 +102,7 @@ pub struct TestBundle {
     pub errors: Vec<TestError>,
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
 #[serde(deny_unknown_fields)]
 pub struct TestResource {
     pub name: Option<String>,
@@ -120,7 +120,7 @@ pub struct TestSetup {
     pub resources: Vec<TestResource>,
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
 #[serde(deny_unknown_fields)]
 pub struct TestError {
     #[serde(rename = "type")]
@@ -186,7 +186,7 @@ pub struct TestFixture {
     pub suites: Vec<TestSuite>,
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
 #[serde(deny_unknown_fields)]
 pub struct BundleDefaults {
     #[serde(rename = "useIsolating")]
@@ -195,7 +195,7 @@ pub struct BundleDefaults {
     pub locales: Option<Vec<String>>,
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize, Clone)]
+#[derive(Debug, PartialEq, Eq, Serialize, Deserialize, Clone)]
 #[serde(deny_unknown_fields)]
 pub struct TestDefaults {
     pub bundle: BundleDefaults,