Remove unnecessary qualifications

Author: bluk

src/lib.rs

@@ -5,7 +5,9 @@
     missing_copy_implementations,
     missing_debug_implementations,
     missing_docs,
-    rust_2018_idioms
+    rust_2018_idioms,
+    unused_lifetimes,
+    unused_qualifications
 )]
 
 #[cfg(all(feature = "alloc", not(feature = "std")))]

src/ser.rs

@@ -516,15 +516,15 @@ impl<'a> ser::Serializer for &'a mut MapKeySerializer {
         Err(Error::UnsupportedType)
     }
 
-    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
+    fn serialize_newtype_struct<T: ?Sized + Serialize>(
         self,
         _name: &'static str,
         _value: &T,
     ) -> Result<Vec<u8>> {
         Err(Error::UnsupportedType)
     }
 
-    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
+    fn serialize_newtype_variant<T: ?Sized + Serialize>(
         self,
         _name: &'static str,
         _variant_index: u32,
@@ -538,7 +538,7 @@ impl<'a> ser::Serializer for &'a mut MapKeySerializer {
         Err(Error::UnsupportedType)
     }
 
-    fn serialize_some<T: ?Sized + ser::Serialize>(self, _value: &T) -> Result<Vec<u8>> {
+    fn serialize_some<T: ?Sized + Serialize>(self, _value: &T) -> Result<Vec<u8>> {
         Err(Error::UnsupportedType)
     }
 

src/value/de.rs

@@ -3,7 +3,7 @@
 use super::{Number, Value};
 use crate::error::Error;
 use serde::de::{
-    self, DeserializeOwned, DeserializeSeed, IntoDeserializer, MapAccess, SeqAccess, Visitor,
+    DeserializeOwned, DeserializeSeed, IntoDeserializer, MapAccess, SeqAccess, Visitor,
 };
 use serde::forward_to_deserialize_any;
 use serde_bytes::ByteBuf;
@@ -97,14 +97,14 @@ impl<'de> serde::Deserializer<'de> for Value {
         visitor: V,
     ) -> Result<V::Value, Self::Error>
     where
-        V: de::Visitor<'de>,
+        V: Visitor<'de>,
     {
         visitor.visit_newtype_struct(self)
     }
 
     fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
     where
-        V: de::Visitor<'de>,
+        V: Visitor<'de>,
     {
         self.deserialize_seq(visitor)
     }
@@ -116,7 +116,7 @@ impl<'de> serde::Deserializer<'de> for Value {
         visitor: V,
     ) -> Result<V::Value, Self::Error>
     where
-        V: de::Visitor<'de>,
+        V: Visitor<'de>,
     {
         self.deserialize_seq(visitor)
     }

src/value/ser.rs

@@ -400,15 +400,15 @@ impl ser::Serializer for &mut DictKeySerializer {
         Err(Error::UnsupportedType)
     }
 
-    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(
+    fn serialize_newtype_struct<T: ?Sized + Serialize>(
         self,
         _name: &'static str,
         _value: &T,
     ) -> Result<Self::Ok> {
         Err(Error::UnsupportedType)
     }
 
-    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(
+    fn serialize_newtype_variant<T: ?Sized + Serialize>(
         self,
         _name: &'static str,
         _variant_index: u32,
@@ -422,7 +422,7 @@ impl ser::Serializer for &mut DictKeySerializer {
         Err(Error::UnsupportedType)
     }
 
-    fn serialize_some<T: ?Sized + ser::Serialize>(self, _value: &T) -> Result<Self::Ok> {
+    fn serialize_some<T: ?Sized + Serialize>(self, _value: &T) -> Result<Self::Ok> {
         Err(Error::UnsupportedType)
     }
 
@@ -637,7 +637,7 @@ mod tests {
         use serde::Serializer;
 
         assert!(matches!(
-            super::Serializer.serialize_unit_struct("Nothing"),
+            Serializer.serialize_unit_struct("Nothing"),
             Err(Error::UnsupportedType)
         ));
     }
@@ -647,7 +647,7 @@ mod tests {
         use serde::Serializer;
 
         assert!(matches!(
-            super::Serializer.serialize_unit_variant("Nothing", 0, "Case"),
+            Serializer.serialize_unit_variant("Nothing", 0, "Case"),
             Err(Error::UnsupportedType)
         ));
     }
@@ -656,17 +656,15 @@ mod tests {
     fn test_serialize_newtype_struct() {
         use serde::Serializer;
 
-        assert!(super::Serializer
-            .serialize_newtype_struct("Nothing", &2)
-            .is_ok());
+        assert!(Serializer.serialize_newtype_struct("Nothing", &2).is_ok());
     }
 
     #[test]
     fn test_serialize_newtype_variant() {
         use serde::Serializer;
 
         assert!(matches!(
-            super::Serializer.serialize_unit_variant("Nothing", 0, "Case"),
+            Serializer.serialize_unit_variant("Nothing", 0, "Case"),
             Err(Error::UnsupportedType)
         ));
     }
@@ -695,7 +693,7 @@ mod tests {
         use serde::Serializer;
 
         assert!(matches!(
-            super::Serializer.serialize_tuple(0),
+            Serializer.serialize_tuple(0),
             Err(Error::UnsupportedType)
         ));
     }
@@ -705,7 +703,7 @@ mod tests {
         use serde::Serializer;
 
         assert!(matches!(
-            super::Serializer.serialize_tuple_struct("Tuple Struct", 2),
+            Serializer.serialize_tuple_struct("Tuple Struct", 2),
             Err(Error::UnsupportedType)
         ));
     }
@@ -715,7 +713,7 @@ mod tests {
         use serde::Serializer;
 
         assert!(matches!(
-            super::Serializer.serialize_tuple_variant("Tuple Variant", 2, "Case", 1),
+            Serializer.serialize_tuple_variant("Tuple Variant", 2, "Case", 1),
             Err(Error::UnsupportedType)
         ));
     }
@@ -725,7 +723,7 @@ mod tests {
         use serde::Serializer;
 
         assert!(matches!(
-            super::Serializer.serialize_struct_variant("Struct Variant", 2, "Case", 1),
+            Serializer.serialize_struct_variant("Struct Variant", 2, "Case", 1),
             Err(Error::UnsupportedType)
         ));
     }