Bump rustversion to 1.83 and fix new clippy lints

diesel/src/associations/mod.rs

@@ -369,7 +369,7 @@ pub trait HasTable {
     fn table() -> Self::Table;
 }
 
-impl<'a, T: HasTable> HasTable for &'a T {
+impl<T: HasTable> HasTable for &T {
     type Table = T::Table;
 
     fn table() -> Self::Table {

diesel/src/connection/instrumentation.rs

@@ -173,6 +173,7 @@ pub enum InstrumentationEvent<'a> {
 // these constructors exist to
 // keep `#[non_exhaustive]` on all the variants
 // and to gate the constructors on the unstable feature
+#[cfg(feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes")]
 impl<'a> InstrumentationEvent<'a> {
     /// Create a new `InstrumentationEvent::StartEstablishConnection` event
     #[cfg(feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes")]
@@ -351,6 +352,7 @@ impl DerefMut for DynInstrumentation {
 }
 
 impl DynInstrumentation {
+    /// Create a instance of the default instrumentation provider
     #[diesel_derives::__diesel_public_if(
         feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
     )]
@@ -361,6 +363,7 @@ impl DynInstrumentation {
         }
     }
 
+    /// Create a noop instrumentation provider instance
     #[diesel_derives::__diesel_public_if(
         feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
     )]
@@ -371,6 +374,7 @@ impl DynInstrumentation {
         }
     }
 
+    /// register an event with the given instrumentation implementation
     #[diesel_derives::__diesel_public_if(
         feature = "i-implement-a-third-party-backend-and-opt-into-breaking-changes"
     )]

diesel/src/connection/mod.rs

@@ -601,6 +601,9 @@ pub(crate) mod private {
     where
         T: super::LoadConnection<B>,
     {
-        type Cursor<'conn, 'query> = <T as super::LoadConnection<B>>::Cursor<'conn, 'query> where T: 'conn;
+        type Cursor<'conn, 'query>
+            = <T as super::LoadConnection<B>>::Cursor<'conn, 'query>
+        where
+            T: 'conn;
     }
 }

diesel/src/connection/statement_cache/mod.rs

@@ -303,7 +303,7 @@ pub enum MaybeCached<'a, T: 'a> {
     Cached(&'a mut T),
 }
 
-impl<'a, T> Deref for MaybeCached<'a, T> {
+impl<T> Deref for MaybeCached<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
@@ -314,7 +314,7 @@ impl<'a, T> Deref for MaybeCached<'a, T> {
     }
 }
 
-impl<'a, T> DerefMut for MaybeCached<'a, T> {
+impl<T> DerefMut for MaybeCached<'_, T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         match *self {
             MaybeCached::CannotCache(ref mut x) => x,

diesel/src/expression/mod.rs

@@ -161,7 +161,7 @@ impl<T: Expression + ?Sized> Expression for Box<T> {
     type SqlType = T::SqlType;
 }
 
-impl<'a, T: Expression + ?Sized> Expression for &'a T {
+impl<T: Expression + ?Sized> Expression for &T {
     type SqlType = T::SqlType;
 }
 
@@ -701,7 +701,7 @@ impl<T: ValidGrouping<GB> + ?Sized, GB> ValidGrouping<GB> for Box<T> {
     type IsAggregate = T::IsAggregate;
 }
 
-impl<'a, T: ValidGrouping<GB> + ?Sized, GB> ValidGrouping<GB> for &'a T {
+impl<T: ValidGrouping<GB> + ?Sized, GB> ValidGrouping<GB> for &T {
     type IsAggregate = T::IsAggregate;
 }
 
@@ -1030,16 +1030,16 @@ where
 {
 }
 
-impl<'a, QS, ST, DB, GB, IsAggregate> QueryId
-    for dyn BoxableExpression<QS, DB, GB, IsAggregate, SqlType = ST> + 'a
+impl<QS, ST, DB, GB, IsAggregate> QueryId
+    for dyn BoxableExpression<QS, DB, GB, IsAggregate, SqlType = ST> + '_
 {
     type QueryId = ();
 
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a, QS, ST, DB, GB, IsAggregate> ValidGrouping<GB>
-    for dyn BoxableExpression<QS, DB, GB, IsAggregate, SqlType = ST> + 'a
+impl<QS, ST, DB, GB, IsAggregate> ValidGrouping<GB>
+    for dyn BoxableExpression<QS, DB, GB, IsAggregate, SqlType = ST> + '_
 {
     type IsAggregate = IsAggregate;
 }

diesel/src/insertable.rs

@@ -86,7 +86,7 @@ pub trait CanInsertInSingleQuery<DB: Backend> {
     fn rows_to_insert(&self) -> Option<usize>;
 }
 
-impl<'a, T, DB> CanInsertInSingleQuery<DB> for &'a T
+impl<T, DB> CanInsertInSingleQuery<DB> for &T
 where
     T: ?Sized + CanInsertInSingleQuery<DB>,
     DB: Backend,

diesel/src/migration/mod.rs

@@ -24,15 +24,15 @@ pub type Result<T> = std::result::Result<T, Box<dyn Error + Send + Sync>>;
 #[diesel(sql_type = Text)]
 pub struct MigrationVersion<'a>(Cow<'a, str>);
 
-impl<'a> MigrationVersion<'a> {
+impl MigrationVersion<'_> {
     /// Convert the current migration version into
     /// an owned variant with static life time
     pub fn as_owned(&self) -> MigrationVersion<'static> {
         MigrationVersion(Cow::Owned(self.0.as_ref().to_owned()))
     }
 }
 
-impl<'a, DB> FromSql<Text, DB> for MigrationVersion<'a>
+impl<DB> FromSql<Text, DB> for MigrationVersion<'_>
 where
     String: FromSql<Text, DB>,
     DB: Backend,
@@ -56,7 +56,7 @@ where
     }
 }
 
-impl<'a> From<String> for MigrationVersion<'a> {
+impl From<String> for MigrationVersion<'_> {
     fn from(s: String) -> Self {
         MigrationVersion(Cow::Owned(s))
     }
@@ -74,7 +74,7 @@ impl<'a> From<&'a String> for MigrationVersion<'a> {
     }
 }
 
-impl<'a> Display for MigrationVersion<'a> {
+impl Display for MigrationVersion<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str(self.0.as_ref())
     }
@@ -140,7 +140,7 @@ pub trait MigrationSource<DB: Backend> {
     fn migrations(&self) -> Result<Vec<Box<dyn Migration<DB>>>>;
 }
 
-impl<'a, DB: Backend> Migration<DB> for Box<dyn Migration<DB> + 'a> {
+impl<DB: Backend> Migration<DB> for Box<dyn Migration<DB> + '_> {
     fn run(&self, conn: &mut dyn BoxableConnection<DB>) -> Result<()> {
         (**self).run(conn)
     }
@@ -158,7 +158,7 @@ impl<'a, DB: Backend> Migration<DB> for Box<dyn Migration<DB> + 'a> {
     }
 }
 
-impl<'a, DB: Backend> Migration<DB> for &'a dyn Migration<DB> {
+impl<DB: Backend> Migration<DB> for &dyn Migration<DB> {
     fn run(&self, conn: &mut dyn BoxableConnection<DB>) -> Result<()> {
         (**self).run(conn)
     }

diesel/src/mysql/connection/raw.rs

@@ -39,7 +39,7 @@ impl RawConnection {
             ffi::mysql_options(
                 result.0.as_ptr(),
                 ffi::mysql_option::MYSQL_SET_CHARSET_NAME,
-                b"utf8mb4\0".as_ptr() as *const libc::c_void,
+                c"utf8mb4".as_ptr() as *const libc::c_void,
             )
         };
         assert_eq!(

diesel/src/mysql/connection/stmt/iterator.rs

@@ -38,7 +38,7 @@ impl<'a> StatementIterator<'a> {
     }
 }
 
-impl<'a> Iterator for StatementIterator<'a> {
+impl Iterator for StatementIterator<'_> {
     type Item = QueryResult<MysqlRow>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -125,7 +125,7 @@ impl<'a> Iterator for StatementIterator<'a> {
     }
 }
 
-impl<'a> ExactSizeIterator for StatementIterator<'a> {
+impl ExactSizeIterator for StatementIterator<'_> {
     fn len(&self) -> usize {
         self.len
     }
@@ -154,7 +154,11 @@ impl PrivateMysqlRow {
 impl RowSealed for MysqlRow {}
 
 impl<'a> Row<'a, Mysql> for MysqlRow {
-    type Field<'f> = MysqlField<'f> where 'a: 'f, Self: 'f;
+    type Field<'f>
+        = MysqlField<'f>
+    where
+        'a: 'f,
+        Self: 'f;
     type InnerPartialRow = Self;
 
     fn field_count(&self) -> usize {

diesel/src/mysql/connection/stmt/metadata.rs

@@ -40,7 +40,7 @@ pub(in crate::mysql::connection) struct MysqlFieldMetadata<'a>(
     std::marker::PhantomData<&'a ()>,
 );
 
-impl<'a> MysqlFieldMetadata<'a> {
+impl MysqlFieldMetadata<'_> {
     pub(in crate::mysql::connection) fn field_name(&self) -> Option<&str> {
         if self.0.name.is_null() {
             None

diesel/src/mysql/connection/stmt/mod.rs

@@ -152,7 +152,7 @@ pub(super) struct StatementUse<'a> {
     inner: MaybeCached<'a, Statement>,
 }
 
-impl<'a> StatementUse<'a> {
+impl StatementUse<'_> {
     pub(in crate::mysql::connection) fn affected_rows(&self) -> QueryResult<usize> {
         let affected_rows = unsafe { ffi::mysql_stmt_affected_rows(self.inner.stmt.as_ptr()) };
         affected_rows
@@ -211,7 +211,7 @@ impl<'a> StatementUse<'a> {
     }
 }
 
-impl<'a> Drop for StatementUse<'a> {
+impl Drop for StatementUse<'_> {
     fn drop(&mut self) {
         unsafe {
             ffi::mysql_stmt_free_result(self.inner.stmt.as_ptr());

diesel/src/mysql/query_builder/limit_offset.rs

@@ -33,7 +33,7 @@ where
     }
 }
 
-impl<'a> QueryFragment<Mysql> for BoxedLimitOffsetClause<'a, Mysql> {
+impl QueryFragment<Mysql> for BoxedLimitOffsetClause<'_, Mysql> {
     fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Mysql>) -> QueryResult<()> {
         match (self.limit.as_ref(), self.offset.as_ref()) {
             (Some(limit), Some(offset)) => {

diesel/src/pg/connection/copy.rs

@@ -22,7 +22,7 @@ impl<'conn> CopyFromSink<'conn> {
     }
 }
 
-impl<'conn> Write for CopyFromSink<'conn> {
+impl Write for CopyFromSink<'_> {
     fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
         self.conn
             .put_copy_data(buf)
@@ -70,7 +70,7 @@ impl<'conn> CopyToBuffer<'conn> {
     }
 }
 
-impl<'conn> Drop for CopyToBuffer<'conn> {
+impl Drop for CopyToBuffer<'_> {
     #[allow(unsafe_code)] // ffi code
     fn drop(&mut self) {
         if !self.ptr.is_null() {
@@ -80,7 +80,7 @@ impl<'conn> Drop for CopyToBuffer<'conn> {
     }
 }
 
-impl<'conn> Read for CopyToBuffer<'conn> {
+impl Read for CopyToBuffer<'_> {
     fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
         let data = self.fill_buf()?;
         let len = usize::min(buf.len(), data.len());
@@ -90,7 +90,7 @@ impl<'conn> Read for CopyToBuffer<'conn> {
     }
 }
 
-impl<'conn> BufRead for CopyToBuffer<'conn> {
+impl BufRead for CopyToBuffer<'_> {
     #[allow(unsafe_code)] // ffi code + ptr arithmetic
     fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
         if self.data_slice().is_empty() {

diesel/src/pg/connection/cursor.rs

@@ -84,7 +84,7 @@ impl<'conn, 'query> RowByRowCursor<'conn, 'query> {
     }
 }
 
-impl<'conn, 'query> Iterator for RowByRowCursor<'conn, 'query> {
+impl Iterator for RowByRowCursor<'_, '_> {
     type Item = crate::QueryResult<PgRow>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -121,7 +121,7 @@ impl<'conn, 'query> Iterator for RowByRowCursor<'conn, 'query> {
     }
 }
 
-impl<'conn, 'query> Drop for RowByRowCursor<'conn, 'query> {
+impl Drop for RowByRowCursor<'_, '_> {
     fn drop(&mut self) {
         loop {
             let res = super::update_transaction_manager_status(

diesel/src/pg/connection/row.rs

@@ -21,7 +21,11 @@ impl PgRow {
 impl RowSealed for PgRow {}
 
 impl<'a> Row<'a, Pg> for PgRow {
-    type Field<'f> = PgField<'f> where 'a: 'f, Self: 'f;
+    type Field<'f>
+        = PgField<'f>
+    where
+        'a: 'f,
+        Self: 'f;
     type InnerPartialRow = Self;
 
     fn field_count(&self) -> usize {
@@ -81,7 +85,7 @@ impl<'a> Field<'a, Pg> for PgField<'a> {
     }
 }
 
-impl<'a> TypeOidLookup for PgField<'a> {
+impl TypeOidLookup for PgField<'_> {
     fn lookup(&self) -> std::num::NonZeroU32 {
         self.db_result.column_type(self.col_idx)
     }

diesel/src/pg/expression/array_comparison.rs

@@ -175,7 +175,7 @@ where
     }
 }
 
-impl<'a, ST, QS, DB, GB> AsArrayExpression<ST> for BoxedSelectStatement<'a, ST, QS, DB, GB>
+impl<ST, QS, DB, GB> AsArrayExpression<ST> for BoxedSelectStatement<'_, ST, QS, DB, GB>
 where
     ST: 'static,
     Self: SelectQuery<SqlType = ST>,

diesel/src/pg/expression/expression_methods.rs

@@ -3804,7 +3804,7 @@ pub(in crate::pg) mod private {
         }
     }
 
-    impl<'a> JsonRemoveIndex for Vec<&'a str> {
+    impl JsonRemoveIndex for Vec<&str> {
         type Expression = crate::dsl::AsExprOf<Self, Array<Text>>;
 
         fn into_json_index_expression(self) -> Self::Expression {

diesel/src/pg/query_builder/copy/copy_to.rs

@@ -152,7 +152,7 @@ impl<'f> Field<'f, Pg> for CopyField<'f> {
 }
 
 #[cfg(feature = "postgres")]
-impl<'a> TypeOidLookup for CopyField<'a> {
+impl TypeOidLookup for CopyField<'_> {
     fn lookup(&self) -> std::num::NonZeroU32 {
         self.result.column_type(self.col_idx)
     }
@@ -181,7 +181,8 @@ impl<'a> RowIndex<&'a str> for CopyRow<'_> {
 
 #[cfg(feature = "postgres")]
 impl<'a> Row<'a, Pg> for CopyRow<'_> {
-    type Field<'f> = CopyField<'f>
+    type Field<'f>
+        = CopyField<'f>
     where
         'a: 'f,
         Self: 'f;

diesel/src/pg/query_builder/limit_offset.rs

@@ -18,7 +18,7 @@ where
     }
 }
 
-impl<'a> QueryFragment<Pg> for BoxedLimitOffsetClause<'a, Pg> {
+impl QueryFragment<Pg> for BoxedLimitOffsetClause<'_, Pg> {
     fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         if let Some(ref limit) = self.limit {
             limit.walk_ast(out.reborrow())?;

diesel/src/pg/query_builder/on_constraint.rs

@@ -53,14 +53,14 @@ pub struct OnConstraint<'a> {
     constraint_name: &'a str,
 }
 
-impl<'a> QueryId for OnConstraint<'a> {
+impl QueryId for OnConstraint<'_> {
     type QueryId = ();
 
     const HAS_STATIC_QUERY_ID: bool = false;
 }
 
-impl<'a> QueryFragment<Pg, crate::pg::backend::PgOnConflictClause>
-    for ConflictTarget<OnConstraint<'a>>
+impl QueryFragment<Pg, crate::pg::backend::PgOnConflictClause>
+    for ConflictTarget<OnConstraint<'_>>
 {
     fn walk_ast<'b>(&'b self, mut out: AstPass<'_, 'b, Pg>) -> QueryResult<()> {
         out.unsafe_to_cache_prepared();
@@ -70,4 +70,4 @@ impl<'a> QueryFragment<Pg, crate::pg::backend::PgOnConflictClause>
     }
 }
 
-impl<'a, Table> OnConflictTarget<Table> for ConflictTarget<OnConstraint<'a>> {}
+impl<Table> OnConflictTarget<Table> for ConflictTarget<OnConstraint<'_>> {}