fix newly introduced clippy lints

conradludgate · conradludgate · commit 587d856bc2c0 · 2025-01-29T13:48:15.000Z
diff --git a/postgres-protocol/src/lib.rs b/postgres-protocol/src/lib.rs
@@ -68,7 +68,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
@@ -902,7 +902,7 @@ pub enum Format {
     Binary,
 }
 
-impl<'a, T> ToSql for &'a T
+impl<T> ToSql for &T
 where
     T: ToSql,
 {
@@ -951,7 +951,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,
@@ -992,7 +992,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)
@@ -1052,7 +1052,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)
     }
@@ -1076,7 +1076,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),
@@ -1097,7 +1097,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)
     }
@@ -1216,7 +1216,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)
@@ -1244,17 +1244,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/config.rs b/postgres/src/config.rs
@@ -44,6 +44,7 @@ use tokio_postgres::{Error, Socket};
 ///     e.g., 172.28.40.9. If your machine supports IPv6, you can also use those addresses.
 ///     If this parameter is not specified, the value of `host` will be looked up to find the corresponding IP address,
 ///     - or if host specifies an IP address, that value will be used directly.
+///
 ///     Using `hostaddr` allows the application to avoid a host name look-up, which might be important in applications
 ///     with time constraints. However, a host name is required for verify-full SSL certificate verification.
 ///     Specifically:
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
`@@ -902,7 +902,7 @@ pub enum Format {`
`902`	`902`	`Binary,`
`903`	`903`	`}`
`904`	`904`
`905`		`-impl<'a, T> ToSql for &'a T`
	`905`	`+impl<T> ToSql for &T`
`906`	`906`	`where`
`907`	`907`	`T: ToSql,`
`908`	`908`	`{`
`@@ -951,7 +951,7 @@ impl<T: ToSql> ToSql for Option<T> {`
`951`	`951`	`to_sql_checked!();`
`952`	`952`	`}`
`953`	`953`
`954`		`-impl<'a, T: ToSql> ToSql for &'a [T] {`
	`954`	`+impl<T: ToSql> ToSql for &[T] {`
`955`	`955`	`fn to_sql(&self, ty: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {`
`956`	`956`	`let member_type = match *ty.kind() {`
`957`	`957`	`Kind::Array(ref member) => member,`
`@@ -992,7 +992,7 @@ impl<'a, T: ToSql> ToSql for &'a [T] {`
`992`	`992`	`to_sql_checked!();`
`993`	`993`	`}`
`994`	`994`
`995`		`-impl<'a> ToSql for &'a [u8] {`
	`995`	`+impl ToSql for &[u8] {`
`996`	`996`	`fn to_sql(&self, _: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {`
`997`	`997`	`types::bytea_to_sql(self, w);`
`998`	`998`	`Ok(IsNull::No)`
`@@ -1052,7 +1052,7 @@ impl<T: ToSql> ToSql for Box<[T]> {`
`1052`	`1052`	`to_sql_checked!();`
`1053`	`1053`	`}`
`1054`	`1054`
`1055`		`-impl<'a> ToSql for Cow<'a, [u8]> {`
	`1055`	`+impl ToSql for Cow<'_, [u8]> {`
`1056`	`1056`	`fn to_sql(&self, ty: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {`
`1057`	`1057`	`<&[u8] as ToSql>::to_sql(&self.as_ref(), ty, w)`
`1058`	`1058`	`}`
`@@ -1076,7 +1076,7 @@ impl ToSql for Vec<u8> {`
`1076`	`1076`	`to_sql_checked!();`
`1077`	`1077`	`}`
`1078`	`1078`
`1079`		`-impl<'a> ToSql for &'a str {`
	`1079`	`+impl ToSql for &str {`
`1080`	`1080`	`fn to_sql(&self, ty: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {`
`1081`	`1081`	`match ty.name() {`
`1082`	`1082`	`"ltree" => types::ltree_to_sql(self, w),`
`@@ -1097,7 +1097,7 @@ impl<'a> ToSql for &'a str {`
`1097`	`1097`	`to_sql_checked!();`
`1098`	`1098`	`}`
`1099`	`1099`
`1100`		`-impl<'a> ToSql for Cow<'a, str> {`
	`1100`	`+impl ToSql for Cow<'_, str> {`
`1101`	`1101`	`fn to_sql(&self, ty: &Type, w: &mut BytesMut) -> Result<IsNull, Box<dyn Error + Sync + Send>> {`
`1102`	`1102`	`<&str as ToSql>::to_sql(&self.as_ref(), ty, w)`
`1103`	`1103`	`}`
`@@ -1216,7 +1216,7 @@ impl ToSql for IpAddr {`
`1216`	`1216`	`}`
`1217`	`1217`
`1218`	`1218`	`fn downcast(len: usize) -> Result<i32, Box<dyn Error + Sync + Send>> {`
`1219`		`- if len > i32::max_value() as usize {`
	`1219`	`+ if len > i32::MAX as usize {`
`1220`	`1220`	`Err("value too large to transmit".into())`
`1221`	`1221`	`} else {`
`1222`	`1222`	`Ok(len as i32)`
`@@ -1244,17 +1244,17 @@ impl BorrowToSql for &dyn ToSql {`
`1244`	`1244`	`}`
`1245`	`1245`	`}`
`1246`	`1246`
`1247`		`-impl<'a> sealed::Sealed for Box<dyn ToSql + Sync + 'a> {}`
	`1247`	`+impl sealed::Sealed for Box<dyn ToSql + Sync + '_> {}`
`1248`	`1248`
`1249`		`-impl<'a> BorrowToSql for Box<dyn ToSql + Sync + 'a> {`
	`1249`	`+impl BorrowToSql for Box<dyn ToSql + Sync + '_> {`
`1250`	`1250`	`#[inline]`
`1251`	`1251`	`fn borrow_to_sql(&self) -> &dyn ToSql {`
`1252`	`1252`	`self.as_ref()`
`1253`	`1253`	`}`
`1254`	`1254`	`}`
`1255`	`1255`
`1256`		`-impl<'a> sealed::Sealed for Box<dyn ToSql + Sync + Send + 'a> {}`
`1257`		`-impl<'a> BorrowToSql for Box<dyn ToSql + Sync + Send + 'a> {`
	`1256`	`+impl sealed::Sealed for Box<dyn ToSql + Sync + Send + '_> {}`
	`1257`	`+impl BorrowToSql for Box<dyn ToSql + Sync + Send + '_> {`
`1258`	`1258`	`#[inline]`
`1259`	`1259`	`fn borrow_to_sql(&self) -> &dyn ToSql {`
`1260`	`1260`	`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`