Clippy

Author: kornelski

rmp-serde/benches/buf.rs

@@ -2,7 +2,7 @@
 
 extern crate test;
 
-use rmp_serde;
+
 
 use serde::{Deserialize, Serialize};
 

rmp-serde/src/decode.rs

@@ -773,7 +773,7 @@ impl<'de, 'a, R: ReadSlice<'de> + 'a, C: SerializerConfig> de::MapAccess<'de> fo
     fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
         where V: DeserializeSeed<'de>
     {
-        Ok(seed.deserialize(&mut *self.de)?)
+        seed.deserialize(&mut *self.de)
     }
 
     #[inline(always)]

rmp-serde/src/lib.rs

@@ -151,7 +151,7 @@ impl Raw {
     pub fn as_err(&self) -> Option<&Utf8Error> {
         match self.s {
             Ok(..) => None,
-            Err((_, ref err)) => Some(&err),
+            Err((_, ref err)) => Some(err),
         }
     }
 
@@ -300,7 +300,7 @@ impl<'a> RawRef<'a> {
     #[inline]
     pub fn as_str(&self) -> Option<&str> {
         match self.s {
-            Ok(ref s) => Some(s),
+            Ok(s) => Some(s),
             Err(..) => None,
         }
     }
@@ -311,16 +311,16 @@ impl<'a> RawRef<'a> {
     pub fn as_err(&self) -> Option<&Utf8Error> {
         match self.s {
             Ok(..) => None,
-            Err((_, ref err)) => Some(&err),
+            Err((_, ref err)) => Some(err),
         }
     }
 
     /// Returns a byte slice of this raw's contents.
     #[inline]
     pub fn as_bytes(&self) -> &[u8] {
         match self.s {
-            Ok(ref s) => s.as_bytes(),
-            Err(ref err) => &err.0[..],
+            Ok(s) => s.as_bytes(),
+            Err(ref err) => err.0,
         }
     }
 }

rmp-serde/tests/round.rs

@@ -494,7 +494,7 @@ fn round_variant_string() {
         }
     }
 
-    do_test!(|b| Serializer::new(b));
+    do_test!(Serializer::new);
     do_test!(|b| Serializer::new(b).with_struct_map());
     do_test!(|b| Serializer::new(b).with_struct_tuple());
     do_test!(|b| Serializer::new(b).with_struct_map());

rmp/src/decode/bytes.rs

@@ -63,7 +63,7 @@ impl<'a> Bytes<'a> {
     /// Get a reference to the remaining bytes in the buffer.
     #[inline]
     pub fn remaining_slice(&self) -> &'a [u8] {
-        &self.bytes
+        self.bytes
     }
     /// Return the position of the input buffer.
     ///

rmp/src/decode/str.rs

@@ -137,7 +137,7 @@ pub fn read_str_data<'r, R>(rd: &mut R,
             Ok(decoded) => Ok(decoded),
             Err(err) => Err(DecodeStringError::InvalidUtf8(buf, err)),
         },
-        Err(err) => Err(DecodeStringError::InvalidDataRead(From::from(err))),
+        Err(err) => Err(DecodeStringError::InvalidDataRead(err)),
     }
 }
 

rmp/tests/func/decode/bool.rs

@@ -16,6 +16,6 @@ fn from_bool_true() {
     let buf = [0xc3];
     let mut cur = Cursor::new(&buf[..]);
 
-    assert_eq!(true, read_bool(&mut cur).unwrap());
+    assert!(read_bool(&mut cur).unwrap());
     assert_eq!(1, cur.position());
 }

rmp/tests/func/decode/null.rs

@@ -49,7 +49,7 @@ fn interrupt_safe() {
                 self.state_ = 1;
                 Err(Error::new(ErrorKind::Interrupted, "interrupted"))
             } else {
-                assert!(buf.len() > 0);
+                assert!(!buf.is_empty());
 
                 buf[0] = 0xc0;
                 Ok(1)

rmp/tests/func/decode/string.rs

@@ -137,9 +137,9 @@ fn from_str_strfix() {
     let buf: &[u8] = &[0xaa, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65];
     let mut cur = Cursor::new(buf);
 
-    let mut out: &mut [u8] = &mut [0u8; 16];
+    let out: &mut [u8] = &mut [0u8; 16];
 
-    assert_eq!("le message", read_str(&mut cur, &mut out).unwrap());
+    assert_eq!("le message", read_str(&mut cur, out).unwrap());
     assert_eq!(11, cur.position());
 }
 
@@ -148,9 +148,9 @@ fn from_str_strfix_extra_data() {
     let buf: &[u8] = &[0xaa, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x00];
     let mut cur = Cursor::new(buf);
 
-    let mut out: &mut [u8] = &mut [0u8; 16];
+    let out: &mut [u8] = &mut [0u8; 16];
 
-    assert_eq!("le message", read_str(&mut cur, &mut out).unwrap());
+    assert_eq!("le message", read_str(&mut cur, out).unwrap());
     assert_eq!(11, cur.position());
 }
 
@@ -159,9 +159,9 @@ fn from_str_strfix_exact_buffer() {
     let buf: &[u8] = &[0xaa, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65];
     let mut cur = Cursor::new(buf);
 
-    let mut out: &mut [u8] = &mut [0u8; 10];
+    let out: &mut [u8] = &mut [0u8; 10];
 
-    assert_eq!("le message", read_str(&mut cur, &mut out).unwrap());
+    assert_eq!("le message", read_str(&mut cur, out).unwrap());
     assert_eq!(11, cur.position());
 }
 
@@ -171,9 +171,9 @@ fn from_str_strfix_invalid_utf8() {
     let buf: &[u8] = &[0xa2, 0xc3, 0x28];
     let mut cur = Cursor::new(buf);
 
-    let mut out: &mut [u8] = &mut [0u8; 16];
+    let out: &mut [u8] = &mut [0u8; 16];
 
-    match read_str(&mut cur, &mut out) {
+    match read_str(&mut cur, out) {
         Err(DecodeStringError::InvalidUtf8(raw, _)) => {
             assert_eq!(&[0xc3, 0x28], raw);
         }
@@ -188,9 +188,9 @@ fn from_str_strfix_buffer_too_small() {
     let buf: &[u8] = &[0xaa, 0x6c, 0x65, 0x20, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65];
     let mut cur = Cursor::new(buf);
 
-    let mut out: &mut [u8] = &mut [0u8; 9];
+    let out: &mut [u8] = &mut [0u8; 9];
 
-    match read_str(&mut cur, &mut out) {
+    match read_str(&mut cur, out) {
         Err(DecodeStringError::BufferSizeTooSmall(10)) => (),
         other => panic!("unexpected result: {:?}", other)
     }

rmpv-tests/benches/value.rs

@@ -1,7 +1,7 @@
 #![feature(test)]
 
 extern crate rmp_serde as rmps;
-use rmpv;
+
 extern crate test;
 
 use test::Bencher;
@@ -42,7 +42,7 @@ fn from_complex_read_value_ref(b: &mut Bencher) {
 #[bench]
 fn from_complex_zero_copy_decode(b: &mut Bencher) {
     b.iter(|| {
-        let res: ValueRef<'_> = rmps::from_slice(&COMPLEX[..]).unwrap();
+        let res: ValueRef<'_> = rmps::from_slice(COMPLEX).unwrap();
         test::black_box(res);
     });
     b.bytes = COMPLEX.len() as u64;