minor: bump clippy version to 1.83.0 (#509)

isabelatkinson · web-flow · commit e0aab6fedc80 · 2024-12-12T11:51:52.000-05:00
diff --git a/.evergreen/check-clippy.sh b/.evergreen/check-clippy.sh
@@ -5,7 +5,7 @@ set -o errexit
 . ~/.cargo/env
 
 # Pin clippy to the latest version. This should be updated when new versions of Rust are released.
-CLIPPY_VERSION=1.80.0
+CLIPPY_VERSION=1.83.0
 
 rustup install $CLIPPY_VERSION
 
diff --git a/src/de/mod.rs b/src/de/mod.rs
@@ -91,7 +91,7 @@ where
     let de = Deserializer::new(bson);
     #[cfg(feature = "serde_path_to_error")]
     {
-        return serde_path_to_error::deserialize(de).map_err(Error::with_path);
+        serde_path_to_error::deserialize(de).map_err(Error::with_path)
     }
     #[cfg(not(feature = "serde_path_to_error"))]
     {
diff --git a/src/de/raw.rs b/src/de/raw.rs
@@ -730,7 +730,7 @@ struct TimestampAccess<'d> {
     deserializer: &'d mut TimestampDeserializer,
 }
 
-impl<'de, 'd> serde::de::MapAccess<'de> for TimestampAccess<'d> {
+impl<'de> serde::de::MapAccess<'de> for TimestampAccess<'_> {
     type Error = Error;
 
     fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
@@ -775,7 +775,7 @@ impl TimestampDeserializer {
     }
 }
 
-impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut TimestampDeserializer {
+impl<'de> serde::de::Deserializer<'de> for &mut TimestampDeserializer {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
@@ -823,7 +823,7 @@ struct DateTimeAccess<'d> {
     deserializer: &'d mut DateTimeDeserializer,
 }
 
-impl<'de, 'd> serde::de::MapAccess<'de> for DateTimeAccess<'d> {
+impl<'de> serde::de::MapAccess<'de> for DateTimeAccess<'_> {
     type Error = Error;
 
     fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
@@ -875,7 +875,7 @@ impl DateTimeDeserializer {
     }
 }
 
-impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut DateTimeDeserializer {
+impl<'de> serde::de::Deserializer<'de> for &mut DateTimeDeserializer {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
@@ -932,7 +932,7 @@ struct BinaryAccess<'d, 'de> {
     deserializer: &'d mut BinaryDeserializer<'de>,
 }
 
-impl<'de, 'd> serde::de::MapAccess<'de> for BinaryAccess<'d, 'de> {
+impl<'de> serde::de::MapAccess<'de> for BinaryAccess<'_, 'de> {
     type Error = Error;
 
     fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
@@ -976,7 +976,7 @@ impl<'a> BinaryDeserializer<'a> {
     }
 }
 
-impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut BinaryDeserializer<'de> {
+impl<'de> serde::de::Deserializer<'de> for &mut BinaryDeserializer<'de> {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
@@ -1084,7 +1084,7 @@ impl<'de> serde::de::MapAccess<'de> for CodeWithScopeAccess<'de> {
     }
 }
 
-impl<'a, 'de> serde::de::Deserializer<'de> for &'a CodeWithScopeAccess<'de> {
+impl<'de> serde::de::Deserializer<'de> for &CodeWithScopeAccess<'de> {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
@@ -1180,7 +1180,7 @@ impl<'de> serde::de::MapAccess<'de> for DbPointerAccess<'de> {
     }
 }
 
-impl<'a, 'de> serde::de::Deserializer<'de> for &'a mut DbPointerAccess<'de> {
+impl<'de> serde::de::Deserializer<'de> for &mut DbPointerAccess<'de> {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>
@@ -1289,7 +1289,7 @@ impl<'de> serde::de::MapAccess<'de> for RegexAccess<'de> {
     }
 }
 
-impl<'a, 'de> serde::de::Deserializer<'de> for &'a mut RegexAccess<'de> {
+impl<'de> serde::de::Deserializer<'de> for &mut RegexAccess<'de> {
     type Error = Error;
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
diff --git a/src/document.rs b/src/document.rs
@@ -696,7 +696,7 @@ pub struct VacantEntry<'a> {
     inner: indexmap::map::VacantEntry<'a, String, Bson>,
 }
 
-impl<'a> VacantEntry<'a> {
+impl VacantEntry<'_> {
     /// Gets a reference to the key that would be used when inserting a value through the
     /// [VacantEntry].
     fn key(&self) -> &str {
@@ -709,7 +709,7 @@ pub struct OccupiedEntry<'a> {
     inner: indexmap::map::OccupiedEntry<'a, String, Bson>,
 }
 
-impl<'a> OccupiedEntry<'a> {
+impl OccupiedEntry<'_> {
     /// Gets a reference to the key in the entry.
     pub fn key(&self) -> &str {
         self.inner.key()
diff --git a/src/raw/array.rs b/src/raw/array.rs
@@ -304,14 +304,14 @@ impl<'de: 'a, 'a> Deserialize<'de> for &'a RawArray {
     }
 }
 
-impl<'a> Serialize for &'a RawArray {
+impl Serialize for &RawArray {
     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
         struct SeqSerializer<'a>(&'a RawArray);
 
-        impl<'a> Serialize for SeqSerializer<'a> {
+        impl Serialize for SeqSerializer<'_> {
             fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
             where
                 S: serde::Serializer,
diff --git a/src/raw/array_buf.rs b/src/raw/array_buf.rs
@@ -136,7 +136,7 @@ impl<'a> IntoIterator for &'a RawArrayBuf {
     }
 }
 
-impl<'a> From<RawArrayBuf> for Cow<'a, RawArray> {
+impl From<RawArrayBuf> for Cow<'_, RawArray> {
     fn from(rd: RawArrayBuf) -> Self {
         Cow::Owned(rd)
     }
diff --git a/src/raw/bson_ref.rs b/src/raw/bson_ref.rs
@@ -312,7 +312,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for RawBsonRef<'a> {
     }
 }
 
-impl<'a> Serialize for RawBsonRef<'a> {
+impl Serialize for RawBsonRef<'_> {
     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -371,13 +371,13 @@ impl<'a> TryFrom<RawBsonRef<'a>> for Bson {
     }
 }
 
-impl<'a> From<i32> for RawBsonRef<'a> {
+impl From<i32> for RawBsonRef<'_> {
     fn from(i: i32) -> Self {
         RawBsonRef::Int32(i)
     }
 }
 
-impl<'a> From<i64> for RawBsonRef<'a> {
+impl From<i64> for RawBsonRef<'_> {
     fn from(i: i64) -> Self {
         RawBsonRef::Int64(i)
     }
@@ -389,13 +389,13 @@ impl<'a> From<&'a str> for RawBsonRef<'a> {
     }
 }
 
-impl<'a> From<f64> for RawBsonRef<'a> {
+impl From<f64> for RawBsonRef<'_> {
     fn from(f: f64) -> Self {
         RawBsonRef::Double(f)
     }
 }
 
-impl<'a> From<bool> for RawBsonRef<'a> {
+impl From<bool> for RawBsonRef<'_> {
     fn from(b: bool) -> Self {
         RawBsonRef::Boolean(b)
     }
@@ -425,25 +425,25 @@ impl<'a> From<&'a RawArrayBuf> for RawBsonRef<'a> {
     }
 }
 
-impl<'a> From<crate::DateTime> for RawBsonRef<'a> {
+impl From<crate::DateTime> for RawBsonRef<'_> {
     fn from(dt: crate::DateTime) -> Self {
         RawBsonRef::DateTime(dt)
     }
 }
 
-impl<'a> From<Timestamp> for RawBsonRef<'a> {
+impl From<Timestamp> for RawBsonRef<'_> {
     fn from(ts: Timestamp) -> Self {
         RawBsonRef::Timestamp(ts)
     }
 }
 
-impl<'a> From<ObjectId> for RawBsonRef<'a> {
+impl From<ObjectId> for RawBsonRef<'_> {
     fn from(oid: ObjectId) -> Self {
         RawBsonRef::ObjectId(oid)
     }
 }
 
-impl<'a> From<Decimal128> for RawBsonRef<'a> {
+impl From<Decimal128> for RawBsonRef<'_> {
     fn from(d: Decimal128) -> Self {
         RawBsonRef::Decimal128(d)
     }
@@ -459,7 +459,7 @@ pub struct RawBinaryRef<'a> {
     pub bytes: &'a [u8],
 }
 
-impl<'a> RawBinaryRef<'a> {
+impl RawBinaryRef<'_> {
     /// Copy the contents into a [`Binary`].
     pub fn to_binary(&self) -> Binary {
         Binary {
@@ -491,7 +491,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for RawBinaryRef<'a> {
     }
 }
 
-impl<'a> Serialize for RawBinaryRef<'a> {
+impl Serialize for RawBinaryRef<'_> {
     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -569,7 +569,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for RawRegexRef<'a> {
     }
 }
 
-impl<'a> Serialize for RawRegexRef<'a> {
+impl Serialize for RawRegexRef<'_> {
     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -606,7 +606,7 @@ pub struct RawJavaScriptCodeWithScopeRef<'a> {
     pub scope: &'a RawDocument,
 }
 
-impl<'a> RawJavaScriptCodeWithScopeRef<'a> {
+impl RawJavaScriptCodeWithScopeRef<'_> {
     pub(crate) fn len(self) -> i32 {
         4 + 4 + self.code.len() as i32 + 1 + self.scope.as_bytes().len() as i32
     }
@@ -627,7 +627,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for RawJavaScriptCodeWithScopeRef<'a> {
     }
 }
 
-impl<'a> Serialize for RawJavaScriptCodeWithScopeRef<'a> {
+impl Serialize for RawJavaScriptCodeWithScopeRef<'_> {
     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
@@ -667,7 +667,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for RawDbPointerRef<'a> {
     }
 }
 
-impl<'a> Serialize for RawDbPointerRef<'a> {
+impl Serialize for RawDbPointerRef<'_> {
     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
diff --git a/src/raw/document.rs b/src/raw/document.rs
@@ -548,14 +548,14 @@ impl<'de: 'a, 'a> Deserialize<'de> for &'a RawDocument {
     }
 }
 
-impl<'a> Serialize for &'a RawDocument {
+impl Serialize for &RawDocument {
     fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
         struct KvpSerializer<'a>(&'a RawDocument);
 
-        impl<'a> Serialize for KvpSerializer<'a> {
+        impl Serialize for KvpSerializer<'_> {
             fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
             where
                 S: serde::Serializer,
diff --git a/src/raw/document_buf.rs b/src/raw/document_buf.rs
@@ -268,7 +268,7 @@ impl std::fmt::Debug for RawDocumentBuf {
     }
 }
 
-impl<'a> From<RawDocumentBuf> for Cow<'a, RawDocument> {
+impl From<RawDocumentBuf> for Cow<'_, RawDocument> {
     fn from(rd: RawDocumentBuf) -> Self {
         Cow::Owned(rd)
     }
diff --git a/src/raw/iter.rs b/src/raw/iter.rs
@@ -128,15 +128,15 @@ impl<'a> TryInto<RawBsonRef<'a>> for RawElement<'a> {
     }
 }
 
-impl<'a> TryInto<RawBson> for RawElement<'a> {
+impl TryInto<RawBson> for RawElement<'_> {
     type Error = Error;
 
     fn try_into(self) -> Result<RawBson> {
         Ok(self.value()?.to_raw_bson())
     }
 }
 
-impl<'a> TryInto<Bson> for RawElement<'a> {
+impl TryInto<Bson> for RawElement<'_> {
     type Error = Error;
 
     fn try_into(self) -> Result<Bson> {
@@ -340,7 +340,7 @@ impl<'a> RawElement<'a> {
     }
 }
 
-impl<'a> RawIter<'a> {
+impl RawIter<'_> {
     fn get_next_length_at(&self, start_at: usize) -> Result<usize> {
         let len = i32_from_slice(&self.doc.as_bytes()[start_at..])?;
         if len < 0 {
diff --git a/src/raw/serde.rs b/src/raw/serde.rs
@@ -54,7 +54,7 @@ impl<'a, 'de: 'a> Deserialize<'de> for OwnedOrBorrowedRawBson<'a> {
     }
 }
 
-impl<'a> Debug for OwnedOrBorrowedRawBson<'a> {
+impl Debug for OwnedOrBorrowedRawBson<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::Owned(o) => o.fmt(f),
@@ -69,7 +69,7 @@ impl<'a> From<RawBsonRef<'a>> for OwnedOrBorrowedRawBson<'a> {
     }
 }
 
-impl<'a> From<RawBson> for OwnedOrBorrowedRawBson<'a> {
+impl From<RawBson> for OwnedOrBorrowedRawBson<'_> {
     fn from(b: RawBson) -> Self {
         OwnedOrBorrowedRawBson::Owned(b)
     }
@@ -82,7 +82,7 @@ pub(crate) enum OwnedOrBorrowedRawDocument<'a> {
     Borrowed(&'a RawDocument),
 }
 
-impl<'a> OwnedOrBorrowedRawDocument<'a> {
+impl OwnedOrBorrowedRawDocument<'_> {
     pub(crate) fn into_owned(self) -> RawDocumentBuf {
         match self {
             Self::Owned(o) => o,
@@ -91,7 +91,7 @@ impl<'a> OwnedOrBorrowedRawDocument<'a> {
     }
 }
 
-impl<'a> From<RawDocumentBuf> for OwnedOrBorrowedRawDocument<'a> {
+impl From<RawDocumentBuf> for OwnedOrBorrowedRawDocument<'_> {
     fn from(doc: RawDocumentBuf) -> Self {
         Self::Owned(doc)
     }
@@ -160,7 +160,7 @@ pub(crate) enum OwnedOrBorrowedRawArray<'a> {
     Borrowed(&'a RawArray),
 }
 
-impl<'a> OwnedOrBorrowedRawArray<'a> {
+impl OwnedOrBorrowedRawArray<'_> {
     pub(crate) fn into_owned(self) -> RawArrayBuf {
         match self {
             Self::Owned(o) => o,
diff --git a/src/raw/serde/seeded_visitor.rs b/src/raw/serde/seeded_visitor.rs
@@ -82,7 +82,7 @@ pub(crate) struct SeededVisitor<'a, 'de> {
     buffer: &'a mut CowByteBuffer<'de>,
 }
 
-impl<'a, 'de> DeserializeSeed<'de> for SeededVisitor<'a, 'de> {
+impl<'de> DeserializeSeed<'de> for SeededVisitor<'_, 'de> {
     type Value = ElementType;
 
     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
@@ -93,7 +93,7 @@ impl<'a, 'de> DeserializeSeed<'de> for SeededVisitor<'a, 'de> {
     }
 }
 
-impl<'a, 'de> DeserializeSeed<'de> for &mut SeededVisitor<'a, 'de> {
+impl<'de> DeserializeSeed<'de> for &mut SeededVisitor<'_, 'de> {
     type Value = ElementType;
 
     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
@@ -233,7 +233,7 @@ impl<'a, 'de> SeededVisitor<'a, 'de> {
     }
 }
 
-impl<'a, 'de> Visitor<'de> for SeededVisitor<'a, 'de> {
+impl<'de> Visitor<'de> for SeededVisitor<'_, 'de> {
     type Value = ElementType;
 
     fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {
diff --git a/src/ser/raw/document_serializer.rs b/src/ser/raw/document_serializer.rs
diff --git a/src/ser/raw/mod.rs b/src/ser/raw/mod.rs
diff --git a/src/ser/raw/value_serializer.rs b/src/ser/raw/value_serializer.rs
diff --git a/src/tests/serde_helpers.rs b/src/tests/serde_helpers.rs
diff --git a/src/tests/spec/corpus.rs b/src/tests/spec/corpus.rs

Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,7 @@ where`
`91`	`91`	`let de = Deserializer::new(bson);`
`92`	`92`	`#[cfg(feature = "serde_path_to_error")]`
`93`	`93`	`{`
`94`		`- return serde_path_to_error::deserialize(de).map_err(Error::with_path);`
	`94`	`+ serde_path_to_error::deserialize(de).map_err(Error::with_path)`
`95`	`95`	`}`
`96`	`96`	`#[cfg(not(feature = "serde_path_to_error"))]`
`97`	`97`	`{`
Original file line number	Diff line number	Diff line change
`@@ -730,7 +730,7 @@ struct TimestampAccess<'d> {`
`730`	`730`	`deserializer: &'d mut TimestampDeserializer,`
`731`	`731`	`}`
`732`	`732`
`733`		`-impl<'de, 'd> serde::de::MapAccess<'de> for TimestampAccess<'d> {`
	`733`	`+impl<'de> serde::de::MapAccess<'de> for TimestampAccess<'_> {`
`734`	`734`	`type Error = Error;`
`735`	`735`
`736`	`736`	`fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>`
`@@ -775,7 +775,7 @@ impl TimestampDeserializer {`
`775`	`775`	`}`
`776`	`776`	`}`
`777`	`777`
`778`		`-impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut TimestampDeserializer {`
	`778`	`+impl<'de> serde::de::Deserializer<'de> for &mut TimestampDeserializer {`
`779`	`779`	`type Error = Error;`
`780`	`780`
`781`	`781`	`fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>`
`@@ -823,7 +823,7 @@ struct DateTimeAccess<'d> {`
`823`	`823`	`deserializer: &'d mut DateTimeDeserializer,`
`824`	`824`	`}`
`825`	`825`
`826`		`-impl<'de, 'd> serde::de::MapAccess<'de> for DateTimeAccess<'d> {`
	`826`	`+impl<'de> serde::de::MapAccess<'de> for DateTimeAccess<'_> {`
`827`	`827`	`type Error = Error;`
`828`	`828`
`829`	`829`	`fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>`
`@@ -875,7 +875,7 @@ impl DateTimeDeserializer {`
`875`	`875`	`}`
`876`	`876`	`}`
`877`	`877`
`878`		`-impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut DateTimeDeserializer {`
	`878`	`+impl<'de> serde::de::Deserializer<'de> for &mut DateTimeDeserializer {`
`879`	`879`	`type Error = Error;`
`880`	`880`
`881`	`881`	`fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>`
`@@ -932,7 +932,7 @@ struct BinaryAccess<'d, 'de> {`
`932`	`932`	`deserializer: &'d mut BinaryDeserializer<'de>,`
`933`	`933`	`}`
`934`	`934`
`935`		`-impl<'de, 'd> serde::de::MapAccess<'de> for BinaryAccess<'d, 'de> {`
	`935`	`+impl<'de> serde::de::MapAccess<'de> for BinaryAccess<'_, 'de> {`
`936`	`936`	`type Error = Error;`
`937`	`937`
`938`	`938`	`fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>`
`@@ -976,7 +976,7 @@ impl<'a> BinaryDeserializer<'a> {`
`976`	`976`	`}`
`977`	`977`	`}`
`978`	`978`
`979`		`-impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut BinaryDeserializer<'de> {`
	`979`	`+impl<'de> serde::de::Deserializer<'de> for &mut BinaryDeserializer<'de> {`
`980`	`980`	`type Error = Error;`
`981`	`981`
`982`	`982`	`fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>`
`@@ -1084,7 +1084,7 @@ impl<'de> serde::de::MapAccess<'de> for CodeWithScopeAccess<'de> {`
`1084`	`1084`	`}`
`1085`	`1085`	`}`
`1086`	`1086`
`1087`		`-impl<'a, 'de> serde::de::Deserializer<'de> for &'a CodeWithScopeAccess<'de> {`
	`1087`	`+impl<'de> serde::de::Deserializer<'de> for &CodeWithScopeAccess<'de> {`
`1088`	`1088`	`type Error = Error;`
`1089`	`1089`
`1090`	`1090`	`fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>`
`@@ -1180,7 +1180,7 @@ impl<'de> serde::de::MapAccess<'de> for DbPointerAccess<'de> {`
`1180`	`1180`	`}`
`1181`	`1181`	`}`
`1182`	`1182`
`1183`		`-impl<'a, 'de> serde::de::Deserializer<'de> for &'a mut DbPointerAccess<'de> {`
	`1183`	`+impl<'de> serde::de::Deserializer<'de> for &mut DbPointerAccess<'de> {`
`1184`	`1184`	`type Error = Error;`
`1185`	`1185`
`1186`	`1186`	`fn deserialize_any<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error>`
`@@ -1289,7 +1289,7 @@ impl<'de> serde::de::MapAccess<'de> for RegexAccess<'de> {`
`1289`	`1289`	`}`
`1290`	`1290`	`}`
`1291`	`1291`
`1292`		`-impl<'a, 'de> serde::de::Deserializer<'de> for &'a mut RegexAccess<'de> {`
	`1292`	`+impl<'de> serde::de::Deserializer<'de> for &mut RegexAccess<'de> {`
`1293`	`1293`	`type Error = Error;`
`1294`	`1294`
`1295`	`1295`	`fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>`
Original file line number	Diff line number	Diff line change
`@@ -304,14 +304,14 @@ impl<'de: 'a, 'a> Deserialize<'de> for &'a RawArray {`
`304`	`304`	`}`
`305`	`305`	`}`
`306`	`306`
`307`		`-impl<'a> Serialize for &'a RawArray {`
	`307`	`+impl Serialize for &RawArray {`
`308`	`308`	`fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>`
`309`	`309`	`where`
`310`	`310`	`S: serde::Serializer,`
`311`	`311`	`{`
`312`	`312`	`struct SeqSerializer<'a>(&'a RawArray);`
`313`	`313`
`314`		`- impl<'a> Serialize for SeqSerializer<'a> {`
	`314`	`+ impl Serialize for SeqSerializer<'_> {`
`315`	`315`	`fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>`
`316`	`316`	`where`
`317`	`317`	`S: serde::Serializer,`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ impl<'a> IntoIterator for &'a RawArrayBuf {`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`
`139`		`-impl<'a> From<RawArrayBuf> for Cow<'a, RawArray> {`
	`139`	`+impl From<RawArrayBuf> for Cow<'_, RawArray> {`
`140`	`140`	`fn from(rd: RawArrayBuf) -> Self {`
`141`	`141`	`Cow::Owned(rd)`
`142`	`142`	`}`
Original file line number	Diff line number	Diff line change
`@@ -312,7 +312,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for RawBsonRef<'a> {`
`312`	`312`	`}`
`313`	`313`	`}`
`314`	`314`
`315`		`-impl<'a> Serialize for RawBsonRef<'a> {`
	`315`	`+impl Serialize for RawBsonRef<'_> {`
`316`	`316`	`fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>`
`317`	`317`	`where`
`318`	`318`	`S: serde::Serializer,`
`@@ -371,13 +371,13 @@ impl<'a> TryFrom<RawBsonRef<'a>> for Bson {`
`371`	`371`	`}`
`372`	`372`	`}`
`373`	`373`
`374`		`-impl<'a> From<i32> for RawBsonRef<'a> {`
	`374`	`+impl From<i32> for RawBsonRef<'_> {`
`375`	`375`	`fn from(i: i32) -> Self {`
`376`	`376`	`RawBsonRef::Int32(i)`
`377`	`377`	`}`
`378`	`378`	`}`
`379`	`379`
`380`		`-impl<'a> From<i64> for RawBsonRef<'a> {`
	`380`	`+impl From<i64> for RawBsonRef<'_> {`
`381`	`381`	`fn from(i: i64) -> Self {`
`382`	`382`	`RawBsonRef::Int64(i)`
`383`	`383`	`}`
`@@ -389,13 +389,13 @@ impl<'a> From<&'a str> for RawBsonRef<'a> {`
`389`	`389`	`}`
`390`	`390`	`}`
`391`	`391`
`392`		`-impl<'a> From<f64> for RawBsonRef<'a> {`
	`392`	`+impl From<f64> for RawBsonRef<'_> {`
`393`	`393`	`fn from(f: f64) -> Self {`
`394`	`394`	`RawBsonRef::Double(f)`
`395`	`395`	`}`
`396`	`396`	`}`
`397`	`397`
`398`		`-impl<'a> From<bool> for RawBsonRef<'a> {`
	`398`	`+impl From<bool> for RawBsonRef<'_> {`
`399`	`399`	`fn from(b: bool) -> Self {`
`400`	`400`	`RawBsonRef::Boolean(b)`
`401`	`401`	`}`
`@@ -425,25 +425,25 @@ impl<'a> From<&'a RawArrayBuf> for RawBsonRef<'a> {`
`425`	`425`	`}`
`426`	`426`	`}`
`427`	`427`
`428`		`-impl<'a> From<crate::DateTime> for RawBsonRef<'a> {`
	`428`	`+impl From<crate::DateTime> for RawBsonRef<'_> {`
`429`	`429`	`fn from(dt: crate::DateTime) -> Self {`
`430`	`430`	`RawBsonRef::DateTime(dt)`
`431`	`431`	`}`
`432`	`432`	`}`
`433`	`433`
`434`		`-impl<'a> From<Timestamp> for RawBsonRef<'a> {`
	`434`	`+impl From<Timestamp> for RawBsonRef<'_> {`
`435`	`435`	`fn from(ts: Timestamp) -> Self {`
`436`	`436`	`RawBsonRef::Timestamp(ts)`
`437`	`437`	`}`
`438`	`438`	`}`
`439`	`439`
`440`		`-impl<'a> From<ObjectId> for RawBsonRef<'a> {`
	`440`	`+impl From<ObjectId> for RawBsonRef<'_> {`
`441`	`441`	`fn from(oid: ObjectId) -> Self {`
`442`	`442`	`RawBsonRef::ObjectId(oid)`
`443`	`443`	`}`
`444`	`444`	`}`
`445`	`445`
`446`		`-impl<'a> From<Decimal128> for RawBsonRef<'a> {`
	`446`	`+impl From<Decimal128> for RawBsonRef<'_> {`
`447`	`447`	`fn from(d: Decimal128) -> Self {`
`448`	`448`	`RawBsonRef::Decimal128(d)`
`449`	`449`	`}`
`@@ -459,7 +459,7 @@ pub struct RawBinaryRef<'a> {`
`459`	`459`	`pub bytes: &'a [u8],`
`460`	`460`	`}`
`461`	`461`
`462`		`-impl<'a> RawBinaryRef<'a> {`
	`462`	`+impl RawBinaryRef<'_> {`
`463`	`463`	/// Copy the contents into a [`Binary`].
`464`	`464`	`pub fn to_binary(&self) -> Binary {`
`465`	`465`	`Binary {`
`@@ -491,7 +491,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for RawBinaryRef<'a> {`
`491`	`491`	`}`
`492`	`492`	`}`
`493`	`493`
`494`		`-impl<'a> Serialize for RawBinaryRef<'a> {`
	`494`	`+impl Serialize for RawBinaryRef<'_> {`
`495`	`495`	`fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>`
`496`	`496`	`where`
`497`	`497`	`S: serde::Serializer,`
`@@ -569,7 +569,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for RawRegexRef<'a> {`
`569`	`569`	`}`
`570`	`570`	`}`
`571`	`571`
`572`		`-impl<'a> Serialize for RawRegexRef<'a> {`
	`572`	`+impl Serialize for RawRegexRef<'_> {`
`573`	`573`	`fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>`
`574`	`574`	`where`
`575`	`575`	`S: serde::Serializer,`
`@@ -606,7 +606,7 @@ pub struct RawJavaScriptCodeWithScopeRef<'a> {`
`606`	`606`	`pub scope: &'a RawDocument,`
`607`	`607`	`}`
`608`	`608`
`609`		`-impl<'a> RawJavaScriptCodeWithScopeRef<'a> {`
	`609`	`+impl RawJavaScriptCodeWithScopeRef<'_> {`
`610`	`610`	`pub(crate) fn len(self) -> i32 {`
`611`	`611`	`4 + 4 + self.code.len() as i32 + 1 + self.scope.as_bytes().len() as i32`
`612`	`612`	`}`
`@@ -627,7 +627,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for RawJavaScriptCodeWithScopeRef<'a> {`
`627`	`627`	`}`
`628`	`628`	`}`
`629`	`629`
`630`		`-impl<'a> Serialize for RawJavaScriptCodeWithScopeRef<'a> {`
	`630`	`+impl Serialize for RawJavaScriptCodeWithScopeRef<'_> {`
`631`	`631`	`fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>`
`632`	`632`	`where`
`633`	`633`	`S: serde::Serializer,`
`@@ -667,7 +667,7 @@ impl<'de: 'a, 'a> Deserialize<'de> for RawDbPointerRef<'a> {`
`667`	`667`	`}`
`668`	`668`	`}`
`669`	`669`
`670`		`-impl<'a> Serialize for RawDbPointerRef<'a> {`
	`670`	`+impl Serialize for RawDbPointerRef<'_> {`
`671`	`671`	`fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>`
`672`	`672`	`where`
`673`	`673`	`S: serde::Serializer,`
Original file line number	Diff line number	Diff line change
`@@ -548,14 +548,14 @@ impl<'de: 'a, 'a> Deserialize<'de> for &'a RawDocument {`
`548`	`548`	`}`
`549`	`549`	`}`
`550`	`550`
`551`		`-impl<'a> Serialize for &'a RawDocument {`
	`551`	`+impl Serialize for &RawDocument {`
`552`	`552`	`fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>`
`553`	`553`	`where`
`554`	`554`	`S: serde::Serializer,`
`555`	`555`	`{`
`556`	`556`	`struct KvpSerializer<'a>(&'a RawDocument);`
`557`	`557`
`558`		`- impl<'a> Serialize for KvpSerializer<'a> {`
	`558`	`+ impl Serialize for KvpSerializer<'_> {`
`559`	`559`	`fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>`
`560`	`560`	`where`
`561`	`561`	`S: serde::Serializer,`
Original file line number	Diff line number	Diff line change
`@@ -268,7 +268,7 @@ impl std::fmt::Debug for RawDocumentBuf {`
`268`	`268`	`}`
`269`	`269`	`}`
`270`	`270`
`271`		`-impl<'a> From<RawDocumentBuf> for Cow<'a, RawDocument> {`
	`271`	`+impl From<RawDocumentBuf> for Cow<'_, RawDocument> {`
`272`	`272`	`fn from(rd: RawDocumentBuf) -> Self {`
`273`	`273`	`Cow::Owned(rd)`
`274`	`274`	`}`
Original file line number	Diff line number	Diff line change
`@@ -128,15 +128,15 @@ impl<'a> TryInto<RawBsonRef<'a>> for RawElement<'a> {`
`128`	`128`	`}`
`129`	`129`	`}`
`130`	`130`
`131`		`-impl<'a> TryInto<RawBson> for RawElement<'a> {`
	`131`	`+impl TryInto<RawBson> for RawElement<'_> {`
`132`	`132`	`type Error = Error;`
`133`	`133`
`134`	`134`	`fn try_into(self) -> Result<RawBson> {`
`135`	`135`	`Ok(self.value()?.to_raw_bson())`
`136`	`136`	`}`
`137`	`137`	`}`
`138`	`138`
`139`		`-impl<'a> TryInto<Bson> for RawElement<'a> {`
	`139`	`+impl TryInto<Bson> for RawElement<'_> {`
`140`	`140`	`type Error = Error;`
`141`	`141`
`142`	`142`	`fn try_into(self) -> Result<Bson> {`
`@@ -340,7 +340,7 @@ impl<'a> RawElement<'a> {`
`340`	`340`	`}`
`341`	`341`	`}`
`342`	`342`
`343`		`-impl<'a> RawIter<'a> {`
	`343`	`+impl RawIter<'_> {`
`344`	`344`	`fn get_next_length_at(&self, start_at: usize) -> Result<usize> {`
`345`	`345`	`let len = i32_from_slice(&self.doc.as_bytes()[start_at..])?;`
`346`	`346`	`if len < 0 {`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ impl<'a, 'de: 'a> Deserialize<'de> for OwnedOrBorrowedRawBson<'a> {`
`54`	`54`	`}`
`55`	`55`	`}`
`56`	`56`
`57`		`-impl<'a> Debug for OwnedOrBorrowedRawBson<'a> {`
	`57`	`+impl Debug for OwnedOrBorrowedRawBson<'_> {`
`58`	`58`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`59`	`59`	`match self {`
`60`	`60`	`Self::Owned(o) => o.fmt(f),`
`@@ -69,7 +69,7 @@ impl<'a> From<RawBsonRef<'a>> for OwnedOrBorrowedRawBson<'a> {`
`69`	`69`	`}`
`70`	`70`	`}`
`71`	`71`
`72`		`-impl<'a> From<RawBson> for OwnedOrBorrowedRawBson<'a> {`
	`72`	`+impl From<RawBson> for OwnedOrBorrowedRawBson<'_> {`
`73`	`73`	`fn from(b: RawBson) -> Self {`
`74`	`74`	`OwnedOrBorrowedRawBson::Owned(b)`
`75`	`75`	`}`
`@@ -82,7 +82,7 @@ pub(crate) enum OwnedOrBorrowedRawDocument<'a> {`
`82`	`82`	`Borrowed(&'a RawDocument),`
`83`	`83`	`}`
`84`	`84`
`85`		`-impl<'a> OwnedOrBorrowedRawDocument<'a> {`
	`85`	`+impl OwnedOrBorrowedRawDocument<'_> {`
`86`	`86`	`pub(crate) fn into_owned(self) -> RawDocumentBuf {`
`87`	`87`	`match self {`
`88`	`88`	`Self::Owned(o) => o,`
`@@ -91,7 +91,7 @@ impl<'a> OwnedOrBorrowedRawDocument<'a> {`
`91`	`91`	`}`
`92`	`92`	`}`
`93`	`93`
`94`		`-impl<'a> From<RawDocumentBuf> for OwnedOrBorrowedRawDocument<'a> {`
	`94`	`+impl From<RawDocumentBuf> for OwnedOrBorrowedRawDocument<'_> {`
`95`	`95`	`fn from(doc: RawDocumentBuf) -> Self {`
`96`	`96`	`Self::Owned(doc)`
`97`	`97`	`}`
`@@ -160,7 +160,7 @@ pub(crate) enum OwnedOrBorrowedRawArray<'a> {`
`160`	`160`	`Borrowed(&'a RawArray),`
`161`	`161`	`}`
`162`	`162`
`163`		`-impl<'a> OwnedOrBorrowedRawArray<'a> {`
	`163`	`+impl OwnedOrBorrowedRawArray<'_> {`
`164`	`164`	`pub(crate) fn into_owned(self) -> RawArrayBuf {`
`165`	`165`	`match self {`
`166`	`166`	`Self::Owned(o) => o,`
Original file line number	Diff line number	Diff line change
`@@ -82,7 +82,7 @@ pub(crate) struct SeededVisitor<'a, 'de> {`
`82`	`82`	`buffer: &'a mut CowByteBuffer<'de>,`
`83`	`83`	`}`
`84`	`84`
`85`		`-impl<'a, 'de> DeserializeSeed<'de> for SeededVisitor<'a, 'de> {`
	`85`	`+impl<'de> DeserializeSeed<'de> for SeededVisitor<'_, 'de> {`
`86`	`86`	`type Value = ElementType;`
`87`	`87`
`88`	`88`	`fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>`
`@@ -93,7 +93,7 @@ impl<'a, 'de> DeserializeSeed<'de> for SeededVisitor<'a, 'de> {`
`93`	`93`	`}`
`94`	`94`	`}`
`95`	`95`
`96`		`-impl<'a, 'de> DeserializeSeed<'de> for &mut SeededVisitor<'a, 'de> {`
	`96`	`+impl<'de> DeserializeSeed<'de> for &mut SeededVisitor<'_, 'de> {`
`97`	`97`	`type Value = ElementType;`
`98`	`98`
`99`	`99`	`fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>`
`@@ -233,7 +233,7 @@ impl<'a, 'de> SeededVisitor<'a, 'de> {`
`233`	`233`	`}`
`234`	`234`	`}`
`235`	`235`
`236`		`-impl<'a, 'de> Visitor<'de> for SeededVisitor<'a, 'de> {`
	`236`	`+impl<'de> Visitor<'de> for SeededVisitor<'_, 'de> {`
`237`	`237`	`type Value = ElementType;`
`238`	`238`
`239`	`239`	`fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {`