fix newly introduced clippy lints

conradludgate · conradludgate · commit 8b44892f7851 · 2025-01-29T15:07:53.000Z
diff --git a/postgres-protocol/src/lib.rs b/postgres-protocol/src/lib.rs
@@ -67,7 +67,7 @@ macro_rules! from_usize {
         impl FromUsize for $t {
             #[inline]
             fn from_usize(x: usize) -> io::Result<$t> {
-                if x > <$t>::max_value() as usize {
+                if x > <$t>::MAX as usize {
                     Err(io::Error::new(
                         io::ErrorKind::InvalidInput,
                         "value too large to transmit",
diff --git a/postgres-protocol/src/message/backend.rs b/postgres-protocol/src/message/backend.rs
@@ -591,7 +591,7 @@ pub struct ColumnFormats<'a> {
     remaining: u16,
 }
 
-impl<'a> FallibleIterator for ColumnFormats<'a> {
+impl FallibleIterator for ColumnFormats<'_> {
     type Item = u16;
     type Error = io::Error;
 
@@ -694,7 +694,7 @@ pub struct DataRowRanges<'a> {
     remaining: u16,
 }
 
-impl<'a> FallibleIterator for DataRowRanges<'a> {
+impl FallibleIterator for DataRowRanges<'_> {
     type Item = Option<Range<usize>>;
     type Error = io::Error;
 
@@ -782,7 +782,7 @@ pub struct ErrorField<'a> {
     value: &'a str,
 }
 
-impl<'a> ErrorField<'a> {
+impl ErrorField<'_> {
     #[inline]
     pub fn type_(&self) -> u8 {
         self.type_
@@ -848,7 +848,7 @@ pub struct Parameters<'a> {
     remaining: u16,
 }
 
-impl<'a> FallibleIterator for Parameters<'a> {
+impl FallibleIterator for Parameters<'_> {
     type Item = Oid;
     type Error = io::Error;
 
diff --git a/postgres-protocol/src/types/mod.rs b/postgres-protocol/src/types/mod.rs
@@ -582,7 +582,7 @@ impl<'a> Array<'a> {
 /// An iterator over the dimensions of an array.
 pub struct ArrayDimensions<'a>(&'a [u8]);
 
-impl<'a> FallibleIterator for ArrayDimensions<'a> {
+impl FallibleIterator for ArrayDimensions<'_> {
     type Item = ArrayDimension;
     type Error = StdBox<dyn Error + Sync + Send>;
 
@@ -950,7 +950,7 @@ pub struct PathPoints<'a> {
     buf: &'a [u8],
 }
 
-impl<'a> FallibleIterator for PathPoints<'a> {
+impl FallibleIterator for PathPoints<'_> {
     type Item = Point;
     type Error = StdBox<dyn Error + Sync + Send>;
 
diff --git a/postgres-protocol/src/types/test.rs b/postgres-protocol/src/types/test.rs
@@ -174,15 +174,15 @@ fn ltree_str() {
     let mut query = vec![1u8];
     query.extend_from_slice("A.B.C".as_bytes());
 
-    assert!(matches!(ltree_from_sql(query.as_slice()), Ok(_)))
+    assert!(ltree_from_sql(query.as_slice()).is_ok())
 }
 
 #[test]
 fn ltree_wrong_version() {
     let mut query = vec![2u8];
     query.extend_from_slice("A.B.C".as_bytes());
 
-    assert!(matches!(ltree_from_sql(query.as_slice()), Err(_)))
+    assert!(ltree_from_sql(query.as_slice()).is_err())
 }
 
 #[test]
@@ -202,15 +202,15 @@ fn lquery_str() {
     let mut query = vec![1u8];
     query.extend_from_slice("A.B.C".as_bytes());
 
-    assert!(matches!(lquery_from_sql(query.as_slice()), Ok(_)))
+    assert!(lquery_from_sql(query.as_slice()).is_ok())
 }
 
 #[test]
 fn lquery_wrong_version() {
     let mut query = vec![2u8];
     query.extend_from_slice("A.B.C".as_bytes());
 
-    assert!(matches!(lquery_from_sql(query.as_slice()), Err(_)))
+    assert!(lquery_from_sql(query.as_slice()).is_err())
 }
 
 #[test]
@@ -230,13 +230,13 @@ fn ltxtquery_str() {
     let mut query = vec![1u8];
     query.extend_from_slice("a & b*".as_bytes());
 
-    assert!(matches!(ltree_from_sql(query.as_slice()), Ok(_)))
+    assert!(ltree_from_sql(query.as_slice()).is_ok())
 }
 
 #[test]
 fn ltxtquery_wrong_version() {
     let mut query = vec![2u8];
     query.extend_from_slice("a & b*".as_bytes());
 
-    assert!(matches!(ltree_from_sql(query.as_slice()), Err(_)))
+    assert!(ltree_from_sql(query.as_slice()).is_err())
 }
diff --git a/postgres-types/Cargo.toml b/postgres-types/Cargo.toml
@@ -11,6 +11,7 @@ keywords = ["database", "postgres", "postgresql", "sql"]
 categories = ["database"]
 
 [features]
+default = ["with-chrono-0_4"]
 derive = ["postgres-derive"]
 array-impls = ["array-init"]
 with-bit-vec-0_6 = ["bit-vec-06"]
diff --git a/postgres-types/src/chrono_04.rs b/postgres-types/src/chrono_04.rs
@@ -14,7 +14,7 @@ fn base() -> NaiveDateTime {
         .unwrap()
 }
 
-impl<'a> FromSql<'a> for NaiveDateTime {
+impl FromSql<'_> for NaiveDateTime {
     fn from_sql(_: &Type, raw: &[u8]) -> Result<NaiveDateTime, Box<dyn Error + Sync + Send>> {
         let t = types::timestamp_from_sql(raw)?;
         base()
@@ -39,7 +39,7 @@ impl ToSql for NaiveDateTime {
     to_sql_checked!();
 }
 
-impl<'a> FromSql<'a> for DateTime<Utc> {
+impl FromSql<'_> for DateTime<Utc> {
     fn from_sql(type_: &Type, raw: &[u8]) -> Result<DateTime<Utc>, Box<dyn Error + Sync + Send>> {
         let naive = NaiveDateTime::from_sql(type_, raw)?;
         Ok(Utc.from_utc_datetime(&naive))
@@ -61,7 +61,7 @@ impl ToSql for DateTime<Utc> {
     to_sql_checked!();
 }
 
-impl<'a> FromSql<'a> for DateTime<Local> {
+impl FromSql<'_> for DateTime<Local> {
     fn from_sql(type_: &Type, raw: &[u8]) -> Result<DateTime<Local>, Box<dyn Error + Sync + Send>> {
         let utc = DateTime::<Utc>::from_sql(type_, raw)?;
         Ok(utc.with_timezone(&Local))
@@ -83,7 +83,7 @@ impl ToSql for DateTime<Local> {
     to_sql_checked!();
 }
 
-impl<'a> FromSql<'a> for DateTime<FixedOffset> {
+impl FromSql<'_> for DateTime<FixedOffset> {
     fn from_sql(
         type_: &Type,
         raw: &[u8],
@@ -108,7 +108,7 @@ impl ToSql for DateTime<FixedOffset> {
     to_sql_checked!();
 }
 
-impl<'a> FromSql<'a> for NaiveDate {
+impl FromSql<'_> for NaiveDate {
     fn from_sql(_: &Type, raw: &[u8]) -> Result<NaiveDate, Box<dyn Error + Sync + Send>> {
         let jd = types::date_from_sql(raw)?;
         base()
@@ -123,7 +123,7 @@ impl<'a> FromSql<'a> for NaiveDate {
 impl ToSql for NaiveDate {
     fn to_sql(&self, _: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
         let jd = self.signed_duration_since(base().date()).num_days();
-        if jd > i64::from(i32::max_value()) || jd < i64::from(i32::min_value()) {
+        if jd > i64::from(i32::MAX) || jd < i64::from(i32::MIN) {
             return Err("value too large to transmit".into());
         }
 
@@ -135,7 +135,7 @@ impl ToSql for NaiveDate {
     to_sql_checked!();
 }
 
-impl<'a> FromSql<'a> for NaiveTime {
+impl FromSql<'_> for NaiveTime {
     fn from_sql(_: &Type, raw: &[u8]) -> Result<NaiveTime, Box<dyn Error + Sync + Send>> {
         let usec = types::time_from_sql(raw)?;
         Ok(NaiveTime::from_hms_opt(0, 0, 0).unwrap() + Duration::microseconds(usec))
diff --git a/postgres-types/src/lib.rs b/postgres-types/src/lib.rs
@@ -901,7 +901,7 @@ pub enum Format {
     Binary,
 }
 
-impl<'a, T> ToSql for &'a T
+impl<T> ToSql for &T
 where
     T: ToSql,
 {
@@ -950,7 +950,7 @@ impl<T: ToSql> ToSql for Option<T> {
     to_sql_checked!();
 }
 
-impl<'a, T: ToSql> ToSql for &'a [T] {
+impl<T: ToSql> ToSql for &[T] {
     fn to_sql(&self, ty: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
         let member_type = match *ty.kind() {
             Kind::Array(ref member) => member,
@@ -991,7 +991,7 @@ impl<'a, T: ToSql> ToSql for &'a [T] {
     to_sql_checked!();
 }
 
-impl<'a> ToSql for &'a [u8] {
+impl ToSql for &[u8] {
     fn to_sql(&self, _: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
         types::bytea_to_sql(self, w);
         Ok(IsNull::No)
@@ -1051,7 +1051,7 @@ impl<T: ToSql> ToSql for Box<[T]> {
     to_sql_checked!();
 }
 
-impl<'a> ToSql for Cow<'a, [u8]> {
+impl ToSql for Cow<'_, [u8]> {
     fn to_sql(&self, ty: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
         <&[u8] as ToSql>::to_sql(&self.as_ref(), ty, w)
     }
@@ -1075,7 +1075,7 @@ impl ToSql for Vec<u8> {
     to_sql_checked!();
 }
 
-impl<'a> ToSql for &'a str {
+impl ToSql for &str {
     fn to_sql(&self, ty: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
         match ty.name() {
             "ltree" => types::ltree_to_sql(self, w),
@@ -1096,7 +1096,7 @@ impl<'a> ToSql for &'a str {
     to_sql_checked!();
 }
 
-impl<'a> ToSql for Cow<'a, str> {
+impl ToSql for Cow<'_, str> {
     fn to_sql(&self, ty: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {
         <&str as ToSql>::to_sql(&self.as_ref(), ty, w)
     }
@@ -1215,7 +1215,7 @@ impl ToSql for IpAddr {
 }
 
 fn downcast(len: usize) -> Result<i32, Box<dyn Error + Sync + Send>> {
-    if len > i32::max_value() as usize {
+    if len > i32::MAX as usize {
         Err("value too large to transmit".into())
     } else {
         Ok(len as i32)
@@ -1243,17 +1243,17 @@ impl BorrowToSql for &dyn ToSql {
     }
 }
 
-impl<'a> sealed::Sealed for Box<dyn ToSql + Sync + 'a> {}
+impl sealed::Sealed for Box<dyn ToSql + Sync + '_> {}
 
-impl<'a> BorrowToSql for Box<dyn ToSql + Sync + 'a> {
+impl BorrowToSql for Box<dyn ToSql + Sync + '_> {
     #[inline]
     fn borrow_to_sql(&self) -> &dyn ToSql {
         self.as_ref()
     }
 }
 
-impl<'a> sealed::Sealed for Box<dyn ToSql + Sync + Send + 'a> {}
-impl<'a> BorrowToSql for Box<dyn ToSql + Sync + Send + 'a> {
+impl sealed::Sealed for Box<dyn ToSql + Sync + Send + '_> {}
+impl BorrowToSql for Box<dyn ToSql + Sync + Send + '_> {
     #[inline]
     fn borrow_to_sql(&self) -> &dyn ToSql {
         self.as_ref()
diff --git a/postgres-types/src/special.rs b/postgres-types/src/special.rs
@@ -1,7 +1,6 @@
 use bytes::BytesMut;
 use postgres_protocol::types;
 use std::error::Error;
-use std::{i32, i64};
 
 use crate::{FromSql, IsNull, ToSql, Type};
 
diff --git a/postgres/src/notifications.rs b/postgres/src/notifications.rs
@@ -77,7 +77,7 @@ pub struct Iter<'a> {
     connection: ConnectionRef<'a>,
 }
 
-impl<'a> FallibleIterator for Iter<'a> {
+impl FallibleIterator for Iter<'_> {
     type Item = Notification;
     type Error = Error;
 
@@ -100,7 +100,7 @@ pub struct BlockingIter<'a> {
     connection: ConnectionRef<'a>,
 }
 
-impl<'a> FallibleIterator for BlockingIter<'a> {
+impl FallibleIterator for BlockingIter<'_> {
     type Item = Notification;
     type Error = Error;
 
@@ -129,7 +129,7 @@ pub struct TimeoutIter<'a> {
     timeout: Duration,
 }
 
-impl<'a> FallibleIterator for TimeoutIter<'a> {
+impl FallibleIterator for TimeoutIter<'_> {
     type Item = Notification;
     type Error = Error;
 
diff --git a/postgres/src/transaction.rs b/postgres/src/transaction.rs
@@ -12,7 +12,7 @@ pub struct Transaction<'a> {
     transaction: Option<tokio_postgres::Transaction<'a>>,
 }
 
-impl<'a> Drop for Transaction<'a> {
+impl Drop for Transaction<'_> {
     fn drop(&mut self) {
         if let Some(transaction) = self.transaction.take() {
             let _ = self.connection.block_on(transaction.rollback());
diff --git a/tokio-postgres/src/client.rs b/tokio-postgres/src/client.rs
@@ -502,7 +502,7 @@ impl Client {
             done: bool,
         }
 
-        impl<'a> Drop for RollbackIfNotDone<'a> {
+        impl Drop for RollbackIfNotDone<'_> {
             fn drop(&mut self) {
                 if self.done {
                     return;
diff --git a/tokio-postgres/src/query.rs b/tokio-postgres/src/query.rs
@@ -16,7 +16,7 @@ use std::task::{Context, Poll};
 
 struct BorrowToSqlParamsDebug<'a, T>(&'a [T]);
 
-impl<'a, T> fmt::Debug for BorrowToSqlParamsDebug<'a, T>
+impl<T> fmt::Debug for BorrowToSqlParamsDebug<'_, T>
 where
     T: BorrowToSql,
 {
diff --git a/tokio-postgres/src/row.rs b/tokio-postgres/src/row.rs
@@ -79,9 +79,9 @@ impl RowIndex for str {
     }
 }
 
-impl<'a, T> Sealed for &'a T where T: ?Sized + Sealed {}
+impl<T> Sealed for &T where T: ?Sized + Sealed {}
 
-impl<'a, T> RowIndex for &'a T
+impl<T> RowIndex for &T
 where
     T: ?Sized + RowIndex,
 {
diff --git a/tokio-postgres/src/to_statement.rs b/tokio-postgres/src/to_statement.rs
@@ -11,7 +11,7 @@ mod private {
         Query(&'a str),
     }
 
-    impl<'a> ToStatementType<'a> {
+    impl ToStatementType<'_> {
         pub async fn into_statement(self, client: &Client) -> Result<Statement, Error> {
             match self {
                 ToStatementType::Statement(s) => Ok(s.clone()),
diff --git a/tokio-postgres/src/transaction.rs b/tokio-postgres/src/transaction.rs
@@ -33,7 +33,7 @@ struct Savepoint {
     depth: u32,
 }
 
-impl<'a> Drop for Transaction<'a> {
+impl Drop for Transaction<'_> {
     fn drop(&mut self) {
         if self.done {
             return;
diff --git a/tokio-postgres/tests/test/main.rs b/tokio-postgres/tests/test/main.rs
@@ -330,7 +330,7 @@ async fn simple_query() {
     }
     match &messages[2] {
         SimpleQueryMessage::Row(row) => {
-            assert_eq!(row.columns().get(0).map(|c| c.name()), Some("id"));
+            assert_eq!(row.columns().first().map(|c| c.name()), Some("id"));
             assert_eq!(row.columns().get(1).map(|c| c.name()), Some("name"));
             assert_eq!(row.get(0), Some("1"));
             assert_eq!(row.get(1), Some("steven"));
@@ -339,7 +339,7 @@ async fn simple_query() {
     }
     match &messages[3] {
         SimpleQueryMessage::Row(row) => {
-            assert_eq!(row.columns().get(0).map(|c| c.name()), Some("id"));
+            assert_eq!(row.columns().first().map(|c| c.name()), Some("id"));
             assert_eq!(row.columns().get(1).map(|c| c.name()), Some("name"));
             assert_eq!(row.get(0), Some("2"));
             assert_eq!(row.get(1), Some("joe"));
diff --git a/tokio-postgres/tests/test/types/mod.rs b/tokio-postgres/tests/test/types/mod.rs
@@ -509,7 +509,7 @@ async fn domain() {
         to_sql_checked!();
     }
 
-    impl<'a> FromSql<'a> for SessionId {
+    impl FromSql<'_> for SessionId {
         fn from_sql(ty: &Type, raw: &[u8]) -> result::Result<Self, Box<dyn Error + Sync + Send>> {
             Vec::<u8>::from_sql(ty, raw).map(SessionId)
         }

Original file line number	Diff line number	Diff line change
`@@ -901,7 +901,7 @@ pub enum Format {`
`901`	`901`	`Binary,`
`902`	`902`	`}`
`903`	`903`
`904`		`-impl<'a, T> ToSql for &'a T`
	`904`	`+impl<T> ToSql for &T`
`905`	`905`	`where`
`906`	`906`	`T: ToSql,`
`907`	`907`	`{`
`@@ -950,7 +950,7 @@ impl<T: ToSql> ToSql for Option<T> {`
`950`	`950`	`to_sql_checked!();`
`951`	`951`	`}`
`952`	`952`
`953`		`-impl<'a, T: ToSql> ToSql for &'a [T] {`
	`953`	`+impl<T: ToSql> ToSql for &[T] {`
`954`	`954`	`fn to_sql(&self, ty: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {`
`955`	`955`	`let member_type = match *ty.kind() {`
`956`	`956`	`Kind::Array(ref member) => member,`
`@@ -991,7 +991,7 @@ impl<'a, T: ToSql> ToSql for &'a [T] {`
`991`	`991`	`to_sql_checked!();`
`992`	`992`	`}`
`993`	`993`
`994`		`-impl<'a> ToSql for &'a [u8] {`
	`994`	`+impl ToSql for &[u8] {`
`995`	`995`	`fn to_sql(&self, _: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {`
`996`	`996`	`types::bytea_to_sql(self, w);`
`997`	`997`	`Ok(IsNull::No)`
`@@ -1051,7 +1051,7 @@ impl<T: ToSql> ToSql for Box<[T]> {`
`1051`	`1051`	`to_sql_checked!();`
`1052`	`1052`	`}`
`1053`	`1053`
`1054`		`-impl<'a> ToSql for Cow<'a, [u8]> {`
	`1054`	`+impl ToSql for Cow<'_, [u8]> {`
`1055`	`1055`	`fn to_sql(&self, ty: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {`
`1056`	`1056`	`<&[u8] as ToSql>::to_sql(&self.as_ref(), ty, w)`
`1057`	`1057`	`}`
`@@ -1075,7 +1075,7 @@ impl ToSql for Vec<u8> {`
`1075`	`1075`	`to_sql_checked!();`
`1076`	`1076`	`}`
`1077`	`1077`
`1078`		`-impl<'a> ToSql for &'a str {`
	`1078`	`+impl ToSql for &str {`
`1079`	`1079`	`fn to_sql(&self, ty: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {`
`1080`	`1080`	`match ty.name() {`
`1081`	`1081`	`"ltree" => types::ltree_to_sql(self, w),`
`@@ -1096,7 +1096,7 @@ impl<'a> ToSql for &'a str {`
`1096`	`1096`	`to_sql_checked!();`
`1097`	`1097`	`}`
`1098`	`1098`
`1099`		`-impl<'a> ToSql for Cow<'a, str> {`
	`1099`	`+impl ToSql for Cow<'_, str> {`
`1100`	`1100`	`fn to_sql(&self, ty: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {`
`1101`	`1101`	`<&str as ToSql>::to_sql(&self.as_ref(), ty, w)`
`1102`	`1102`	`}`
`@@ -1215,7 +1215,7 @@ impl ToSql for IpAddr {`
`1215`	`1215`	`}`
`1216`	`1216`
`1217`	`1217`	`fn downcast(len: usize) -> Result<i32, Box<dyn Error + Sync + Send>> {`
`1218`		`- if len > i32::max_value() as usize {`
	`1218`	`+ if len > i32::MAX as usize {`
`1219`	`1219`	`Err("value too large to transmit".into())`
`1220`	`1220`	`} else {`
`1221`	`1221`	`Ok(len as i32)`
`@@ -1243,17 +1243,17 @@ impl BorrowToSql for &dyn ToSql {`
`1243`	`1243`	`}`
`1244`	`1244`	`}`
`1245`	`1245`
`1246`		`-impl<'a> sealed::Sealed for Box<dyn ToSql + Sync + 'a> {}`
	`1246`	`+impl sealed::Sealed for Box<dyn ToSql + Sync + '_> {}`
`1247`	`1247`
`1248`		`-impl<'a> BorrowToSql for Box<dyn ToSql + Sync + 'a> {`
	`1248`	`+impl BorrowToSql for Box<dyn ToSql + Sync + '_> {`
`1249`	`1249`	`#[inline]`
`1250`	`1250`	`fn borrow_to_sql(&self) -> &dyn ToSql {`
`1251`	`1251`	`self.as_ref()`
`1252`	`1252`	`}`
`1253`	`1253`	`}`
`1254`	`1254`
`1255`		`-impl<'a> sealed::Sealed for Box<dyn ToSql + Sync + Send + 'a> {}`
`1256`		`-impl<'a> BorrowToSql for Box<dyn ToSql + Sync + Send + 'a> {`
	`1255`	`+impl sealed::Sealed for Box<dyn ToSql + Sync + Send + '_> {}`
	`1256`	`+impl BorrowToSql for Box<dyn ToSql + Sync + Send + '_> {`
`1257`	`1257`	`#[inline]`
`1258`	`1258`	`fn borrow_to_sql(&self) -> &dyn ToSql {`
`1259`	`1259`	`self.as_ref()`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ pub struct Iter<'a> {`
`77`	`77`	`connection: ConnectionRef<'a>,`
`78`	`78`	`}`
`79`	`79`
`80`		`-impl<'a> FallibleIterator for Iter<'a> {`
	`80`	`+impl FallibleIterator for Iter<'_> {`
`81`	`81`	`type Item = Notification;`
`82`	`82`	`type Error = Error;`
`83`	`83`
`@@ -100,7 +100,7 @@ pub struct BlockingIter<'a> {`
`100`	`100`	`connection: ConnectionRef<'a>,`
`101`	`101`	`}`
`102`	`102`
`103`		`-impl<'a> FallibleIterator for BlockingIter<'a> {`
	`103`	`+impl FallibleIterator for BlockingIter<'_> {`
`104`	`104`	`type Item = Notification;`
`105`	`105`	`type Error = Error;`
`106`	`106`
`@@ -129,7 +129,7 @@ pub struct TimeoutIter<'a> {`
`129`	`129`	`timeout: Duration,`
`130`	`130`	`}`
`131`	`131`
`132`		`-impl<'a> FallibleIterator for TimeoutIter<'a> {`
	`132`	`+impl FallibleIterator for TimeoutIter<'_> {`
`133`	`133`	`type Item = Notification;`
`134`	`134`	`type Error = Error;`
`135`	`135`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ pub struct Transaction<'a> {`
`12`	`12`	`transaction: Option<tokio_postgres::Transaction<'a>>,`
`13`	`13`	`}`
`14`	`14`
`15`		`-impl<'a> Drop for Transaction<'a> {`
	`15`	`+impl Drop for Transaction<'_> {`
`16`	`16`	`fn drop(&mut self) {`
`17`	`17`	`if let Some(transaction) = self.transaction.take() {`
`18`	`18`	`let _ = self.connection.block_on(transaction.rollback());`
Original file line number	Diff line number	Diff line change
`@@ -502,7 +502,7 @@ impl Client {`
`502`	`502`	`done: bool,`
`503`	`503`	`}`
`504`	`504`
`505`		`- impl<'a> Drop for RollbackIfNotDone<'a> {`
	`505`	`+ impl Drop for RollbackIfNotDone<'_> {`
`506`	`506`	`fn drop(&mut self) {`
`507`	`507`	`if self.done {`
`508`	`508`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ use std::task::{Context, Poll};`
`16`	`16`
`17`	`17`	`struct BorrowToSqlParamsDebug<'a, T>(&'a [T]);`
`18`	`18`
`19`		`-impl<'a, T> fmt::Debug for BorrowToSqlParamsDebug<'a, T>`
	`19`	`+impl<T> fmt::Debug for BorrowToSqlParamsDebug<'_, T>`
`20`	`20`	`where`
`21`	`21`	`T: BorrowToSql,`
`22`	`22`	`{`
Original file line number	Diff line number	Diff line change
`@@ -79,9 +79,9 @@ impl RowIndex for str {`
`79`	`79`	`}`
`80`	`80`	`}`
`81`	`81`
`82`		`-impl<'a, T> Sealed for &'a T where T: ?Sized + Sealed {}`
	`82`	`+impl<T> Sealed for &T where T: ?Sized + Sealed {}`
`83`	`83`
`84`		`-impl<'a, T> RowIndex for &'a T`
	`84`	`+impl<T> RowIndex for &T`
`85`	`85`	`where`
`86`	`86`	`T: ?Sized + RowIndex,`
`87`	`87`	`{`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ mod private {`
`11`	`11`	`Query(&'a str),`
`12`	`12`	`}`
`13`	`13`
`14`		`- impl<'a> ToStatementType<'a> {`
	`14`	`+ impl ToStatementType<'_> {`
`15`	`15`	`pub async fn into_statement(self, client: &Client) -> Result<Statement, Error> {`
`16`	`16`	`match self {`
`17`	`17`	`ToStatementType::Statement(s) => Ok(s.clone()),`
Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,7 @@ struct Savepoint {`
`33`	`33`	`depth: u32,`
`34`	`34`	`}`
`35`	`35`
`36`		`-impl<'a> Drop for Transaction<'a> {`
	`36`	`+impl Drop for Transaction<'_> {`
`37`	`37`	`fn drop(&mut self) {`
`38`	`38`	`if self.done {`
`39`	`39`	`return;`
Original file line number	Diff line number	Diff line change
`@@ -509,7 +509,7 @@ async fn domain() {`
`509`	`509`	`to_sql_checked!();`
`510`	`510`	`}`
`511`	`511`
`512`		`- impl<'a> FromSql<'a> for SessionId {`
	`512`	`+ impl FromSql<'_> for SessionId {`
`513`	`513`	`fn from_sql(ty: &Type, raw: &[u8]) -> result::Result<Self, Box<dyn Error + Sync + Send>> {`
`514`	`514`	`Vec::<u8>::from_sql(ty, raw).map(SessionId)`
`515`	`515`	`}`