From 22d59d103ad81a0ff71c35f328cbd3b03b2d8505 Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:05:01 +0000 Subject: [PATCH 01/15] remove explicit auto derefs --- src/writable_impl.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/writable_impl.rs b/src/writable_impl.rs index f19858d..97f57e4 100644 --- a/src/writable_impl.rs +++ b/src/writable_impl.rs @@ -673,13 +673,13 @@ impl< C > Writable< C > for Box< str > { #[inline] fn write_to< W >( &self, writer: &mut W ) -> Result< (), C::Error > where W: ?Sized + Writer< C > { - let value: &str = &**self; + let value: &str = self; value.write_to( writer ) } #[inline] fn bytes_needed( &self ) -> Result< usize, C::Error > { - let value: &str = &**self; + let value: &str = self; Writable::< C >::bytes_needed( value ) } } From 659522216dad88d41a18b057c2b57445c8f9f587 Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:06:34 +0000 Subject: [PATCH 02/15] use 'is_empty' --- src/circular_buffer.rs | 2 +- src/lib.rs | 2 +- src/readable.rs | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/src/circular_buffer.rs b/src/circular_buffer.rs index e77c1e5..caf9f50 100644 --- a/src/circular_buffer.rs +++ b/src/circular_buffer.rs @@ -506,7 +506,7 @@ quickcheck::quickcheck! { assert_eq!( buffer.len(), control_buffer.len() ); assert_eq!( buffer.to_vec(), control_buffer ); - if buffer.len() > 0 { + if !buffer.is_empty() { let expected = control_buffer.remove( 0 ); let mut actual = [!expected]; buffer.consume_into( &mut actual ); diff --git a/src/lib.rs b/src/lib.rs index 26ba12a..dacdcc5 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -226,7 +226,7 @@ mod tests { impl io::Read for TestStream { fn read( &mut self, output: &mut [u8] ) -> Result< usize, io::Error > { - if self.position >= self.buffer.len() || output.len() == 0 { + if self.position >= self.buffer.len() || output.is_empty() { return Ok(0); } diff --git a/src/readable.rs b/src/readable.rs index 435b735..53ef5c6 100644 --- a/src/readable.rs +++ b/src/readable.rs @@ -314,7 +314,7 @@ impl< 'a, C, S > StreamReader< C, S > where C: Context, S: Read { } } - if self.buffer.len() > 0 { + if !self.buffer.len() > 0 { let length = std::cmp::min( self.buffer.len(), output.len() ); self.buffer.consume_into( &mut output[ ..length ] ); output = &mut output[ length.. ]; From 28a556f5f8d04867ee2d9d4063d8c622e21948d4 Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:08:47 +0000 Subject: [PATCH 03/15] remove deprecated 'chrono' methods --- src/ext_chrono.rs | 2 +- tests/serialization_tests.rs | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ext_chrono.rs b/src/ext_chrono.rs index 5397a71..a13294c 100644 --- a/src/ext_chrono.rs +++ b/src/ext_chrono.rs @@ -20,7 +20,7 @@ impl< 'a, C > Readable< 'a, C > for DateTime< Utc > fn read_from< R: Reader< 'a, C > >( reader: &mut R ) -> Result< Self, C::Error > { let seconds = reader.read_i64()?; let subsec_nanos = reader.read_u32()?; - Ok( Utc.timestamp( seconds, subsec_nanos ) ) + Ok( Utc.timestamp_opt( seconds, subsec_nanos ).unwrap() ) } #[inline] diff --git a/tests/serialization_tests.rs b/tests/serialization_tests.rs index 5350fb0..62a124b 100644 --- a/tests/serialization_tests.rs +++ b/tests/serialization_tests.rs @@ -2223,7 +2223,7 @@ symmetric_tests_unsized_native_endian! { #[cfg(feature = "chrono")] symmetric_tests! { chrono_datetime_utc for chrono::DateTime< chrono::Utc > { - in = chrono::offset::TimeZone::timestamp( &chrono::Utc, 123, 222 ), + in = chrono::offset::TimeZone::timestamp_opt( &chrono::Utc, 123, 222 ).unwrap(), le = [123, 0, 0, 0, 0, 0, 0, 0, 222, 0, 0, 0], be = [0, 0, 0, 0, 0, 0, 0, 123, 0, 0, 0, 222], minimum_bytes = 12 From ddc3ccb40cc2d485c00bb3e14e7d003ffe996fdc Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:14:21 +0000 Subject: [PATCH 04/15] remove needless borrows --- speedy-derive/src/lib.rs | 34 +++++++++++++++++----------------- src/readable.rs | 4 ++-- src/writable.rs | 4 ++-- src/writable_impl.rs | 8 ++++---- 4 files changed, 25 insertions(+), 25 deletions(-) diff --git a/speedy-derive/src/lib.rs b/speedy-derive/src/lib.rs index b48d211..393cbac 100644 --- a/speedy-derive/src/lib.rs +++ b/speedy-derive/src/lib.rs @@ -96,14 +96,14 @@ fn possibly_uses_generic_ty( generic_types: &[&syn::Ident], ty: &syn::Type ) -> } }) }, - syn::Type::Slice( syn::TypeSlice { elem, .. } ) => possibly_uses_generic_ty( generic_types, &elem ), + syn::Type::Slice( syn::TypeSlice { elem, .. } ) => possibly_uses_generic_ty( generic_types, elem ), syn::Type::Tuple( syn::TypeTuple { elems, .. } ) => elems.iter().any( |elem| possibly_uses_generic_ty( generic_types, elem ) ), - syn::Type::Reference( syn::TypeReference { elem, .. } ) => possibly_uses_generic_ty( generic_types, &elem ), - syn::Type::Paren( syn::TypeParen { elem, .. } ) => possibly_uses_generic_ty( generic_types, &elem ), - syn::Type::Ptr( syn::TypePtr { elem, .. } ) => possibly_uses_generic_ty( generic_types, &elem ), - syn::Type::Group( syn::TypeGroup { elem, .. } ) => possibly_uses_generic_ty( generic_types, &elem ), + syn::Type::Reference( syn::TypeReference { elem, .. } ) => possibly_uses_generic_ty( generic_types, elem ), + syn::Type::Paren( syn::TypeParen { elem, .. } ) => possibly_uses_generic_ty( generic_types, elem ), + syn::Type::Ptr( syn::TypePtr { elem, .. } ) => possibly_uses_generic_ty( generic_types, elem ), + syn::Type::Group( syn::TypeGroup { elem, .. } ) => possibly_uses_generic_ty( generic_types, elem ), syn::Type::Array( syn::TypeArray { elem, len, .. } ) => { - if possibly_uses_generic_ty( generic_types, &elem ) { + if possibly_uses_generic_ty( generic_types, elem ) { return true; } @@ -185,14 +185,14 @@ fn is_guaranteed_non_recursive( ty: &syn::Type ) -> bool { _ => false } }, - syn::Type::Slice( syn::TypeSlice { elem, .. } ) => is_guaranteed_non_recursive( &elem ), + syn::Type::Slice( syn::TypeSlice { elem, .. } ) => is_guaranteed_non_recursive( elem ), syn::Type::Tuple( syn::TypeTuple { elems, .. } ) => elems.iter().all( |elem| is_guaranteed_non_recursive( elem ) ), - syn::Type::Reference( syn::TypeReference { elem, .. } ) => is_guaranteed_non_recursive( &elem ), - syn::Type::Paren( syn::TypeParen { elem, .. } ) => is_guaranteed_non_recursive( &elem ), - syn::Type::Ptr( syn::TypePtr { elem, .. } ) => is_guaranteed_non_recursive( &elem ), - syn::Type::Group( syn::TypeGroup { elem, .. } ) => is_guaranteed_non_recursive( &elem ), + syn::Type::Reference( syn::TypeReference { elem, .. } ) => is_guaranteed_non_recursive( elem ), + syn::Type::Paren( syn::TypeParen { elem, .. } ) => is_guaranteed_non_recursive( elem ), + syn::Type::Ptr( syn::TypePtr { elem, .. } ) => is_guaranteed_non_recursive( elem ), + syn::Type::Group( syn::TypeGroup { elem, .. } ) => is_guaranteed_non_recursive( elem ), syn::Type::Array( syn::TypeArray { elem, len, .. } ) => { - if !is_guaranteed_non_recursive( &elem ) { + if !is_guaranteed_non_recursive( elem ) { return false; } @@ -726,7 +726,7 @@ impl< 'a > Field< 'a > { } fn is_guaranteed_non_recursive( &self ) -> bool { - is_guaranteed_non_recursive( &self.raw_ty ) + is_guaranteed_non_recursive( self.raw_ty ) } } @@ -1607,7 +1607,7 @@ fn readable_body< 'a >( types: &mut Vec< syn::Type >, st: &Struct< 'a > ) -> (To field_names.push( name ); types.extend( field.bound_types() ); - if let Some( minimum_bytes ) = get_minimum_bytes( &field ) { + if let Some( minimum_bytes ) = get_minimum_bytes( field ) { minimum_bytes_needed.push( minimum_bytes ); } } @@ -1740,7 +1740,7 @@ fn writable_body< 'a >( types: &mut Vec< syn::Type >, st: &Struct< 'a > ) -> (To continue; } - let write_value = write_field_body( &field ); + let write_value = write_field_body( field ); types.extend( field.bound_types() ); field_names.push( field.var_name().clone() ); @@ -2133,7 +2133,7 @@ fn impl_readable( input: syn::DeriveInput ) -> Result< TokenStream, syn::Error > (reader_body, minimum_bytes, impl_primitive, impl_zerocopyable) }, syn::Data::Enum( syn::DataEnum { variants, .. } ) => { - let enumeration = Enum::new( &name, &input.attrs, &variants )?; + let enumeration = Enum::new( name, &input.attrs, variants )?; let mut variant_matches = Vec::with_capacity( variants.len() ); let mut variant_minimum_sizes = Vec::with_capacity( variants.len() ); for variant in enumeration.variants { @@ -2306,7 +2306,7 @@ fn impl_writable( input: syn::DeriveInput ) -> Result< TokenStream, syn::Error > (impl_body, impl_primitive) }, syn::Data::Enum( syn::DataEnum { ref variants, .. } ) => { - let enumeration = Enum::new( &name, &input.attrs, &variants )?; + let enumeration = Enum::new( name, &input.attrs, variants )?; let tag_writer = match enumeration.tag_type { BasicType::U64 => quote! { write_u64 }, BasicType::U32 => quote! { write_u32 }, diff --git a/src/readable.rs b/src/readable.rs index 53ef5c6..339ceea 100644 --- a/src/readable.rs +++ b/src/readable.rs @@ -271,12 +271,12 @@ impl< 'ctx, 'r, 'a, C: Context > Reader< 'r, C > for CopyingBufferReader< 'ctx, #[inline(always)] fn context( &self ) -> &C { - &self.context + self.context } #[inline(always)] fn context_mut( &mut self ) -> &mut C { - &mut self.context + self.context } } diff --git a/src/writable.rs b/src/writable.rs index a916934..d6e287d 100644 --- a/src/writable.rs +++ b/src/writable.rs @@ -33,12 +33,12 @@ impl< 'a, C: Context > Writer< C > for BufferCollector< 'a, C > { #[inline] fn context( &self ) -> &C { - &self.context + self.context } #[inline] fn context_mut( &mut self ) -> &mut C { - &mut self.context + self.context } #[inline(always)] diff --git a/src/writable_impl.rs b/src/writable_impl.rs index 97f57e4..ec6fad1 100644 --- a/src/writable_impl.rs +++ b/src/writable_impl.rs @@ -284,7 +284,7 @@ impl< 'a, C: Context, T: Writable< C > > Writable< C > for &'a [T] where [T]: To impl< 'r, C, T > Writable< C > for Cow< 'r, HashSet< T > > where C: Context, T: Writable< C > + Clone + Hash + Eq { #[inline] fn write_to< W: ?Sized + Writer< C > >( &self, writer: &mut W ) -> Result< (), C::Error > { - (&**self).write_to( writer ) + (**self).write_to( writer ) } #[inline] @@ -296,7 +296,7 @@ impl< 'r, C, T > Writable< C > for Cow< 'r, HashSet< T > > where C: Context, T: impl< 'r, C, T > Writable< C > for Cow< 'r, BTreeSet< T > > where C: Context, T: Writable< C > + Clone + Ord { #[inline] fn write_to< W: ?Sized + Writer< C > >( &self, writer: &mut W ) -> Result< (), C::Error > { - (&**self).write_to( writer ) + (**self).write_to( writer ) } #[inline] @@ -308,7 +308,7 @@ impl< 'r, C, T > Writable< C > for Cow< 'r, BTreeSet< T > > where C: Context, T: impl< 'r, C, K, V > Writable< C > for Cow< 'r, HashMap< K, V > > where C: Context, K: Writable< C > + Clone + Hash + Eq, V: Writable< C > + Clone { #[inline] fn write_to< W: ?Sized + Writer< C > >( &self, writer: &mut W ) -> Result< (), C::Error > { - (&**self).write_to( writer ) + (**self).write_to( writer ) } #[inline] @@ -320,7 +320,7 @@ impl< 'r, C, K, V > Writable< C > for Cow< 'r, HashMap< K, V > > where C: Contex impl< 'r, C, K, V > Writable< C > for Cow< 'r, BTreeMap< K, V > > where C: Context, K: Writable< C > + Clone + Ord, V: Writable< C > + Clone { #[inline] fn write_to< W: ?Sized + Writer< C > >( &self, writer: &mut W ) -> Result< (), C::Error > { - (&**self).write_to( writer ) + (**self).write_to( writer ) } #[inline] From eabe0017654c95d6ec0b39b82ca6d0a1bcf527f8 Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:15:22 +0000 Subject: [PATCH 05/15] remove redundant clones --- src/circular_buffer.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/circular_buffer.rs b/src/circular_buffer.rs index caf9f50..7db2f47 100644 --- a/src/circular_buffer.rs +++ b/src/circular_buffer.rs @@ -334,7 +334,7 @@ impl CircularBuffer { self.buffer[ range_1.clone() ].copy_from_slice( &slice[ ..range_1.len() ] ); if let Some( range_2 ) = range_2 { - self.buffer[ range_2.clone() ].copy_from_slice( &slice[ range_1.len().. ] ); + self.buffer[ range_2 ].copy_from_slice( &slice[ range_1.len().. ] ); } self.length += slice.len(); From bc775c5b808c0c77cf821fab4a64cc0131816e5a Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:17:51 +0000 Subject: [PATCH 06/15] remove needless lifetimes --- speedy-derive/src/lib.rs | 4 ++-- src/readable.rs | 4 ++-- src/reader.rs | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/speedy-derive/src/lib.rs b/speedy-derive/src/lib.rs index 393cbac..6fa8473 100644 --- a/speedy-derive/src/lib.rs +++ b/speedy-derive/src/lib.rs @@ -1595,7 +1595,7 @@ fn read_field_body( field: &Field ) -> TokenStream { } } -fn readable_body< 'a >( types: &mut Vec< syn::Type >, st: &Struct< 'a > ) -> (TokenStream, TokenStream, TokenStream) { +fn readable_body( types: &mut Vec< syn::Type >, st: &Struct ) -> (TokenStream, TokenStream, TokenStream) { let mut field_names = Vec::new(); let mut field_readers = Vec::new(); let mut minimum_bytes_needed = Vec::new(); @@ -1732,7 +1732,7 @@ fn write_field_body( field: &Field ) -> TokenStream { body } -fn writable_body< 'a >( types: &mut Vec< syn::Type >, st: &Struct< 'a > ) -> (TokenStream, TokenStream) { +fn writable_body( types: &mut Vec< syn::Type >, st: &Struct ) -> (TokenStream, TokenStream) { let mut field_names = Vec::new(); let mut field_writers = Vec::new(); for field in &st.fields { diff --git a/src/readable.rs b/src/readable.rs index 339ceea..7db4658 100644 --- a/src/readable.rs +++ b/src/readable.rs @@ -120,7 +120,7 @@ impl< 'a, C: Context > Reader< 'a, C > for BufferReader< 'a, C > { } #[inline(always)] - fn read_bytes_borrowed_from_reader< 'r >( &'r mut self, length: usize ) -> Option< Result< &'r [u8], C::Error > > { + fn read_bytes_borrowed_from_reader( &mut self, length: usize ) -> Option< Result< &[u8], C::Error > > { if self.can_read_at_least( length ) == Some( false ) { return Some( Err( error_end_of_input() ) ); } @@ -250,7 +250,7 @@ impl< 'ctx, 'r, 'a, C: Context > Reader< 'r, C > for CopyingBufferReader< 'ctx, } #[inline(always)] - fn read_bytes_borrowed_from_reader< 'reader >( &'reader mut self, length: usize ) -> Option< Result< &'reader [u8], C::Error > > { + fn read_bytes_borrowed_from_reader( &mut self, length: usize ) -> Option< Result< &[u8], C::Error > > { if self.can_read_at_least( length ) == Some( false ) { return Some( Err( error_end_of_input() ) ); } diff --git a/src/reader.rs b/src/reader.rs index 18db8f9..3236bc5 100644 --- a/src/reader.rs +++ b/src/reader.rs @@ -95,7 +95,7 @@ pub trait Reader< 'a, C: Context >: Sized { } #[inline(always)] - fn read_bytes_borrowed_from_reader< 'r >( &'r mut self, _length: usize ) -> Option< Result< &'r [u8], C::Error > > { + fn read_bytes_borrowed_from_reader( &mut self, _length: usize ) -> Option< Result< &[u8], C::Error > > { None } From adcb631e84f5c62564a570e8c93751e3861cd39d Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:18:36 +0000 Subject: [PATCH 07/15] collapse nested if statements --- speedy-derive/src/lib.rs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/speedy-derive/src/lib.rs b/speedy-derive/src/lib.rs index 6fa8473..f1fb662 100644 --- a/speedy-derive/src/lib.rs +++ b/speedy-derive/src/lib.rs @@ -2148,10 +2148,8 @@ fn impl_readable( input: syn::DeriveInput ) -> Result< TokenStream, syn::Error > } }); - if variant.structure.kind != StructKind::Unit { - if variant.structure.is_guaranteed_non_recursive() { - variant_minimum_sizes.push( minimum_bytes ); - } + if variant.structure.kind != StructKind::Unit && variant.structure.is_guaranteed_non_recursive() { + variant_minimum_sizes.push( minimum_bytes ); } } From 5857ed3aadfbd226b2665202d41dd3bb89c343ab Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:19:15 +0000 Subject: [PATCH 08/15] remove needless return statements --- src/reader.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/reader.rs b/src/reader.rs index 3236bc5..f42cfff 100644 --- a/src/reader.rs +++ b/src/reader.rs @@ -21,7 +21,7 @@ impl< T > Iterator for RawCopyIter< T > { #[inline(always)] fn next( &mut self ) -> Option< Self::Item > { if self.pointer.as_ptr() as *const T == self.end { - return None; + None } else { unsafe { let old = self.pointer.as_ptr(); From 14d2dc7154a10c01cfdfe825ffd361c1b0a418fb Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:20:03 +0000 Subject: [PATCH 09/15] remove unused lifetimes --- src/readable.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/readable.rs b/src/readable.rs index 7db4658..208421d 100644 --- a/src/readable.rs +++ b/src/readable.rs @@ -287,7 +287,7 @@ struct StreamReader< C: Context, S: Read > { is_buffering: bool } -impl< 'a, C, S > StreamReader< C, S > where C: Context, S: Read { +impl StreamReader< C, S > where C: Context, S: Read { #[inline(never)] fn read_bytes_slow( &mut self, mut output: &mut [u8] ) -> Result< (), C::Error > { if self.is_buffering && output.len() < self.buffer.capacity() { From 4ea052bd4d5739fe909136abeab34846e9091dbb Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:22:08 +0000 Subject: [PATCH 10/15] remove unnecessary casts --- speedy-derive/src/lib.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/speedy-derive/src/lib.rs b/speedy-derive/src/lib.rs index f1fb662..bd346e4 100644 --- a/speedy-derive/src/lib.rs +++ b/speedy-derive/src/lib.rs @@ -1780,7 +1780,7 @@ impl< 'a > Enum< 'a > { let attrs = collect_enum_attributes( attrs )?; let tag_type = attrs.tag_type.unwrap_or( DEFAULT_ENUM_TAG_TYPE ); let max = match tag_type { - BasicType::U7 => 0b01111111 as u64, + BasicType::U7 => 0b01111111_u64, BasicType::U8 => std::u8::MAX as u64, BasicType::U16 => std::u16::MAX as u64, BasicType::U32 => std::u32::MAX as u64, @@ -1865,7 +1865,6 @@ impl< 'a > Enum< 'a > { quote! { #tag } }, BasicType::U64 | BasicType::VarInt64 => { - let tag = tag as u64; quote! { #tag } } }; From d80cf51a09017b630ab56881bf849b5424756548 Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:22:59 +0000 Subject: [PATCH 11/15] rewrite negation --- speedy-derive/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/speedy-derive/src/lib.rs b/speedy-derive/src/lib.rs index bd346e4..187a633 100644 --- a/speedy-derive/src/lib.rs +++ b/speedy-derive/src/lib.rs @@ -835,7 +835,7 @@ impl syn::parse::Parse for FieldAttribute { match literal { syn::Lit::Int( literal ) => { if literal.suffix() == "i8" { - vec![ (literal.base10_parse::< i8 >().unwrap() * -1) as u8 ] + vec![ -literal.base10_parse::< i8 >().unwrap() as u8 ] } else if literal.suffix() == "u8" { return generic_error() } else { From 9fa04fda5b6627652c0a21e70deef48547e592b0 Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:25:37 +0000 Subject: [PATCH 12/15] collapse nested match block --- speedy-derive/src/lib.rs | 19 +++++++------------ 1 file changed, 7 insertions(+), 12 deletions(-) diff --git a/speedy-derive/src/lib.rs b/speedy-derive/src/lib.rs index 187a633..18b05a5 100644 --- a/speedy-derive/src/lib.rs +++ b/speedy-derive/src/lib.rs @@ -831,18 +831,13 @@ impl syn::parse::Parse for FieldAttribute { }, syn::Expr::Unary( syn::ExprUnary { op: syn::UnOp::Neg(_), expr, .. } ) => { match *expr { - syn::Expr::Lit( syn::ExprLit { lit: literal, .. } ) => { - match literal { - syn::Lit::Int( literal ) => { - if literal.suffix() == "i8" { - vec![ -literal.base10_parse::< i8 >().unwrap() as u8 ] - } else if literal.suffix() == "u8" { - return generic_error() - } else { - return Err( syn::Error::new( value_span, "integers are not supported; if you want to use a single byte constant then append either 'u8' or 'i8' to it" ) ); - } - }, - _ => return generic_error() + syn::Expr::Lit( syn::ExprLit { lit: syn::Lit::Int( literal ), .. } ) => { + if literal.suffix() == "i8" { + vec![ -literal.base10_parse::< i8 >().unwrap() as u8 ] + } else if literal.suffix() == "u8" { + return generic_error() + } else { + return Err( syn::Error::new( value_span, "integers are not supported; if you want to use a single byte constant then append either 'u8' or 'i8' to it" ) ); } }, _ => return generic_error() From 4bfeed581bcc1e7c0c55284d8be01d4a93e71349 Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:30:05 +0000 Subject: [PATCH 13/15] remove unneeded 'unwrap' --- speedy-derive/src/lib.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/speedy-derive/src/lib.rs b/speedy-derive/src/lib.rs index 18b05a5..0256b1d 100644 --- a/speedy-derive/src/lib.rs +++ b/speedy-derive/src/lib.rs @@ -1167,8 +1167,7 @@ fn get_fields< 'a, I: IntoIterator< Item = &'a syn::Field > + 'a >( fields: I ) } } - if length_type.is_some() && length.is_some() { - let (key_span, _) = length_type.unwrap(); + if let (Some((key_span, _)), Some(_)) = (length_type, &length) { let message = "You cannot have both 'length_type' and 'length' on the same field"; return Err( syn::Error::new( key_span, message ) ); } From 45f584d3980f3038dd0babda72f5e5685af16941 Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:31:05 +0000 Subject: [PATCH 14/15] don't compare bools to bools --- speedy-derive/src/lib.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/speedy-derive/src/lib.rs b/speedy-derive/src/lib.rs index 0256b1d..0c15691 100644 --- a/speedy-derive/src/lib.rs +++ b/speedy-derive/src/lib.rs @@ -671,11 +671,11 @@ struct Field< 'a > { impl< 'a > Field< 'a > { fn can_be_primitive( &self ) -> bool { - self.default_on_eof == false && + !self.default_on_eof && self.length.is_none() && self.length_type.is_none() && - self.skip == false && - self.varint == false && + !self.skip && + !self.varint && self.constant_prefix.is_none() } From dd647008a9047780f2a3b610f4d1d078b55ae8c5 Mon Sep 17 00:00:00 2001 From: "daniel.eades" Date: Fri, 25 Nov 2022 13:32:12 +0000 Subject: [PATCH 15/15] remove redundant closures --- speedy-derive/src/lib.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/speedy-derive/src/lib.rs b/speedy-derive/src/lib.rs index 0c15691..15d9c84 100644 --- a/speedy-derive/src/lib.rs +++ b/speedy-derive/src/lib.rs @@ -186,7 +186,7 @@ fn is_guaranteed_non_recursive( ty: &syn::Type ) -> bool { } }, syn::Type::Slice( syn::TypeSlice { elem, .. } ) => is_guaranteed_non_recursive( elem ), - syn::Type::Tuple( syn::TypeTuple { elems, .. } ) => elems.iter().all( |elem| is_guaranteed_non_recursive( elem ) ), + syn::Type::Tuple( syn::TypeTuple { elems, .. } ) => elems.iter().all(is_guaranteed_non_recursive), syn::Type::Reference( syn::TypeReference { elem, .. } ) => is_guaranteed_non_recursive( elem ), syn::Type::Paren( syn::TypeParen { elem, .. } ) => is_guaranteed_non_recursive( elem ), syn::Type::Ptr( syn::TypePtr { elem, .. } ) => is_guaranteed_non_recursive( elem ),