Merge pull request #3568 from weiznich/update/edition_to_2021

Update all the crates to the 2021 edition

diesel/Cargo.toml

@@ -9,7 +9,7 @@ homepage = "https://diesel.rs"
 repository = "https://github.com/diesel-rs/diesel"
 keywords = ["orm", "database", "sql"]
 categories = ["database"]
-edition = "2018"
+edition = "2021"
 rust-version = "1.65.0"
 
 [dependencies]

diesel/src/mysql/value.rs

@@ -58,8 +58,6 @@ impl<'a> MysqlValue<'a> {
     /// Returns the numeric representation of this value, based on the type code.
     /// Returns an error if the type code is not numeric.
     pub(crate) fn numeric_value(&self) -> deserialize::Result<NumericRepresentation<'_>> {
-        use std::convert::TryInto;
-
         Ok(match self.tpe {
             MysqlType::UnsignedTiny | MysqlType::Tiny => {
                 NumericRepresentation::Tiny(self.raw[0] as i8)

diesel/src/result.rs

@@ -388,7 +388,7 @@ impl PartialEq for Error {
 #[allow(warnings)]
 fn error_impls_send() {
     let err: Error = unimplemented!();
-    let x: &Send = &err;
+    let x: &dyn Send = &err;
 }
 
 /// An unexpected `NULL` was encountered during deserialization

diesel/src/sqlite/connection/raw.rs

@@ -306,6 +306,7 @@ extern "C" fn run_custom_function<F, Ret, RetSqlType>(
     let callback = std::panic::AssertUnwindSafe(&mut data_ptr.callback);
 
     let result = std::panic::catch_unwind(move || {
+        let _ = &callback;
         let args = unsafe { slice::from_raw_parts_mut(value_ptr, num_args as _) };
         let res = (callback.0)(&*conn, args)?;
         let value = process_sql_function_result(&res)?;

diesel_cli/Cargo.toml

@@ -9,7 +9,7 @@ homepage = "https://diesel.rs"
 repository = "https://github.com/diesel-rs/diesel"
 keywords = ["diesel", "migrations", "cli"]
 autotests = false
-edition = "2018"
+edition = "2021"
 include = ["src/**/*", "LICENSE-*", "README.md"]
 rust-version = "1.65.0"
 

diesel_derives/Cargo.toml

@@ -9,11 +9,7 @@ repository = "https://github.com/diesel-rs/diesel/tree/master/diesel_derives"
 autotests = false
 include = ["src/**/*", "LICENSE-*"]
 rust-version = "1.65.0"
-# we cannot update to newer editions
-# because we relay on a name resolution
-# hack to get a `diesel` item inside of diesel
-# as well as for using diesel-derives in external crates
-edition = "2015"
+edition = "2021"
 
 [dependencies]
 syn = { version = "2.0", features = ["derive", "fold", "full"] }

diesel_derives/src/as_changeset.rs

@@ -2,10 +2,10 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{parse_quote, DeriveInput, Expr, Path, Result, Type};
 
-use attrs::AttributeSpanWrapper;
-use field::Field;
-use model::Model;
-use util::{inner_of_option_ty, is_option_ty, wrap_in_dummy_mod};
+use crate::attrs::AttributeSpanWrapper;
+use crate::field::Field;
+use crate::model::Model;
+use crate::util::{inner_of_option_ty, is_option_ty, wrap_in_dummy_mod};
 
 pub fn derive(item: DeriveInput) -> Result<TokenStream> {
     let model = Model::from_item(&item, false, false)?;

diesel_derives/src/as_expression.rs

@@ -3,8 +3,8 @@ use quote::quote;
 use syn::DeriveInput;
 use syn::Result;
 
-use model::Model;
-use util::{ty_for_foreign_derive, wrap_in_dummy_mod};
+use crate::model::Model;
+use crate::util::{ty_for_foreign_derive, wrap_in_dummy_mod};
 
 pub fn derive(item: DeriveInput) -> Result<TokenStream> {
     let model = Model::from_item(&item, true, false)?;
@@ -88,15 +88,15 @@ pub fn derive(item: DeriveInput) -> Result<TokenStream> {
             quote!(
                 #tokens
 
-                impl#impl_generics AsExpression<#sql_type> for #struct_ty {
+                impl #impl_generics AsExpression<#sql_type> for #struct_ty {
                     type Expression = Bound<#sql_type, Self>;
 
                     fn as_expression(self) -> Self::Expression {
                         Bound::new(self)
                     }
                 }
 
-                impl#impl_generics AsExpression<Nullable<#sql_type>> for #struct_ty {
+                impl #impl_generics AsExpression<Nullable<#sql_type>> for #struct_ty {
                     type Expression = Bound<Nullable<#sql_type>, Self>;
 
                     fn as_expression(self) -> Self::Expression {

diesel_derives/src/associations.rs

@@ -4,9 +4,9 @@ use syn::fold::Fold;
 use syn::parse_quote;
 use syn::{DeriveInput, Ident, Lifetime, Result};
 
-use model::Model;
-use parsers::BelongsTo;
-use util::{camel_to_snake, wrap_in_dummy_mod};
+use crate::model::Model;
+use crate::parsers::BelongsTo;
+use crate::util::{camel_to_snake, wrap_in_dummy_mod};
 
 pub fn derive(item: DeriveInput) -> Result<TokenStream> {
     let model = Model::from_item(&item, false, false)?;

diesel_derives/src/attrs.rs

@@ -9,9 +9,9 @@ use syn::spanned::Spanned;
 use syn::token::Comma;
 use syn::{Attribute, Ident, LitBool, LitStr, Path, Type, TypePath};
 
-use deprecated::ParseDeprecated;
-use parsers::{BelongsTo, MysqlType, PostgresType, SqliteType};
-use util::{
+use crate::deprecated::ParseDeprecated;
+use crate::parsers::{BelongsTo, MysqlType, PostgresType, SqliteType};
+use crate::util::{
     parse_eq, parse_paren, unknown_attribute, BELONGS_TO_NOTE, COLUMN_NAME_NOTE,
     DESERIALIZE_AS_NOTE, MYSQL_TYPE_NOTE, POSTGRES_TYPE_NOTE, SELECT_EXPRESSION_NOTE,
     SELECT_EXPRESSION_TYPE_NOTE, SERIALIZE_AS_NOTE, SQLITE_TYPE_NOTE, SQL_TYPE_NOTE,

diesel_derives/src/deprecated/belongs_to.rs

@@ -2,9 +2,9 @@ use syn::parse::{ParseStream, Result};
 use syn::token::Comma;
 use syn::{parenthesized, Ident, LitStr};
 
-use deprecated::utils::parse_eq_and_lit_str;
-use parsers::BelongsTo;
-use util::BELONGS_TO_NOTE;
+use crate::deprecated::utils::parse_eq_and_lit_str;
+use crate::parsers::BelongsTo;
+use crate::util::BELONGS_TO_NOTE;
 
 pub fn parse_belongs_to(name: Ident, input: ParseStream) -> Result<BelongsTo> {
     if input.is_empty() {

diesel_derives/src/deprecated/changeset_options.rs

@@ -1,8 +1,8 @@
 use syn::parse::{ParseStream, Result};
 use syn::{parenthesized, Ident, LitBool};
 
-use deprecated::utils::parse_eq_and_lit_str;
-use util::TREAT_NONE_AS_NULL_NOTE;
+use crate::deprecated::utils::parse_eq_and_lit_str;
+use crate::util::TREAT_NONE_AS_NULL_NOTE;
 
 pub fn parse_changeset_options(name: Ident, input: ParseStream) -> Result<(Ident, LitBool)> {
     if input.is_empty() {

diesel_derives/src/deprecated/mod.rs

@@ -18,7 +18,7 @@ pub trait ParseDeprecated: Sized {
 #[cfg(any(feature = "without-deprecated", not(feature = "with-deprecated")))]
 mod not_deprecated {
     use super::{ParseDeprecated, ParseStream, Result};
-    use attrs::{FieldAttr, StructAttr};
+    use crate::attrs::{FieldAttr, StructAttr};
 
     impl ParseDeprecated for StructAttr {
         fn parse_deprecated(_input: ParseStream) -> Result<Option<Self>> {
@@ -36,18 +36,18 @@ mod not_deprecated {
 #[cfg(all(not(feature = "without-deprecated"), feature = "with-deprecated"))]
 mod impl_deprecated {
     use super::{ParseDeprecated, ParseStream, Result};
-    use attrs::{FieldAttr, StructAttr};
-    use deprecated::belongs_to::parse_belongs_to;
-    use deprecated::changeset_options::parse_changeset_options;
-    use deprecated::postgres_type::parse_postgres_type;
-    use deprecated::primary_key::parse_primary_key;
-    use deprecated::utils::parse_eq_and_lit_str;
-    use parsers::{MysqlType, PostgresType, SqliteType};
-    use proc_macro2::Span;
-    use syn::Ident;
-    use util::{
+    use crate::attrs::{FieldAttr, StructAttr};
+    use crate::deprecated::belongs_to::parse_belongs_to;
+    use crate::deprecated::changeset_options::parse_changeset_options;
+    use crate::deprecated::postgres_type::parse_postgres_type;
+    use crate::deprecated::primary_key::parse_primary_key;
+    use crate::deprecated::utils::parse_eq_and_lit_str;
+    use crate::parsers::{MysqlType, PostgresType, SqliteType};
+    use crate::util::{
         COLUMN_NAME_NOTE, MYSQL_TYPE_NOTE, SQLITE_TYPE_NOTE, SQL_TYPE_NOTE, TABLE_NAME_NOTE,
     };
+    use proc_macro2::Span;
+    use syn::Ident;
 
     macro_rules! warn {
         ($ident: expr, $help: expr) => {

diesel_derives/src/deprecated/postgres_type.rs

@@ -3,9 +3,9 @@ use syn::punctuated::Punctuated;
 use syn::token::Comma;
 use syn::{parenthesized, Ident, LitInt, LitStr};
 
-use deprecated::utils::parse_eq_and_lit_str;
-use parsers::PostgresType;
-use util::{unknown_attribute, POSTGRES_TYPE_NOTE};
+use crate::deprecated::utils::parse_eq_and_lit_str;
+use crate::parsers::PostgresType;
+use crate::util::{unknown_attribute, POSTGRES_TYPE_NOTE};
 
 enum Attr {
     Oid(Ident, LitInt),

diesel_derives/src/diesel_numeric_ops.rs

@@ -3,7 +3,7 @@ use quote::quote;
 use syn::parse_quote;
 use syn::DeriveInput;
 
-use util::wrap_in_dummy_mod;
+use crate::util::wrap_in_dummy_mod;
 
 pub fn derive(mut item: DeriveInput) -> TokenStream {
     let struct_name = &item.ident;

diesel_derives/src/field.rs

@@ -2,7 +2,7 @@ use proc_macro2::{Span, TokenStream};
 use syn::spanned::Spanned;
 use syn::{Field as SynField, Ident, Index, Result, Type};
 
-use attrs::{parse_attributes, AttributeSpanWrapper, FieldAttr, SqlIdentifier};
+use crate::attrs::{parse_attributes, AttributeSpanWrapper, FieldAttr, SqlIdentifier};
 
 pub struct Field {
     pub ty: Type,

diesel_derives/src/from_sql_row.rs

@@ -4,8 +4,8 @@ use syn::parse_quote;
 use syn::DeriveInput;
 use syn::Result;
 
-use model::Model;
-use util::{ty_for_foreign_derive, wrap_in_dummy_mod};
+use crate::model::Model;
+use crate::util::{ty_for_foreign_derive, wrap_in_dummy_mod};
 
 pub fn derive(mut item: DeriveInput) -> Result<TokenStream> {
     let model = Model::from_item(&item, true, false)?;

diesel_derives/src/identifiable.rs

@@ -4,8 +4,8 @@ use syn::parse_quote;
 use syn::DeriveInput;
 use syn::Result;
 
-use model::Model;
-use util::wrap_in_dummy_mod;
+use crate::model::Model;
+use crate::util::wrap_in_dummy_mod;
 
 pub fn derive(item: DeriveInput) -> Result<TokenStream> {
     let model = Model::from_item(&item, false, false)?;

diesel_derives/src/insertable.rs

@@ -1,12 +1,12 @@
-use attrs::AttributeSpanWrapper;
-use field::Field;
-use model::Model;
+use crate::attrs::AttributeSpanWrapper;
+use crate::field::Field;
+use crate::model::Model;
+use crate::util::{inner_of_option_ty, is_option_ty, wrap_in_dummy_mod};
 use proc_macro2::TokenStream;
 use quote::quote;
 use quote::quote_spanned;
 use syn::parse_quote;
 use syn::{DeriveInput, Expr, Path, Result, Type};
-use util::{inner_of_option_ty, is_option_ty, wrap_in_dummy_mod};
 
 pub fn derive(item: DeriveInput) -> Result<TokenStream> {
     let model = Model::from_item(&item, false, true)?;

diesel_derives/src/lib.rs

@@ -1150,7 +1150,7 @@ pub fn derive_valid_grouping(input: TokenStream) -> TokenStream {
 /// sql_function!(fn add_mul(x: Integer, y: Integer, z: Double) -> Double);
 ///
 /// # #[cfg(feature = "sqlite")]
-/// # fn run_test() -> Result<(), Box<::std::error::Error>> {
+/// # fn run_test() -> Result<(), Box<dyn std::error::Error>> {
 /// let connection = &mut SqliteConnection::establish(":memory:")?;
 ///
 /// add_mul::register_impl(connection, |x: i32, y: i32, z: f64| {

diesel_derives/src/model.rs

@@ -8,10 +8,10 @@ use syn::{
     LitBool, Path, Type,
 };
 
-use attrs::{parse_attributes, StructAttr};
-use field::Field;
-use parsers::{BelongsTo, MysqlType, PostgresType, SqliteType};
-use util::camel_to_snake;
+use crate::attrs::{parse_attributes, StructAttr};
+use crate::field::Field;
+use crate::parsers::{BelongsTo, MysqlType, PostgresType, SqliteType};
+use crate::util::camel_to_snake;
 
 pub struct Model {
     name: Path,

diesel_derives/src/parsers/belongs_to.rs

@@ -3,7 +3,7 @@ use syn::punctuated::Punctuated;
 use syn::token::Comma;
 use syn::{Ident, TypePath};
 
-use util::{parse_eq, unknown_attribute, BELONGS_TO_NOTE};
+use crate::util::{parse_eq, unknown_attribute, BELONGS_TO_NOTE};
 
 enum Attr {
     ForeignKey(Ident, Ident),

diesel_derives/src/parsers/mysql_type.rs

@@ -3,7 +3,7 @@ use syn::punctuated::Punctuated;
 use syn::token::Comma;
 use syn::{Ident, LitStr};
 
-use util::{parse_eq, unknown_attribute, MYSQL_TYPE_NOTE};
+use crate::util::{parse_eq, unknown_attribute, MYSQL_TYPE_NOTE};
 
 enum Attr {
     Name(Ident, LitStr),

diesel_derives/src/parsers/postgres_type.rs

@@ -3,7 +3,7 @@ use syn::punctuated::Punctuated;
 use syn::token::Comma;
 use syn::{Ident, LitInt, LitStr};
 
-use util::{parse_eq, unknown_attribute, POSTGRES_TYPE_NOTE, POSTGRES_TYPE_NOTE_ID};
+use crate::util::{parse_eq, unknown_attribute, POSTGRES_TYPE_NOTE, POSTGRES_TYPE_NOTE_ID};
 
 enum Attr {
     Oid(Ident, LitInt),

diesel_derives/src/parsers/sqlite_type.rs

@@ -3,7 +3,7 @@ use syn::punctuated::Punctuated;
 use syn::token::Comma;
 use syn::{Ident, LitStr};
 
-use util::{parse_eq, unknown_attribute, SQLITE_TYPE_NOTE};
+use crate::util::{parse_eq, unknown_attribute, SQLITE_TYPE_NOTE};
 
 enum Attr {
     Name(Ident, LitStr),

diesel_derives/src/query_id.rs

@@ -3,7 +3,7 @@ use quote::quote;
 use syn::parse_quote;
 use syn::DeriveInput;
 
-use util::wrap_in_dummy_mod;
+use crate::util::wrap_in_dummy_mod;
 
 pub fn derive(mut item: DeriveInput) -> TokenStream {
     for ty_param in item.generics.type_params_mut() {

diesel_derives/src/queryable.rs

@@ -2,9 +2,9 @@ use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::{parse_quote, DeriveInput, Ident, Index, Result};
 
-use field::Field;
-use model::Model;
-use util::wrap_in_dummy_mod;
+use crate::field::Field;
+use crate::model::Model;
+use crate::util::wrap_in_dummy_mod;
 
 pub fn derive(item: DeriveInput) -> Result<TokenStream> {
     let model = Model::from_item(&item, false, false)?;

diesel_derives/src/queryable_by_name.rs

@@ -2,10 +2,10 @@ use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{parse_quote, DeriveInput, Ident, LitStr, Result, Type};
 
-use attrs::AttributeSpanWrapper;
-use field::{Field, FieldName};
-use model::Model;
-use util::wrap_in_dummy_mod;
+use crate::attrs::AttributeSpanWrapper;
+use crate::field::{Field, FieldName};
+use crate::model::Model;
+use crate::util::wrap_in_dummy_mod;
 
 pub fn derive(item: DeriveInput) -> Result<TokenStream> {
     let model = Model::from_item(&item, false, false)?;

diesel_derives/src/selectable.rs

@@ -4,9 +4,9 @@ use syn::spanned::Spanned;
 use syn::DeriveInput;
 use syn::{parse_quote, Result};
 
-use field::Field;
-use model::Model;
-use util::wrap_in_dummy_mod;
+use crate::field::Field;
+use crate::model::Model;
+use crate::util::wrap_in_dummy_mod;
 
 pub fn derive(item: DeriveInput) -> Result<TokenStream> {
     let model = Model::from_item(&item, false, false)?;

diesel_derives/src/sql_type.rs

@@ -3,9 +3,9 @@ use quote::quote;
 use syn::Result;
 use syn::{DeriveInput, Ident};
 
-use model::Model;
-use parsers::PostgresType;
-use util::wrap_in_dummy_mod;
+use crate::model::Model;
+use crate::parsers::PostgresType;
+use crate::util::wrap_in_dummy_mod;
 
 pub fn derive(item: DeriveInput) -> Result<TokenStream> {
     let model = Model::from_item(&item, true, false)?;

diesel_derives/src/util.rs

@@ -4,7 +4,7 @@ use syn::parse::{Parse, ParseStream, Peek, Result};
 use syn::token::Eq;
 use syn::{parenthesized, parse_quote, Data, DeriveInput, GenericArgument, Ident, Type};
 
-use model::Model;
+use crate::model::Model;
 
 pub const COLUMN_NAME_NOTE: &str = "column_name = foo";
 pub const SQL_TYPE_NOTE: &str = "sql_type = Foo";