clippy::multiple_bound_locations (#103)

* clippy::multiple_bound_locations

* A few more clippy fixes.

---------

Co-authored-by: Sam Scott <sam@osohq.com>

3 files changed, 29 insertions, 29 deletions

diff --git a/examples/csv_vectors.rs b/examples/csv_vectors.rs
index 9d5e0ea..2e44566 100644
--- a/examples/csv_vectors.rs
+++ b/examples/csv_vectors.rs
@@ -48,7 +48,7 @@ impl<T: DeserializeOwned + std::str::FromStr> Default for CSVVecVisitor<T> {
     }
 }
 
-impl<'de, T: DeserializeOwned + std::str::FromStr> serde::de::Visitor<'de> for CSVVecVisitor<T>
+impl<T: DeserializeOwned + std::str::FromStr> serde::de::Visitor<'_> for CSVVecVisitor<T>
 where
     <T as std::str::FromStr>::Err: std::fmt::Debug, // handle the parse error in a generic way
 {
diff --git a/src/de/parse.rs b/src/de/parse.rs
index a76f2c5..4f96fb9 100644
--- a/src/de/parse.rs
+++ b/src/de/parse.rs
@@ -184,7 +184,7 @@ impl<'a> Iterator for Parser<'a> {
     }
 }
 
-impl<'a> Parser<'a> {
+impl Parser<'_> {
     #[inline]
     fn peek(&mut self) -> Option<<Self as Iterator>::Item> {
         if self.peeked.is_some() {
@@ -268,7 +268,7 @@ impl<'a> Parser<'a> {
             Cow::Owned(owned) => Ok(Cow::Owned(owned)),
         };
         self.clear_acc();
-        ret.map_err(Error::from)
+        ret
     }
 
     /// In some ways the main way to use a `Parser`, this runs the parsing step
diff --git a/src/ser.rs b/src/ser.rs
index 5198d71..5c21d92 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -458,12 +458,12 @@ pub struct QsSeq<'a, W: 'a + Write>(QsSerializer<'a, W>, usize);
 #[doc(hidden)]
 pub struct QsMap<'a, W: 'a + Write>(QsSerializer<'a, W>, Option<Cow<'a, str>>);
 
-impl<'a, W: Write> ser::SerializeTuple for QsSeq<'a, W> {
+impl<W: Write> ser::SerializeTuple for QsSeq<'_, W> {
     type Ok = ();
     type Error = Error;
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let key = self.1.to_string();
         self.1 += 1;
@@ -477,12 +477,12 @@ impl<'a, W: Write> ser::SerializeTuple for QsSeq<'a, W> {
     }
 }
 
-impl<'a, W: Write> ser::SerializeSeq for QsSeq<'a, W> {
+impl<W: Write> ser::SerializeSeq for QsSeq<'_, W> {
     type Ok = ();
     type Error = Error;
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(&mut self.0);
         serializer.extend_key(&self.1.to_string());
@@ -494,12 +494,12 @@ impl<'a, W: Write> ser::SerializeSeq for QsSeq<'a, W> {
     }
 }
 
-impl<'a, W: Write> ser::SerializeStruct for QsSerializer<'a, W> {
+impl<W: Write> ser::SerializeStruct for QsSerializer<'_, W> {
     type Ok = ();
     type Error = Error;
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(self);
         serializer.extend_key(key);
@@ -510,13 +510,13 @@ impl<'a, W: Write> ser::SerializeStruct for QsSerializer<'a, W> {
     }
 }
 
-impl<'a, W: Write> ser::SerializeStructVariant for QsSerializer<'a, W> {
+impl<W: Write> ser::SerializeStructVariant for QsSerializer<'_, W> {
     type Ok = ();
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(self);
         serializer.extend_key(key);
@@ -528,13 +528,13 @@ impl<'a, W: Write> ser::SerializeStructVariant for QsSerializer<'a, W> {
     }
 }
 
-impl<'a, W: Write> ser::SerializeTupleVariant for QsSeq<'a, W> {
+impl<W: Write> ser::SerializeTupleVariant for QsSeq<'_, W> {
     type Ok = ();
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(&mut self.0);
         serializer.extend_key(&self.1.to_string());
@@ -547,13 +547,13 @@ impl<'a, W: Write> ser::SerializeTupleVariant for QsSeq<'a, W> {
     }
 }
 
-impl<'a, W: Write> ser::SerializeTupleStruct for QsSeq<'a, W> {
+impl<W: Write> ser::SerializeTupleStruct for QsSeq<'_, W> {
     type Ok = ();
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(&mut self.0);
         serializer.extend_key(&self.1.to_string());
@@ -566,21 +566,21 @@ impl<'a, W: Write> ser::SerializeTupleStruct for QsSeq<'a, W> {
     }
 }
 
-impl<'a, W: Write> ser::SerializeMap for QsMap<'a, W> {
+impl<W: Write> ser::SerializeMap for QsMap<'_, W> {
     type Ok = ();
     type Error = Error;
 
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()>
+    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         self.1 = Some(Cow::from(key.serialize(StringSerializer)?));
         Ok(())
     }
 
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(&mut self.0);
         if let Some(ref key) = self.1 {
@@ -596,10 +596,10 @@ impl<'a, W: Write> ser::SerializeMap for QsMap<'a, W> {
         Ok(())
     }
 
-    fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<()>
+    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
     where
-        K: ser::Serialize,
-        V: ser::Serialize,
+        K: ser::Serialize + ?Sized,
+        V: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(&mut self.0);
         serializer.extend_key(&key.serialize(StringSerializer)?);