From b2e3cfd3bca0def41351f32bdc88c22221bb0e25 Mon Sep 17 00:00:00 2001 From: Victor Koenders Date: Mon, 10 Jan 2022 19:30:24 +0100 Subject: [PATCH 1/2] Switched Decode and BorrowDecode to take &mut D, fixes #467 --- derive/src/derive_enum.rs | 16 ++--- derive/src/derive_struct.rs | 16 ++--- src/de/impl_tuples.rs | 16 ++--- src/de/impls.rs | 114 ++++++++++++++++++------------------ src/de/mod.rs | 16 ++--- src/features/atomic.rs | 22 +++---- src/features/impl_alloc.rs | 46 +++++++-------- src/features/impl_std.rs | 44 +++++++------- src/features/serde/mod.rs | 8 +-- tests/alloc.rs | 6 +- tests/issues.rs | 3 + tests/issues/issue_467.rs | 16 +++++ tests/std.rs | 6 +- 13 files changed, 175 insertions(+), 154 deletions(-) create mode 100644 tests/issues/issue_467.rs diff --git a/derive/src/derive_enum.rs b/derive/src/derive_enum.rs index 4859f0f7..c2016e2c 100644 --- a/derive/src/derive_enum.rs +++ b/derive/src/derive_enum.rs @@ -201,7 +201,7 @@ impl DeriveEnum { }) .generate_fn("decode") .with_generic("D", ["bincode::de::Decoder"]) - .with_arg("mut decoder", "D") + .with_arg("decoder", "&mut D") .with_return_type("core::result::Result") .body(|fn_builder| { if self.variants.is_empty() { @@ -209,7 +209,7 @@ impl DeriveEnum { } else { fn_builder .push_parsed( - "let variant_index = ::decode(&mut decoder)?;", + "let variant_index = ::decode(decoder)?;", )?; fn_builder.push_parsed("match variant_index")?; fn_builder.group(Delimiter::Brace, |variant_case| { @@ -242,10 +242,10 @@ impl DeriveEnum { variant_body.punct(':'); if field.attributes().has_attribute(FieldAttribute::WithSerde)? { variant_body - .push_parsed(" as bincode::Decode>::decode(&mut decoder)?.0,")?; + .push_parsed(" as bincode::Decode>::decode(decoder)?.0,")?; } else { variant_body - .push_parsed("bincode::Decode::decode(&mut decoder)?,")?; + .push_parsed("bincode::Decode::decode(decoder)?,")?; } } Ok(()) @@ -277,14 +277,14 @@ impl DeriveEnum { }) .generate_fn("borrow_decode") .with_generic("D", ["bincode::de::BorrowDecoder<'__de>"]) - .with_arg("mut decoder", "D") + .with_arg("decoder", "&mut D") .with_return_type("core::result::Result") .body(|fn_builder| { if self.variants.is_empty() { fn_builder.push_parsed("core::result::Result::Err(bincode::error::DecodeError::EmptyEnum { type_name: core::any::type_name::() })")?; } else { fn_builder - .push_parsed("let variant_index = ::decode(&mut decoder)?;")?; + .push_parsed("let variant_index = ::decode(decoder)?;")?; fn_builder.push_parsed("match variant_index")?; fn_builder.group(Delimiter::Brace, |variant_case| { for (mut variant_index, variant) in self.iter_fields() { @@ -316,9 +316,9 @@ impl DeriveEnum { variant_body.punct(':'); if field.attributes().has_attribute(FieldAttribute::WithSerde)? { variant_body - .push_parsed(" as bincode::BorrowDecode>::borrow_decode(&mut decoder)?.0,")?; + .push_parsed(" as bincode::BorrowDecode>::borrow_decode(decoder)?.0,")?; } else { - variant_body.push_parsed("bincode::de::BorrowDecode::borrow_decode(&mut decoder)?,")?; + variant_body.push_parsed("bincode::de::BorrowDecode::borrow_decode(decoder)?,")?; } } Ok(()) diff --git a/derive/src/derive_struct.rs b/derive/src/derive_struct.rs index 934678bc..77f0f2c6 100644 --- a/derive/src/derive_struct.rs +++ b/derive/src/derive_struct.rs @@ -58,7 +58,7 @@ impl DeriveStruct { }) .generate_fn("decode") .with_generic("D", ["bincode::de::Decoder"]) - .with_arg("mut decoder", "D") + .with_arg("decoder", "&mut D") .with_return_type("core::result::Result") .body(|fn_body| { // Ok(Self { @@ -68,21 +68,21 @@ impl DeriveStruct { ok_group.group(Delimiter::Brace, |struct_body| { // Fields // { - // a: bincode::Decode::decode(&mut decoder)?, - // b: bincode::Decode::decode(&mut decoder)?, + // a: bincode::Decode::decode(decoder)?, + // b: bincode::Decode::decode(decoder)?, // ... // } for field in fields.names() { if field.attributes().has_attribute(FieldAttribute::WithSerde)? { struct_body .push_parsed(format!( - "{}: ( as bincode::Decode>::decode(&mut decoder)?).0,", + "{}: ( as bincode::Decode>::decode(decoder)?).0,", field ))?; } else { struct_body .push_parsed(format!( - "{}: bincode::Decode::decode(&mut decoder)?,", + "{}: bincode::Decode::decode(decoder)?,", field ))?; } @@ -109,7 +109,7 @@ impl DeriveStruct { }) .generate_fn("borrow_decode") .with_generic("D", ["bincode::de::BorrowDecoder<'__de>"]) - .with_arg("mut decoder", "D") + .with_arg("decoder", "&mut D") .with_return_type("core::result::Result") .body(|fn_body| { // Ok(Self { @@ -121,13 +121,13 @@ impl DeriveStruct { if field.attributes().has_attribute(FieldAttribute::WithSerde)? { struct_body .push_parsed(format!( - "{}: ( as bincode::de::BorrowDecode>::borrow_decode(&mut decoder)?).0,", + "{}: ( as bincode::de::BorrowDecode>::borrow_decode(decoder)?).0,", field ))?; } else { struct_body .push_parsed(format!( - "{}: bincode::de::BorrowDecode::borrow_decode(&mut decoder)?,", + "{}: bincode::de::BorrowDecode::borrow_decode(decoder)?,", field ))?; } diff --git a/src/de/impl_tuples.rs b/src/de/impl_tuples.rs index 47ab21eb..70d82cd7 100644 --- a/src/de/impl_tuples.rs +++ b/src/de/impl_tuples.rs @@ -5,7 +5,7 @@ impl Decode for (A,) where A: Decode, { - fn decode<_D: Decoder>(mut decoder: _D) -> Result { + fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result { Ok((A::decode(&mut decoder)?,)) } } @@ -15,7 +15,7 @@ where A: Decode, B: Decode, { - fn decode<_D: Decoder>(mut decoder: _D) -> Result { + fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result { Ok((A::decode(&mut decoder)?, B::decode(&mut decoder)?)) } } @@ -26,7 +26,7 @@ where B: Decode, C: Decode, { - fn decode<_D: Decoder>(mut decoder: _D) -> Result { + fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result { Ok(( A::decode(&mut decoder)?, B::decode(&mut decoder)?, @@ -42,7 +42,7 @@ where C: Decode, D: Decode, { - fn decode<_D: Decoder>(mut decoder: _D) -> Result { + fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result { Ok(( A::decode(&mut decoder)?, B::decode(&mut decoder)?, @@ -60,7 +60,7 @@ where D: Decode, E: Decode, { - fn decode<_D: Decoder>(mut decoder: _D) -> Result { + fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result { Ok(( A::decode(&mut decoder)?, B::decode(&mut decoder)?, @@ -80,7 +80,7 @@ where E: Decode, F: Decode, { - fn decode<_D: Decoder>(mut decoder: _D) -> Result { + fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result { Ok(( A::decode(&mut decoder)?, B::decode(&mut decoder)?, @@ -102,7 +102,7 @@ where F: Decode, G: Decode, { - fn decode<_D: Decoder>(mut decoder: _D) -> Result { + fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result { Ok(( A::decode(&mut decoder)?, B::decode(&mut decoder)?, @@ -126,7 +126,7 @@ where G: Decode, H: Decode, { - fn decode<_D: Decoder>(mut decoder: _D) -> Result { + fn decode<_D: Decoder>(mut decoder: &mut _D) -> Result { Ok(( A::decode(&mut decoder)?, B::decode(&mut decoder)?, diff --git a/src/de/impls.rs b/src/de/impls.rs index 83cfab22..b53e7ff7 100644 --- a/src/de/impls.rs +++ b/src/de/impls.rs @@ -21,7 +21,7 @@ use core::{ }; impl Decode for bool { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { match u8::decode(decoder)? { 0 => Ok(false), 1 => Ok(true), @@ -32,7 +32,7 @@ impl Decode for bool { impl Decode for u8 { #[inline] - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(1)?; if let Some(buf) = decoder.reader().peek_read(1) { let byte = buf[0]; @@ -47,7 +47,7 @@ impl Decode for u8 { } impl Decode for NonZeroU8 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { NonZeroU8::new(u8::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero { non_zero_type: IntegerType::U8, }) @@ -55,7 +55,7 @@ impl Decode for NonZeroU8 { } impl Decode for u16 { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(2)?; match D::C::INT_ENCODING { IntEncoding::Variable => { @@ -74,7 +74,7 @@ impl Decode for u16 { } impl Decode for NonZeroU16 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { NonZeroU16::new(u16::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero { non_zero_type: IntegerType::U16, }) @@ -82,7 +82,7 @@ impl Decode for NonZeroU16 { } impl Decode for u32 { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(4)?; match D::C::INT_ENCODING { IntEncoding::Variable => { @@ -101,7 +101,7 @@ impl Decode for u32 { } impl Decode for NonZeroU32 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { NonZeroU32::new(u32::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero { non_zero_type: IntegerType::U32, }) @@ -109,7 +109,7 @@ impl Decode for NonZeroU32 { } impl Decode for u64 { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(8)?; match D::C::INT_ENCODING { IntEncoding::Variable => { @@ -128,7 +128,7 @@ impl Decode for u64 { } impl Decode for NonZeroU64 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { NonZeroU64::new(u64::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero { non_zero_type: IntegerType::U64, }) @@ -136,7 +136,7 @@ impl Decode for NonZeroU64 { } impl Decode for u128 { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(16)?; match D::C::INT_ENCODING { IntEncoding::Variable => { @@ -155,7 +155,7 @@ impl Decode for u128 { } impl Decode for NonZeroU128 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { NonZeroU128::new(u128::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero { non_zero_type: IntegerType::U128, }) @@ -163,7 +163,7 @@ impl Decode for NonZeroU128 { } impl Decode for usize { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(8)?; match D::C::INT_ENCODING { IntEncoding::Variable => { @@ -182,7 +182,7 @@ impl Decode for usize { } impl Decode for NonZeroUsize { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { NonZeroUsize::new(usize::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero { non_zero_type: IntegerType::Usize, }) @@ -190,7 +190,7 @@ impl Decode for NonZeroUsize { } impl Decode for i8 { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(1)?; let mut bytes = [0u8; 1]; decoder.reader().read(&mut bytes)?; @@ -199,7 +199,7 @@ impl Decode for i8 { } impl Decode for NonZeroI8 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { NonZeroI8::new(i8::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero { non_zero_type: IntegerType::I8, }) @@ -207,7 +207,7 @@ impl Decode for NonZeroI8 { } impl Decode for i16 { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(2)?; match D::C::INT_ENCODING { IntEncoding::Variable => { @@ -226,7 +226,7 @@ impl Decode for i16 { } impl Decode for NonZeroI16 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { NonZeroI16::new(i16::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero { non_zero_type: IntegerType::I16, }) @@ -234,7 +234,7 @@ impl Decode for NonZeroI16 { } impl Decode for i32 { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(4)?; match D::C::INT_ENCODING { IntEncoding::Variable => { @@ -253,7 +253,7 @@ impl Decode for i32 { } impl Decode for NonZeroI32 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { NonZeroI32::new(i32::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero { non_zero_type: IntegerType::I32, }) @@ -261,7 +261,7 @@ impl Decode for NonZeroI32 { } impl Decode for i64 { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(8)?; match D::C::INT_ENCODING { IntEncoding::Variable => { @@ -280,7 +280,7 @@ impl Decode for i64 { } impl Decode for NonZeroI64 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { NonZeroI64::new(i64::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero { non_zero_type: IntegerType::I64, }) @@ -288,7 +288,7 @@ impl Decode for NonZeroI64 { } impl Decode for i128 { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(16)?; match D::C::INT_ENCODING { IntEncoding::Variable => { @@ -307,7 +307,7 @@ impl Decode for i128 { } impl Decode for NonZeroI128 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { NonZeroI128::new(i128::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero { non_zero_type: IntegerType::I128, }) @@ -315,7 +315,7 @@ impl Decode for NonZeroI128 { } impl Decode for isize { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(8)?; match D::C::INT_ENCODING { IntEncoding::Variable => { @@ -334,7 +334,7 @@ impl Decode for isize { } impl Decode for NonZeroIsize { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { NonZeroIsize::new(isize::decode(decoder)?).ok_or(DecodeError::NonZeroTypeIsZero { non_zero_type: IntegerType::Isize, }) @@ -342,7 +342,7 @@ impl Decode for NonZeroIsize { } impl Decode for f32 { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(4)?; let mut bytes = [0u8; 4]; decoder.reader().read(&mut bytes)?; @@ -354,7 +354,7 @@ impl Decode for f32 { } impl Decode for f64 { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { decoder.claim_bytes_read(8)?; let mut bytes = [0u8; 8]; decoder.reader().read(&mut bytes)?; @@ -366,7 +366,7 @@ impl Decode for f64 { } impl Decode for char { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { let mut array = [0u8; 4]; // Look at the first byte to see how many bytes must be read @@ -395,16 +395,16 @@ impl Decode for char { } impl<'a, 'de: 'a> BorrowDecode<'de> for &'a [u8] { - fn borrow_decode>(mut decoder: D) -> Result { - let len = super::decode_slice_len(&mut decoder)?; + fn borrow_decode>(decoder: &mut D) -> Result { + let len = super::decode_slice_len(decoder)?; decoder.claim_bytes_read(len)?; decoder.borrow_reader().take_bytes(len) } } impl<'a, 'de: 'a> BorrowDecode<'de> for Option<&'a [u8]> { - fn borrow_decode>(mut decoder: D) -> Result { - match super::decode_option_variant(&mut decoder, core::any::type_name::>())? { + fn borrow_decode>(decoder: &mut D) -> Result { + match super::decode_option_variant(decoder, core::any::type_name::>())? { Some(_) => { let val = BorrowDecode::borrow_decode(decoder)?; Ok(Some(val)) @@ -415,15 +415,15 @@ impl<'a, 'de: 'a> BorrowDecode<'de> for Option<&'a [u8]> { } impl<'a, 'de: 'a> BorrowDecode<'de> for &'a str { - fn borrow_decode>(decoder: D) -> Result { + fn borrow_decode>(decoder: &mut D) -> Result { let slice = <&[u8]>::borrow_decode(decoder)?; core::str::from_utf8(slice).map_err(DecodeError::Utf8) } } impl<'a, 'de: 'a> BorrowDecode<'de> for Option<&'a str> { - fn borrow_decode>(mut decoder: D) -> Result { - match super::decode_option_variant(&mut decoder, core::any::type_name::>())? { + fn borrow_decode>(decoder: &mut D) -> Result { + match super::decode_option_variant(decoder, core::any::type_name::>())? { Some(_) => { let val = BorrowDecode::borrow_decode(decoder)?; Ok(Some(val)) @@ -437,9 +437,9 @@ impl Decode for [T; N] where T: Decode + Sized + 'static, { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { if !D::C::SKIP_FIXED_ARRAY_LENGTH { - let length = super::decode_slice_len(&mut decoder)?; + let length = super::decode_slice_len(decoder)?; if length != N { return Err(DecodeError::ArrayLengthMismatch { found: length, @@ -464,7 +464,7 @@ where let result = super::impl_core::collect_into_array(&mut (0..N).map(|_| { // See the documentation on `unclaim_bytes_read` as to why we're doing this here decoder.unclaim_bytes_read(core::mem::size_of::()); - T::decode(&mut decoder) + T::decode(decoder) })); // result is only None if N does not match the values of `(0..N)`, which it always should @@ -475,13 +475,13 @@ where } impl Decode for () { - fn decode(_: D) -> Result { + fn decode(_: &mut D) -> Result { Ok(()) } } impl Decode for core::marker::PhantomData { - fn decode(_: D) -> Result { + fn decode(_: &mut D) -> Result { Ok(core::marker::PhantomData) } } @@ -490,8 +490,8 @@ impl Decode for Option where T: Decode, { - fn decode(mut decoder: D) -> Result { - match super::decode_option_variant(&mut decoder, core::any::type_name::>())? { + fn decode(decoder: &mut D) -> Result { + match super::decode_option_variant(decoder, core::any::type_name::>())? { Some(_) => { let val = T::decode(decoder)?; Ok(Some(val)) @@ -506,8 +506,8 @@ where T: Decode, U: Decode, { - fn decode(mut decoder: D) -> Result { - let is_ok = u8::decode(&mut decoder)?; + fn decode(decoder: &mut D) -> Result { + let is_ok = u8::decode(decoder)?; match is_ok { 0 => { let t = T::decode(decoder)?; @@ -530,7 +530,7 @@ impl Decode for Cell where T: Decode, { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { let t = T::decode(decoder)?; Ok(Cell::new(t)) } @@ -540,17 +540,17 @@ impl Decode for RefCell where T: Decode, { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { let t = T::decode(decoder)?; Ok(RefCell::new(t)) } } impl Decode for Duration { - fn decode(mut decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { const NANOS_PER_SEC: u64 = 1_000_000_000; - let secs: u64 = Decode::decode(&mut decoder)?; - let nanos: u32 = Decode::decode(&mut decoder)?; + let secs: u64 = Decode::decode(decoder)?; + let nanos: u32 = Decode::decode(decoder)?; if secs.checked_add(u64::from(nanos) / NANOS_PER_SEC).is_none() { return Err(DecodeError::InvalidDuration { secs, nanos }); } @@ -562,9 +562,9 @@ impl Decode for Range where T: Decode, { - fn decode(mut decoder: D) -> Result { - let min = T::decode(&mut decoder)?; - let max = T::decode(&mut decoder)?; + fn decode(decoder: &mut D) -> Result { + let min = T::decode(decoder)?; + let max = T::decode(decoder)?; Ok(min..max) } } @@ -573,9 +573,9 @@ impl Decode for RangeInclusive where T: Decode, { - fn decode(mut decoder: D) -> Result { - let min = T::decode(&mut decoder)?; - let max = T::decode(&mut decoder)?; + fn decode(decoder: &mut D) -> Result { + let min = T::decode(decoder)?; + let max = T::decode(decoder)?; Ok(RangeInclusive::new(min, max)) } } @@ -584,8 +584,8 @@ impl Decode for Bound where T: Decode, { - fn decode(mut decoder: D) -> Result { - match u32::decode(&mut decoder)? { + fn decode(decoder: &mut D) -> Result { + match u32::decode(decoder)? { 0 => Ok(Bound::Unbounded), 1 => Ok(Bound::Included(T::decode(decoder)?)), 2 => Ok(Bound::Excluded(T::decode(decoder)?)), diff --git a/src/de/mod.rs b/src/de/mod.rs index ad3f0327..ca128818 100644 --- a/src/de/mod.rs +++ b/src/de/mod.rs @@ -25,7 +25,7 @@ pub use self::decoder::DecoderImpl; /// This trait will be automatically implemented if you enable the `derive` feature and add `#[derive(bincode::Decode)]` to your type. Note that if the type contains any lifetimes, `BorrowDecode` will be implemented instead. pub trait Decode: for<'de> BorrowDecode<'de> { /// Attempt to decode this type with the given [Decode]. - fn decode(decoder: D) -> Result; + fn decode(decoder: &mut D) -> Result; } /// Trait that makes a type able to be decoded, akin to serde's `Deserialize` trait. @@ -35,11 +35,11 @@ pub trait Decode: for<'de> BorrowDecode<'de> { /// This trait will be automatically implemented if you enable the `derive` feature and add `#[derive(bincode::Decode)]` to a type with a lifetime. pub trait BorrowDecode<'de>: Sized { /// Attempt to decode this type with the given [BorrowDecode]. - fn borrow_decode>(decoder: D) -> Result; + fn borrow_decode>(decoder: &mut D) -> Result; } impl<'de, T: Decode> BorrowDecode<'de> for T { - fn borrow_decode(decoder: D) -> Result { + fn borrow_decode(decoder: &mut D) -> Result { Decode::decode(decoder) } } @@ -100,8 +100,8 @@ pub trait Decoder: Sealed { /// # } /// # } /// impl Decode for Container { - /// fn decode(mut decoder: D) -> Result { - /// let len = u64::decode(&mut decoder)? as usize; + /// fn decode(decoder: &mut D) -> Result { + /// let len = u64::decode(decoder)? as usize; /// // Make sure we don't allocate too much memory /// decoder.claim_bytes_read(len * core::mem::size_of::()); /// @@ -109,7 +109,7 @@ pub trait Decoder: Sealed { /// for _ in 0..len { /// // un-claim the memory /// decoder.unclaim_bytes_read(core::mem::size_of::()); - /// result.push(T::decode(&mut decoder)?) + /// result.push(T::decode(decoder)?) /// } /// Ok(result) /// } @@ -170,7 +170,7 @@ where /// Decodes only the option variant from the decoder. Will not read any more data than that. #[inline] pub(crate) fn decode_option_variant( - decoder: D, + decoder: &mut D, type_name: &'static str, ) -> Result, DecodeError> { let is_some = u8::decode(decoder)?; @@ -187,6 +187,6 @@ pub(crate) fn decode_option_variant( /// Decodes the length of any slice, container, etc from the decoder #[inline] -pub(crate) fn decode_slice_len(decoder: D) -> Result { +pub(crate) fn decode_slice_len(decoder: &mut D) -> Result { u64::decode(decoder).map(|v| v as usize) } diff --git a/src/features/atomic.rs b/src/features/atomic.rs index 2f2e85a6..192d8d9c 100644 --- a/src/features/atomic.rs +++ b/src/features/atomic.rs @@ -11,7 +11,7 @@ impl Encode for AtomicBool { } impl Decode for AtomicBool { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { Ok(AtomicBool::new(Decode::decode(decoder)?)) } } @@ -23,7 +23,7 @@ impl Encode for AtomicU8 { } impl Decode for AtomicU8 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { Ok(AtomicU8::new(Decode::decode(decoder)?)) } } @@ -35,7 +35,7 @@ impl Encode for AtomicU16 { } impl Decode for AtomicU16 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { Ok(AtomicU16::new(Decode::decode(decoder)?)) } } @@ -47,7 +47,7 @@ impl Encode for AtomicU32 { } impl Decode for AtomicU32 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { Ok(AtomicU32::new(Decode::decode(decoder)?)) } } @@ -59,7 +59,7 @@ impl Encode for AtomicU64 { } impl Decode for AtomicU64 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { Ok(AtomicU64::new(Decode::decode(decoder)?)) } } @@ -71,7 +71,7 @@ impl Encode for AtomicUsize { } impl Decode for AtomicUsize { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { Ok(AtomicUsize::new(Decode::decode(decoder)?)) } } @@ -83,7 +83,7 @@ impl Encode for AtomicI8 { } impl Decode for AtomicI8 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { Ok(AtomicI8::new(Decode::decode(decoder)?)) } } @@ -95,7 +95,7 @@ impl Encode for AtomicI16 { } impl Decode for AtomicI16 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { Ok(AtomicI16::new(Decode::decode(decoder)?)) } } @@ -107,7 +107,7 @@ impl Encode for AtomicI32 { } impl Decode for AtomicI32 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { Ok(AtomicI32::new(Decode::decode(decoder)?)) } } @@ -119,7 +119,7 @@ impl Encode for AtomicI64 { } impl Decode for AtomicI64 { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { Ok(AtomicI64::new(Decode::decode(decoder)?)) } } @@ -131,7 +131,7 @@ impl Encode for AtomicIsize { } impl Decode for AtomicIsize { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { Ok(AtomicIsize::new(Decode::decode(decoder)?)) } } diff --git a/src/features/impl_alloc.rs b/src/features/impl_alloc.rs index e8316f1a..33bc640d 100644 --- a/src/features/impl_alloc.rs +++ b/src/features/impl_alloc.rs @@ -50,8 +50,8 @@ impl Decode for BinaryHeap where T: Decode + Ord, { - fn decode(mut decoder: D) -> Result { - let len = crate::de::decode_slice_len(&mut decoder)?; + fn decode(decoder: &mut D) -> Result { + let len = crate::de::decode_slice_len(decoder)?; decoder.claim_container_read::(len)?; let mut map = BinaryHeap::with_capacity(len); @@ -59,7 +59,7 @@ where // See the documentation on `unclaim_bytes_read` as to why we're doing this here decoder.unclaim_bytes_read(core::mem::size_of::()); - let key = T::decode(&mut decoder)?; + let key = T::decode(decoder)?; map.push(key); } Ok(map) @@ -84,8 +84,8 @@ where K: Decode + Ord, V: Decode, { - fn decode(mut decoder: D) -> Result { - let len = crate::de::decode_slice_len(&mut decoder)?; + fn decode(decoder: &mut D) -> Result { + let len = crate::de::decode_slice_len(decoder)?; decoder.claim_container_read::<(K, V)>(len)?; let mut map = BTreeMap::new(); @@ -93,8 +93,8 @@ where // See the documentation on `unclaim_bytes_read` as to why we're doing this here decoder.unclaim_bytes_read(core::mem::size_of::<(K, V)>()); - let key = K::decode(&mut decoder)?; - let value = V::decode(&mut decoder)?; + let key = K::decode(decoder)?; + let value = V::decode(decoder)?; map.insert(key, value); } Ok(map) @@ -120,8 +120,8 @@ impl Decode for BTreeSet where T: Decode + Ord, { - fn decode(mut decoder: D) -> Result { - let len = crate::de::decode_slice_len(&mut decoder)?; + fn decode(decoder: &mut D) -> Result { + let len = crate::de::decode_slice_len(decoder)?; decoder.claim_container_read::(len)?; let mut map = BTreeSet::new(); @@ -129,7 +129,7 @@ where // See the documentation on `unclaim_bytes_read` as to why we're doing this here decoder.unclaim_bytes_read(core::mem::size_of::()); - let key = T::decode(&mut decoder)?; + let key = T::decode(decoder)?; map.insert(key); } Ok(map) @@ -153,8 +153,8 @@ impl Decode for VecDeque where T: Decode, { - fn decode(mut decoder: D) -> Result { - let len = crate::de::decode_slice_len(&mut decoder)?; + fn decode(decoder: &mut D) -> Result { + let len = crate::de::decode_slice_len(decoder)?; decoder.claim_container_read::(len)?; let mut map = VecDeque::with_capacity(len); @@ -162,7 +162,7 @@ where // See the documentation on `unclaim_bytes_read` as to why we're doing this here decoder.unclaim_bytes_read(core::mem::size_of::()); - let key = T::decode(&mut decoder)?; + let key = T::decode(decoder)?; map.push_back(key); } Ok(map) @@ -186,8 +186,8 @@ impl Decode for Vec where T: Decode, { - fn decode(mut decoder: D) -> Result { - let len = crate::de::decode_slice_len(&mut decoder)?; + fn decode(decoder: &mut D) -> Result { + let len = crate::de::decode_slice_len(decoder)?; decoder.claim_container_read::(len)?; let mut vec = Vec::with_capacity(len); @@ -195,7 +195,7 @@ where // See the documentation on `unclaim_bytes_read` as to why we're doing this here decoder.unclaim_bytes_read(core::mem::size_of::()); - vec.push(T::decode(&mut decoder)?); + vec.push(T::decode(decoder)?); } Ok(vec) } @@ -215,7 +215,7 @@ where } impl Decode for String { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { let bytes = Vec::::decode(decoder)?; String::from_utf8(bytes).map_err(|e| DecodeError::Utf8(e.utf8_error())) } @@ -231,7 +231,7 @@ impl Decode for Box where T: Decode, { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { let t = T::decode(decoder)?; Ok(Box::new(t)) } @@ -250,7 +250,7 @@ impl Decode for Box<[T]> where T: Decode, { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { let vec = Vec::decode(decoder)?; Ok(vec.into_boxed_slice()) } @@ -277,7 +277,7 @@ where // where // T: BorrowDecode<'cow>, // { -// fn borrow_decode>(decoder: D) -> Result { +// fn borrow_decode>(decoder: &mut D) -> Result { // let t = T::borrow_decode(decoder)?; // Ok(Cow::Borrowed(t)) // } @@ -288,7 +288,7 @@ where T: ToOwned, ::Owned: Decode, { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { let t = ::Owned::decode(decoder)?; Ok(Cow::Owned(t)) } @@ -307,7 +307,7 @@ impl Decode for Rc where T: Decode, { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { let t = T::decode(decoder)?; Ok(Rc::new(t)) } @@ -327,7 +327,7 @@ impl Decode for Arc where T: Decode, { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { let t = T::decode(decoder)?; Ok(Arc::new(t)) } diff --git a/src/features/impl_std.rs b/src/features/impl_std.rs index 75a2fe0f..0e6e9cc4 100644 --- a/src/features/impl_std.rs +++ b/src/features/impl_std.rs @@ -114,7 +114,7 @@ impl<'a> Encode for &'a CStr { } impl<'de> BorrowDecode<'de> for &'de CStr { - fn borrow_decode>(decoder: D) -> Result { + fn borrow_decode>(decoder: &mut D) -> Result { let bytes = <&[u8]>::borrow_decode(decoder)?; CStr::from_bytes_with_nul(bytes).map_err(|e| DecodeError::CStrNulError { inner: e }) } @@ -127,7 +127,7 @@ impl Encode for CString { } impl Decode for CString { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { // BlockedTODO: https://github.com/rust-lang/rust/issues/73179 // use `from_vec_with_nul` instead, combined with: // let bytes = std::vec::Vec::::decode(decoder)?; @@ -156,7 +156,7 @@ impl Decode for Mutex where T: Decode, { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { let t = T::decode(decoder)?; Ok(Mutex::new(t)) } @@ -178,7 +178,7 @@ impl Decode for RwLock where T: Decode, { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { let t = T::decode(decoder)?; Ok(RwLock::new(t)) } @@ -197,7 +197,7 @@ impl Encode for SystemTime { } impl Decode for SystemTime { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { let duration = Duration::decode(decoder)?; match SystemTime::UNIX_EPOCH.checked_add(duration) { Some(t) => Ok(t), @@ -216,7 +216,7 @@ impl Encode for &'_ Path { } impl<'de> BorrowDecode<'de> for &'de Path { - fn borrow_decode>(decoder: D) -> Result { + fn borrow_decode>(decoder: &mut D) -> Result { let str = <&'de str>::borrow_decode(decoder)?; Ok(Path::new(str)) } @@ -229,7 +229,7 @@ impl Encode for PathBuf { } impl Decode for PathBuf { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { let string = std::string::String::decode(decoder)?; Ok(string.into()) } @@ -251,8 +251,8 @@ impl Encode for IpAddr { } impl Decode for IpAddr { - fn decode(mut decoder: D) -> Result { - match u32::decode(&mut decoder)? { + fn decode(decoder: &mut D) -> Result { + match u32::decode(decoder)? { 0 => Ok(IpAddr::V4(Ipv4Addr::decode(decoder)?)), 1 => Ok(IpAddr::V6(Ipv6Addr::decode(decoder)?)), found => Err(DecodeError::UnexpectedVariant { @@ -271,7 +271,7 @@ impl Encode for Ipv4Addr { } impl Decode for Ipv4Addr { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { Ok(Self::from(<[u8; 4]>::decode(decoder)?)) } } @@ -283,7 +283,7 @@ impl Encode for Ipv6Addr { } impl Decode for Ipv6Addr { - fn decode(decoder: D) -> Result { + fn decode(decoder: &mut D) -> Result { Ok(Self::from(<[u8; 16]>::decode(decoder)?)) } } @@ -304,8 +304,8 @@ impl Encode for SocketAddr { } impl Decode for SocketAddr { - fn decode(mut decoder: D) -> Result { - match u32::decode(&mut decoder)? { + fn decode(decoder: &mut D) -> Result { + match u32::decode(decoder)? { 0 => Ok(SocketAddr::V4(SocketAddrV4::decode(decoder)?)), 1 => Ok(SocketAddr::V6(SocketAddrV6::decode(decoder)?)), found => Err(DecodeError::UnexpectedVariant { @@ -325,8 +325,8 @@ impl Encode for SocketAddrV4 { } impl Decode for SocketAddrV4 { - fn decode(mut decoder: D) -> Result { - let ip = Ipv4Addr::decode(&mut decoder)?; + fn decode(decoder: &mut D) -> Result { + let ip = Ipv4Addr::decode(decoder)?; let port = u16::decode(decoder)?; Ok(Self::new(ip, port)) } @@ -340,8 +340,8 @@ impl Encode for SocketAddrV6 { } impl Decode for SocketAddrV6 { - fn decode(mut decoder: D) -> Result { - let ip = Ipv6Addr::decode(&mut decoder)?; + fn decode(decoder: &mut D) -> Result { + let ip = Ipv6Addr::decode(decoder)?; let port = u16::decode(decoder)?; Ok(Self::new(ip, port, 0, 0)) } @@ -370,8 +370,8 @@ where K: Decode + Eq + std::hash::Hash, V: Decode, { - fn decode(mut decoder: D) -> Result { - let len = crate::de::decode_slice_len(&mut decoder)?; + fn decode(decoder: &mut D) -> Result { + let len = crate::de::decode_slice_len(decoder)?; decoder.claim_container_read::<(K, V)>(len)?; let mut map = HashMap::with_capacity(len); @@ -379,10 +379,12 @@ where // See the documentation on `unclaim_bytes_read` as to why we're doing this here decoder.unclaim_bytes_read(core::mem::size_of::<(K, V)>()); - let k = K::decode(&mut decoder)?; - let v = V::decode(&mut decoder)?; + let k = K::decode(decoder)?; + let v = V::decode(decoder)?; map.insert(k, v); } Ok(map) } } + + diff --git a/src/features/serde/mod.rs b/src/features/serde/mod.rs index a5bf8ceb..314ec723 100644 --- a/src/features/serde/mod.rs +++ b/src/features/serde/mod.rs @@ -101,8 +101,8 @@ impl crate::Decode for Compat where T: serde_incl::de::DeserializeOwned, { - fn decode(mut decoder: D) -> Result { - let serde_decoder = de_owned::SerdeDecoder { de: &mut decoder }; + fn decode(decoder: &mut D) -> Result { + let serde_decoder = de_owned::SerdeDecoder { de: decoder }; T::deserialize(serde_decoder).map(Compat) } } @@ -134,10 +134,10 @@ where T: serde_incl::de::Deserialize<'de>, { fn borrow_decode>( - mut decoder: D, + decoder: &mut D, ) -> Result { let serde_decoder = de_borrowed::SerdeDecoder { - de: &mut decoder, + de: decoder, pd: core::marker::PhantomData, }; T::deserialize(serde_decoder).map(BorrowCompat) diff --git a/tests/alloc.rs b/tests/alloc.rs index dd396e85..215916ad 100644 --- a/tests/alloc.rs +++ b/tests/alloc.rs @@ -30,11 +30,11 @@ impl bincode::enc::Encode for Foo { impl bincode::Decode for Foo { fn decode( - mut decoder: D, + decoder: &mut D, ) -> Result { Ok(Self { - a: bincode::Decode::decode(&mut decoder)?, - b: bincode::Decode::decode(&mut decoder)?, + a: bincode::Decode::decode(decoder)?, + b: bincode::Decode::decode(decoder)?, }) } } diff --git a/tests/issues.rs b/tests/issues.rs index 51a8ebd8..cecf2b3e 100644 --- a/tests/issues.rs +++ b/tests/issues.rs @@ -5,3 +5,6 @@ mod issue_431; #[path = "issues/issue_427.rs"] mod issue_427; + +#[path = "issues/issue_467.rs"] +mod issue_467; diff --git a/tests/issues/issue_467.rs b/tests/issues/issue_467.rs new file mode 100644 index 00000000..8cfe8e54 --- /dev/null +++ b/tests/issues/issue_467.rs @@ -0,0 +1,16 @@ +#![cfg(all(feature = "std", feature = "derive"))] + +extern crate std; + +use std::collections::BTreeMap; + +#[derive(bincode::Decode)] +struct AllTypes(BTreeMap); + +#[test] +fn test_issue_467() { + let _result: Result<(AllTypes, _), _> = bincode::decode_from_slice( + &[], + bincode::config::Configuration::standard().with_limit::<1024>(), + ); +} diff --git a/tests/std.rs b/tests/std.rs index 13056b8b..e1e49cf6 100644 --- a/tests/std.rs +++ b/tests/std.rs @@ -32,11 +32,11 @@ impl bincode::enc::Encode for Foo { impl bincode::Decode for Foo { fn decode( - mut decoder: D, + decoder: &mut D, ) -> Result { Ok(Self { - a: bincode::Decode::decode(&mut decoder)?, - b: bincode::Decode::decode(&mut decoder)?, + a: bincode::Decode::decode(decoder)?, + b: bincode::Decode::decode(decoder)?, }) } } From c4cb2d70d43f6ef9ff59dbfc04cb53f88bd387e2 Mon Sep 17 00:00:00 2001 From: Victor Koenders Date: Mon, 10 Jan 2022 19:34:29 +0100 Subject: [PATCH 2/2] I didn't forget to run cargo fmt, you did --- src/features/impl_std.rs | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/features/impl_std.rs b/src/features/impl_std.rs index 0e6e9cc4..d30e27df 100644 --- a/src/features/impl_std.rs +++ b/src/features/impl_std.rs @@ -386,5 +386,3 @@ where Ok(map) } } - -