Merge pull request mozilla#1084 from bendk/clippy-and-test-fixes

Clippy and test fixes

fixtures/uitests/tests/ui/interface_not_sync_and_send.stderr

@@ -8,8 +8,12 @@ error[E0277]: `Cell<u32>` cannot be shared between threads safely
     | required by this bound in `assert_impl_all`
     |
     = help: within `Counter`, the trait `Sync` is not implemented for `Cell<u32>`
-    = note: required because it appears within the type `Counter`
-    = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+note: required because it appears within the type `Counter`
+   --> $DIR/interface_not_sync_and_send.rs:9:12
+    |
+9   | pub struct Counter {
+    |            ^^^^^^^
+    = note: this error originates in the macro `uniffi::deps::static_assertions::assert_impl_all` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0277]: the trait bound `Arc<Counter>: FfiConverter` is not satisfied
    --> $DIR/counter.uniffi.rs:145:9

uniffi/tests/ui/version_mismatch.stderr

@@ -4,4 +4,4 @@ error[E0080]: evaluation of constant value failed
 2 | uniffi::assert_compatible_version!("0.0.1"); // An error message would go here.
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ attempt to compute `0_usize - 1_usize`, which would overflow
   |
-  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
+  = note: this error originates in the macro `uniffi::deps::static_assertions::const_assert` (in Nightly builds, run with -Z macro-backtrace for more info)

uniffi_bindgen/src/bindings/kotlin/gen_kotlin/primitives.rs

@@ -31,22 +31,22 @@ fn render_literal(_oracle: &dyn CodeOracle, literal: &Literal) -> String {
         Literal::Boolean(v) => format!("{}", v),
         Literal::String(s) => format!("\"{}\"", s),
         Literal::Int(i, radix, type_) => typed_number(
-            &type_,
+            type_,
             match radix {
                 Radix::Octal => format!("{:#x}", i),
                 Radix::Decimal => format!("{}", i),
                 Radix::Hexadecimal => format!("{:#x}", i),
             },
         ),
         Literal::UInt(i, radix, type_) => typed_number(
-            &type_,
+            type_,
             match radix {
                 Radix::Octal => format!("{:#x}", i),
                 Radix::Decimal => format!("{}", i),
                 Radix::Hexadecimal => format!("{:#x}", i),
             },
         ),
-        Literal::Float(string, type_) => typed_number(&type_, string.clone()),
+        Literal::Float(string, type_) => typed_number(type_, string.clone()),
 
         _ => unreachable!("Literal"),
     }

uniffi_bindgen/src/interface/mod.rs

@@ -660,19 +660,13 @@ impl<'a> RecursiveTypeIterator<'a> {
             // to a non-existent type, we just leave the existing iterator in place and allow the recursive
             // call to `next()` to try again with the next pending type.
             let next_iter = match next_type {
-                Type::Record(nm) => self
-                    .ci
-                    .get_record_definition(&nm)
-                    .map(IterTypes::iter_types),
-                Type::Enum(nm) => self.ci.get_enum_definition(&nm).map(IterTypes::iter_types),
-                Type::Error(nm) => self.ci.get_error_definition(&nm).map(IterTypes::iter_types),
-                Type::Object(nm) => self
-                    .ci
-                    .get_object_definition(&nm)
-                    .map(IterTypes::iter_types),
+                Type::Record(nm) => self.ci.get_record_definition(nm).map(IterTypes::iter_types),
+                Type::Enum(nm) => self.ci.get_enum_definition(nm).map(IterTypes::iter_types),
+                Type::Error(nm) => self.ci.get_error_definition(nm).map(IterTypes::iter_types),
+                Type::Object(nm) => self.ci.get_object_definition(nm).map(IterTypes::iter_types),
                 Type::CallbackInterface(nm) => self
                     .ci
-                    .get_callback_interface_definition(&nm)
+                    .get_callback_interface_definition(nm)
                     .map(IterTypes::iter_types),
                 _ => None,
             };
@@ -922,14 +916,14 @@ mod test {
         };
 
         // check that `contains_optional_types` returns false when there is no Optional type in the interface
-        assert_eq!(ci.contains_optional_types(), false);
+        assert!(!ci.contains_optional_types());
 
         // check that `contains_optional_types` returns true when there is an Optional type in the interface
         assert!(ci
             .types
             .add_type_definition("TestOptional{}", Type::Optional(Box::new(Type::String)))
             .is_ok());
-        assert_eq!(ci.contains_optional_types(), true);
+        assert!(ci.contains_optional_types());
     }
 
     #[test]
@@ -939,14 +933,14 @@ mod test {
         };
 
         // check that `contains_sequence_types` returns false when there is no Sequence type in the interface
-        assert_eq!(ci.contains_sequence_types(), false);
+        assert!(!ci.contains_sequence_types());
 
         // check that `contains_sequence_types` returns true when there is a Sequence type in the interface
         assert!(ci
             .types
             .add_type_definition("TestSequence{}", Type::Sequence(Box::new(Type::UInt64)))
             .is_ok());
-        assert_eq!(ci.contains_sequence_types(), true);
+        assert!(ci.contains_sequence_types());
     }
 
     #[test]
@@ -956,14 +950,14 @@ mod test {
         };
 
         // check that `contains_map_types` returns false when there is no Map type in the interface
-        assert_eq!(ci.contains_map_types(), false);
+        assert!(!ci.contains_map_types());
 
         // check that `contains_map_types` returns true when there is a Map type in the interface
         assert!(ci
             .types
             .add_type_definition("Map{}", Type::Map(Box::new(Type::Boolean)))
             .is_ok());
-        assert_eq!(ci.contains_map_types(), true);
+        assert!(ci.contains_map_types());
     }
 
     #[test]

uniffi_bindgen/src/lib.rs

@@ -167,7 +167,7 @@ pub fn generate_bindings<P: AsRef<Path>>(
         guess_crate_root(udl_file)?,
         config_file_override,
     )?;
-    let out_dir = get_out_dir(&udl_file, out_dir_override)?;
+    let out_dir = get_out_dir(udl_file, out_dir_override)?;
     for language in target_languages {
         bindings::write_bindings(
             &config.bindings,