Rewrap lines in sqlx_macros::derives::{decode, encode}

sqlx-macros/src/derives/decode.rs

@@ -74,7 +74,14 @@ fn expand_derive_decode_transparent(
 
     let tts = quote!(
         impl #impl_generics ::sqlx::decode::Decode<'r, DB> for #ident #ty_generics #where_clause {
-            fn decode(value: <DB as ::sqlx::database::HasValueRef<'r>>::ValueRef) -> ::std::result::Result<Self, ::std::boxed::Box<dyn ::std::error::Error + 'static + ::std::marker::Send + ::std::marker::Sync>> {
+            fn decode(
+                value: <DB as ::sqlx::database::HasValueRef<'r>>::ValueRef,
+            ) -> ::std::result::Result<
+                Self,
+                ::std::boxed::Box<
+                    dyn ::std::error::Error + 'static + ::std::marker::Send + ::std::marker::Sync,
+                >,
+            > {
                 <#ty as ::sqlx::decode::Decode<'r, DB>>::decode(value).map(Self)
             }
         }
@@ -97,19 +104,32 @@ fn expand_derive_decode_weak_enum(
         .iter()
         .map(|v| {
             let id = &v.ident;
-            parse_quote!(_ if (#ident :: #id as #repr) == value => ::std::result::Result::Ok(#ident :: #id),)
+            parse_quote! {
+                _ if (#ident::#id as #repr) == value => ::std::result::Result::Ok(#ident::#id),
+            }
         })
         .collect::<Vec<Arm>>();
 
     Ok(quote!(
-        impl<'r, DB: ::sqlx::Database> ::sqlx::decode::Decode<'r, DB> for #ident where #repr: ::sqlx::decode::Decode<'r, DB> {
+        impl<'r, DB: ::sqlx::Database> ::sqlx::decode::Decode<'r, DB> for #ident
-            fn decode(value: <DB as ::sqlx::database::HasValueRef<'r>>::ValueRef) -> ::std::result::Result<Self, ::std::boxed::Box<dyn ::std::error::Error + 'static + ::std::marker::Send + ::std::marker::Sync>> {
+        where
+            #repr: ::sqlx::decode::Decode<'r, DB>,
+        {
+            fn decode(
+                value: <DB as ::sqlx::database::HasValueRef<'r>>::ValueRef,
+            ) -> ::std::result::Result<
+                Self,
+                ::std::boxed::Box<
+                    dyn ::std::error::Error + 'static + ::std::marker::Send + ::std::marker::Sync,
+                >,
+            > {
                 let value = <#repr as ::sqlx::decode::Decode<'r, DB>>::decode(value)?;
 
                 match value {
                     #(#arms)*
-
+                    _ => ::std::result::Result::Err(::std::boxed::Box::new(::sqlx::Error::Decode(
-                    _ => ::std::result::Result::Err(::std::boxed::Box::new(::sqlx::Error::Decode(::std::format!("invalid value {:?} for enum {}", value, #ident_s).into())))
+                        ::std::format!("invalid value {:?} for enum {}", value, #ident_s).into(),
+                    )))
                 }
             }
         }
@@ -154,8 +174,21 @@ fn expand_derive_decode_strong_enum(
     if cfg!(feature = "mysql") {
         tts.extend(quote!(
             impl<'r> ::sqlx::decode::Decode<'r, ::sqlx::mysql::MySql> for #ident {
-                fn decode(value: ::sqlx::mysql::MySqlValueRef<'r>) -> ::std::result::Result<Self, ::std::boxed::Box<dyn ::std::error::Error + 'static + ::std::marker::Send + ::std::marker::Sync>> {
+                fn decode(
-                    let value = <&'r ::std::primitive::str as ::sqlx::decode::Decode<'r, ::sqlx::mysql::MySql>>::decode(value)?;
+                    value: ::sqlx::mysql::MySqlValueRef<'r>,
+                ) -> ::std::result::Result<
+                    Self,
+                    ::std::boxed::Box<
+                        dyn ::std::error::Error
+                            + 'static
+                            + ::std::marker::Send
+                            + ::std::marker::Sync,
+                    >,
+                > {
+                    let value = <&'r ::std::primitive::str as ::sqlx::decode::Decode<
+                        'r,
+                        ::sqlx::mysql::MySql,
+                    >>::decode(value)?;
 
                     #values
                 }
@@ -166,8 +199,21 @@ fn expand_derive_decode_strong_enum(
     if cfg!(feature = "postgres") {
         tts.extend(quote!(
             impl<'r> ::sqlx::decode::Decode<'r, ::sqlx::postgres::Postgres> for #ident {
-                fn decode(value: ::sqlx::postgres::PgValueRef<'r>) -> ::std::result::Result<Self, ::std::boxed::Box<dyn ::std::error::Error + 'static + ::std::marker::Send + ::std::marker::Sync>> {
+                fn decode(
-                    let value = <&'r ::std::primitive::str as ::sqlx::decode::Decode<'r, ::sqlx::postgres::Postgres>>::decode(value)?;
+                    value: ::sqlx::postgres::PgValueRef<'r>,
+                ) -> ::std::result::Result<
+                    Self,
+                    ::std::boxed::Box<
+                        dyn ::std::error::Error
+                            + 'static
+                            + ::std::marker::Send
+                            + ::std::marker::Sync,
+                    >,
+                > {
+                    let value = <&'r ::std::primitive::str as ::sqlx::decode::Decode<
+                        'r,
+                        ::sqlx::postgres::Postgres,
+                    >>::decode(value)?;
 
                     #values
                 }
@@ -178,8 +224,21 @@ fn expand_derive_decode_strong_enum(
     if cfg!(feature = "sqlite") {
         tts.extend(quote!(
             impl<'r> ::sqlx::decode::Decode<'r, ::sqlx::sqlite::Sqlite> for #ident {
-                fn decode(value: ::sqlx::sqlite::SqliteValueRef<'r>) -> ::std::result::Result<Self, ::std::boxed::Box<dyn ::std::error::Error + 'static + ::std::marker::Send + ::std::marker::Sync>> {
+                fn decode(
-                    let value = <&'r ::std::primitive::str as ::sqlx::decode::Decode<'r, ::sqlx::sqlite::Sqlite>>::decode(value)?;
+                    value: ::sqlx::sqlite::SqliteValueRef<'r>,
+                ) -> ::std::result::Result<
+                    Self,
+                    ::std::boxed::Box<
+                        dyn ::std::error::Error
+                            + 'static
+                            + ::std::marker::Send
+                            + ::std::marker::Sync,
+                    >,
+                > {
+                    let value = <&'r ::std::primitive::str as ::sqlx::decode::Decode<
+                        'r,
+                        ::sqlx::sqlite::Sqlite,
+                    >>::decode(value)?;
 
                     #values
                 }
@@ -232,8 +291,20 @@ fn expand_derive_decode_struct(
         let names = fields.iter().map(|field| &field.ident);
 
         tts.extend(quote!(
-            impl #impl_generics ::sqlx::decode::Decode<'r, ::sqlx::Postgres> for #ident #ty_generics #where_clause {
+            impl #impl_generics ::sqlx::decode::Decode<'r, ::sqlx::Postgres> for #ident #ty_generics
-                fn decode(value: ::sqlx::postgres::PgValueRef<'r>) -> ::std::result::Result<Self, ::std::boxed::Box<dyn ::std::error::Error + 'static + ::std::marker::Send + ::std::marker::Sync>> {
+            #where_clause
+            {
+                fn decode(
+                    value: ::sqlx::postgres::PgValueRef<'r>,
+                ) -> ::std::result::Result<
+                    Self,
+                    ::std::boxed::Box<
+                        dyn ::std::error::Error
+                            + 'static
+                            + ::std::marker::Send
+                            + ::std::marker::Sync,
+                    >,
+                > {
                     let mut decoder = ::sqlx::postgres::types::PgRecordDecoder::new(value)?;
 
                     #(#reads)*

sqlx-macros/src/derives/encode.rs

@@ -78,8 +78,13 @@ fn expand_derive_encode_transparent(
     let (impl_generics, _, where_clause) = generics.split_for_impl();
 
     Ok(quote!(
-        impl #impl_generics ::sqlx::encode::Encode<#lifetime, DB> for #ident #ty_generics #where_clause {
+        impl #impl_generics ::sqlx::encode::Encode<#lifetime, DB> for #ident #ty_generics
-            fn encode_by_ref(&self, buf: &mut <DB as ::sqlx::database::HasArguments<#lifetime>>::ArgumentBuffer) -> ::sqlx::encode::IsNull {
+        #where_clause
+        {
+            fn encode_by_ref(
+                &self,
+                buf: &mut <DB as ::sqlx::database::HasArguments<#lifetime>>::ArgumentBuffer,
+            ) -> ::sqlx::encode::IsNull {
                 <#ty as ::sqlx::encode::Encode<#lifetime, DB>>::encode_by_ref(&self.0, buf)
             }
 
@@ -110,8 +115,14 @@ fn expand_derive_encode_weak_enum(
     }
 
     Ok(quote!(
-        impl<'q, DB: ::sqlx::Database> ::sqlx::encode::Encode<'q, DB> for #ident where #repr: ::sqlx::encode::Encode<'q, DB> {
+        impl<'q, DB: ::sqlx::Database> ::sqlx::encode::Encode<'q, DB> for #ident
-            fn encode_by_ref(&self, buf: &mut <DB as ::sqlx::database::HasArguments<'q>>::ArgumentBuffer) -> ::sqlx::encode::IsNull {
+        where
+            #repr: ::sqlx::encode::Encode<'q, DB>,
+        {
+            fn encode_by_ref(
+                &self,
+                buf: &mut <DB as ::sqlx::database::HasArguments<'q>>::ArgumentBuffer,
+            ) -> ::sqlx::encode::IsNull {
                 let value = match self {
                     #(#values)*
                 };
@@ -153,8 +164,14 @@ fn expand_derive_encode_strong_enum(
     }
 
     Ok(quote!(
-        impl<'q, DB: ::sqlx::Database> ::sqlx::encode::Encode<'q, DB> for #ident where &'q ::std::primitive::str: ::sqlx::encode::Encode<'q, DB> {
+        impl<'q, DB: ::sqlx::Database> ::sqlx::encode::Encode<'q, DB> for #ident
-            fn encode_by_ref(&self, buf: &mut <DB as ::sqlx::database::HasArguments<'q>>::ArgumentBuffer) -> ::sqlx::encode::IsNull {
+        where
+            &'q ::std::primitive::str: ::sqlx::encode::Encode<'q, DB>,
+        {
+            fn encode_by_ref(
+                &self,
+                buf: &mut <DB as ::sqlx::database::HasArguments<'q>>::ArgumentBuffer,
+            ) -> ::sqlx::encode::IsNull {
                 let val = match self {
                     #(#value_arms)*
                 };
@@ -222,8 +239,13 @@ fn expand_derive_encode_struct(
         });
 
         tts.extend(quote!(
-            impl #impl_generics ::sqlx::encode::Encode<'_, ::sqlx::Postgres> for #ident #ty_generics #where_clause {
+            impl #impl_generics ::sqlx::encode::Encode<'_, ::sqlx::Postgres> for #ident #ty_generics
-                fn encode_by_ref(&self, buf: &mut ::sqlx::postgres::PgArgumentBuffer) -> ::sqlx::encode::IsNull {
+            #where_clause
+            {
+                fn encode_by_ref(
+                    &self,
+                    buf: &mut ::sqlx::postgres::PgArgumentBuffer,
+                ) -> ::sqlx::encode::IsNull {
                     let mut encoder = ::sqlx::postgres::types::PgRecordEncoder::new(buf);
 
                     #(#writes)*