From 60e08f9545e1631dea1b8b801566fa9b4f59879e Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 23 Jan 2021 12:29:20 -0800 Subject: [PATCH 1/9] Format PR #1917 with rustfmt 1.4.32 --- serde/src/private/de.rs | 2 +- serde_derive/src/de.rs | 39 +++++++++++++-------------------- test_suite/tests/test_borrow.rs | 11 ++-------- 3 files changed, 18 insertions(+), 34 deletions(-) diff --git a/serde/src/private/de.rs b/serde/src/private/de.rs index 24d2d691..2432e52e 100644 --- a/serde/src/private/de.rs +++ b/serde/src/private/de.rs @@ -1,7 +1,7 @@ use lib::*; +use de::value::{BorrowedBytesDeserializer, BytesDeserializer}; use de::{Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor}; -use de::value::{BytesDeserializer, BorrowedBytesDeserializer}; #[cfg(any(feature = "std", feature = "alloc"))] use de::{MapAccess, Unexpected}; diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs index c9a4bd34..8470da8d 100644 --- a/serde_derive/src/de.rs +++ b/serde_derive/src/de.rs @@ -1893,15 +1893,12 @@ fn deserialize_generated_identifier( let fallthrough = quote!(_serde::__private::Ok(__Field::__other(__value))); ( Some(ignore_variant), - Some((fallthrough.clone(), fallthrough)) + Some((fallthrough.clone(), fallthrough)), ) } else if let Some(other_idx) = other_idx { let ignore_variant = fields[other_idx].1.clone(); let fallthrough = quote!(_serde::__private::Ok(__Field::#ignore_variant)); - ( - None, - Some((fallthrough.clone(), fallthrough)) - ) + (None, Some((fallthrough.clone(), fallthrough))) } else if is_variant || cattrs.deny_unknown_fields() { (None, None) } else { @@ -1909,7 +1906,7 @@ fn deserialize_generated_identifier( let fallthrough = quote!(_serde::__private::Ok(__Field::__ignore)); ( Some(ignore_variant), - Some((fallthrough.clone(), fallthrough)) + Some((fallthrough.clone(), fallthrough)), ) }; @@ -1973,25 +1970,21 @@ fn deserialize_custom_identifier( if last.attrs.other() { let ordinary = &variants[..variants.len() - 1]; let fallthrough = quote!(_serde::__private::Ok(#this::#last_ident)); - ( - ordinary, - Some((fallthrough.clone(), fallthrough)) - ) + (ordinary, Some((fallthrough.clone(), fallthrough))) } else if let Style::Newtype = last.style { let ordinary = &variants[..variants.len() - 1]; - let fallthrough = |method| quote! { - _serde::__private::Result::map( - _serde::Deserialize::deserialize( - _serde::__private::de::IdentifierDeserializer::#method(__value) - ), - #this::#last_ident) + let fallthrough = |method| { + quote! { + _serde::__private::Result::map( + _serde::Deserialize::deserialize( + _serde::__private::de::IdentifierDeserializer::#method(__value) + ), + #this::#last_ident) + } }; ( ordinary, - Some(( - fallthrough(quote!(from)), - fallthrough(quote!(borrowed)), - )) + Some((fallthrough(quote!(from)), fallthrough(quote!(borrowed)))), ) } else { (variants, None) @@ -2128,10 +2121,8 @@ fn deserialize_identifier( (None, None, None, None) }; - let ( - fallthrough_arm, - fallthrough_borrowed_arm, - ) = if let Some(fallthrough) = fallthrough.clone() { + let (fallthrough_arm, fallthrough_borrowed_arm) = if let Some(fallthrough) = fallthrough.clone() + { fallthrough } else if is_variant { let fallthrough = quote! { diff --git a/test_suite/tests/test_borrow.rs b/test_suite/tests/test_borrow.rs index 15139cb9..fd8c9651 100644 --- a/test_suite/tests/test_borrow.rs +++ b/test_suite/tests/test_borrow.rs @@ -99,12 +99,7 @@ fn test_field_identifier() { Str(&'a str), } - assert_de_tokens( - &FieldStr::Str("value"), - &[ - Token::BorrowedStr("value"), - ], - ); + assert_de_tokens(&FieldStr::Str("value"), &[Token::BorrowedStr("value")]); #[derive(Deserialize, Debug, PartialEq)] #[serde(field_identifier)] @@ -115,9 +110,7 @@ fn test_field_identifier() { assert_de_tokens( &FieldBytes::Bytes(b"value"), - &[ - Token::BorrowedBytes(b"value"), - ], + &[Token::BorrowedBytes(b"value")], ); } From 34f4b68f7714b12551a472a86bc0568c7c5b3388 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 23 Jan 2021 12:30:19 -0800 Subject: [PATCH 2/9] Fix unneeded clone from PR #1917 --- serde_derive/src/de.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs index 8470da8d..9e9c4022 100644 --- a/serde_derive/src/de.rs +++ b/serde_derive/src/de.rs @@ -2121,8 +2121,7 @@ fn deserialize_identifier( (None, None, None, None) }; - let (fallthrough_arm, fallthrough_borrowed_arm) = if let Some(fallthrough) = fallthrough.clone() - { + let (fallthrough_arm, fallthrough_borrowed_arm) = if let Some(fallthrough) = fallthrough { fallthrough } else if is_variant { let fallthrough = quote! { From b20214d4a059e80e80740a8a26035eb9055eff9a Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 23 Jan 2021 12:23:10 -0800 Subject: [PATCH 3/9] Undo macro exports from PR #1917 All of these macros are only used internally within the serde crate. There is no need for them to have #[macro_export] and need to be hidden from docs. --- serde/src/de/value.rs | 29 +++++++++++++---------------- serde/src/private/de.rs | 2 +- 2 files changed, 14 insertions(+), 17 deletions(-) diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs index fcacb0c3..1f878151 100644 --- a/serde/src/de/value.rs +++ b/serde/src/de/value.rs @@ -25,15 +25,13 @@ use lib::*; use self::private::{First, Second}; use __private::de::size_hint; -use de::{self, Expected, IntoDeserializer, SeqAccess}; +use de::{self, Deserializer, Expected, IntoDeserializer, SeqAccess, Visitor}; use ser; //////////////////////////////////////////////////////////////////////////////// -/// For structs that contain a PhantomData. We do not want the trait -/// bound `E: Clone` inferred by derive(Clone). -#[doc(hidden)] -#[macro_export] +// For structs that contain a PhantomData. We do not want the trait +// bound `E: Clone` inferred by derive(Clone). macro_rules! impl_copy_clone { ($ty:ident $(<$lifetime:tt>)*) => { impl<$($lifetime,)* E> Copy for $ty<$($lifetime,)* E> {} @@ -46,9 +44,8 @@ macro_rules! impl_copy_clone { }; } -/// Creates a deserializer any method of which forwards to the specified visitor method -#[doc(hidden)] -#[macro_export(local_inner_macros)] +// Creates a deserializer any method of which forwards to the specified visitor +// method. macro_rules! forward_deserializer { // Non-borrowed references ( @@ -76,15 +73,15 @@ macro_rules! forward_deserializer { impl_copy_clone!($deserializer $(<$lifetime>)*); - impl<'de, $($lifetime,)* E> $crate::de::Deserializer<'de> for $deserializer<$($lifetime,)* E> + impl<'de, $($lifetime,)* E> Deserializer<'de> for $deserializer<$($lifetime,)* E> where - E: $crate::de::Error, + E: de::Error, { type Error = E; - fn deserialize_any(self, visitor: V) -> $crate::export::Result + fn deserialize_any(self, visitor: V) -> Result where - V: $crate::de::Visitor<'de>, + V: Visitor<'de>, { visitor.$visit(self.value) } @@ -120,15 +117,15 @@ macro_rules! forward_deserializer { impl_copy_clone!($deserializer<'de>); - impl<'de, E> $crate::de::Deserializer<'de> for $deserializer<'de, E> + impl<'de, E> Deserializer<'de> for $deserializer<'de, E> where - E: $crate::de::Error, + E: de::Error, { type Error = E; - fn deserialize_any(self, visitor: V) -> $crate::export::Result + fn deserialize_any(self, visitor: V) -> Result where - V: $crate::de::Visitor<'de>, + V: Visitor<'de>, { visitor.$visit(self.value) } diff --git a/serde/src/private/de.rs b/serde/src/private/de.rs index 2432e52e..b0e75af8 100644 --- a/serde/src/private/de.rs +++ b/serde/src/private/de.rs @@ -1,7 +1,7 @@ use lib::*; use de::value::{BorrowedBytesDeserializer, BytesDeserializer}; -use de::{Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor}; +use de::{self, Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor}; #[cfg(any(feature = "std", feature = "alloc"))] use de::{MapAccess, Unexpected}; From 0a230e8598f6a529ee765c578366a268f2bbe48c Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 23 Jan 2021 12:50:01 -0800 Subject: [PATCH 4/9] Inline forward_deserializer into private::de for Str deserializers We shouldn't try to use the same macro for public and private types. The API for a private type can usually be pared much further down to save compile time, such as Debug and Copy and Clone impls. --- serde/src/private/de.rs | 77 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 74 insertions(+), 3 deletions(-) diff --git a/serde/src/private/de.rs b/serde/src/private/de.rs index b0e75af8..6bb6cd44 100644 --- a/serde/src/private/de.rs +++ b/serde/src/private/de.rs @@ -1,7 +1,7 @@ use lib::*; use de::value::{BorrowedBytesDeserializer, BytesDeserializer}; -use de::{self, Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor}; +use de::{Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor}; #[cfg(any(feature = "std", feature = "alloc"))] use de::{MapAccess, Unexpected}; @@ -2561,8 +2561,79 @@ where } } -forward_deserializer!(ref StrDeserializer<'a>(&'a str) => visit_str); -forward_deserializer!(borrowed BorrowedStrDeserializer(&'de str) => visit_borrowed_str); +#[derive(Debug)] +pub struct StrDeserializer<'a, E> { + value: &'a str, + marker: PhantomData, +} + +impl<'a, E> StrDeserializer<'a, E> { + pub fn new(value: &'a str) -> Self { + StrDeserializer { + value: value, + marker: PhantomData, + } + } +} + +impl_copy_clone!(StrDeserializer<'a>); + +impl<'de, 'a, E> Deserializer<'de> for StrDeserializer<'a, E> +where + E: Error, +{ + type Error = E; + + fn deserialize_any(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + visitor.visit_str(self.value) + } + + forward_to_deserialize_any! { + bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string + bytes byte_buf option unit unit_struct newtype_struct seq tuple + tuple_struct map struct enum identifier ignored_any + } +} + +#[derive(Debug)] +pub struct BorrowedStrDeserializer<'de, E> { + value: &'de str, + marker: PhantomData, +} + +impl<'de, E> BorrowedStrDeserializer<'de, E> { + pub fn new(value: &'de str) -> Self { + BorrowedStrDeserializer { + value: value, + marker: PhantomData, + } + } +} + +impl_copy_clone!(BorrowedStrDeserializer<'de>); + +impl<'de, E> Deserializer<'de> for BorrowedStrDeserializer<'de, E> +where + E: Error, +{ + type Error = E; + + fn deserialize_any(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + visitor.visit_borrowed_str(self.value) + } + + forward_to_deserialize_any! { + bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string + bytes byte_buf option unit unit_struct newtype_struct seq tuple + tuple_struct map struct enum identifier ignored_any + } +} impl<'a, E> IdentifierDeserializer<'a, E> for &'a str where From 034fe25d5b0a469d4e04459cb2469818fbf8e978 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 23 Jan 2021 12:54:31 -0800 Subject: [PATCH 5/9] Remove redundant unused trait impls from private types from PR #1917 --- serde/src/private/de.rs | 6 ------ 1 file changed, 6 deletions(-) diff --git a/serde/src/private/de.rs b/serde/src/private/de.rs index 6bb6cd44..daf83388 100644 --- a/serde/src/private/de.rs +++ b/serde/src/private/de.rs @@ -2561,7 +2561,6 @@ where } } -#[derive(Debug)] pub struct StrDeserializer<'a, E> { value: &'a str, marker: PhantomData, @@ -2576,8 +2575,6 @@ impl<'a, E> StrDeserializer<'a, E> { } } -impl_copy_clone!(StrDeserializer<'a>); - impl<'de, 'a, E> Deserializer<'de> for StrDeserializer<'a, E> where E: Error, @@ -2598,7 +2595,6 @@ where } } -#[derive(Debug)] pub struct BorrowedStrDeserializer<'de, E> { value: &'de str, marker: PhantomData, @@ -2613,8 +2609,6 @@ impl<'de, E> BorrowedStrDeserializer<'de, E> { } } -impl_copy_clone!(BorrowedStrDeserializer<'de>); - impl<'de, E> Deserializer<'de> for BorrowedStrDeserializer<'de, E> where E: Error, From d02eb2255725fb1d43ec9550d2bf4a28345786d4 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 23 Jan 2021 12:56:45 -0800 Subject: [PATCH 6/9] Inline some unnecessary constructor functions from PR #1917 --- serde/src/private/de.rs | 28 ++++++++-------------------- 1 file changed, 8 insertions(+), 20 deletions(-) diff --git a/serde/src/private/de.rs b/serde/src/private/de.rs index daf83388..fc37b9e5 100644 --- a/serde/src/private/de.rs +++ b/serde/src/private/de.rs @@ -2566,15 +2566,6 @@ pub struct StrDeserializer<'a, E> { marker: PhantomData, } -impl<'a, E> StrDeserializer<'a, E> { - pub fn new(value: &'a str) -> Self { - StrDeserializer { - value: value, - marker: PhantomData, - } - } -} - impl<'de, 'a, E> Deserializer<'de> for StrDeserializer<'a, E> where E: Error, @@ -2600,15 +2591,6 @@ pub struct BorrowedStrDeserializer<'de, E> { marker: PhantomData, } -impl<'de, E> BorrowedStrDeserializer<'de, E> { - pub fn new(value: &'de str) -> Self { - BorrowedStrDeserializer { - value: value, - marker: PhantomData, - } - } -} - impl<'de, E> Deserializer<'de> for BorrowedStrDeserializer<'de, E> where E: Error, @@ -2637,11 +2619,17 @@ where type BorrowedDeserializer = BorrowedStrDeserializer<'a, E>; fn from(self) -> Self::Deserializer { - StrDeserializer::new(self) + StrDeserializer { + value: self, + marker: PhantomData, + } } fn borrowed(self) -> Self::BorrowedDeserializer { - BorrowedStrDeserializer::new(self) + BorrowedStrDeserializer { + value: self, + marker: PhantomData, + } } } From c858a1fa778ae9fd447c18614c06223c7379c8f0 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 23 Jan 2021 12:59:12 -0800 Subject: [PATCH 7/9] Clean up unnecessary macro_use from PR #1917 --- serde/src/de/mod.rs | 1 - serde/src/lib.rs | 1 - 2 files changed, 2 deletions(-) diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs index 1f0c8adc..6d394736 100644 --- a/serde/src/de/mod.rs +++ b/serde/src/de/mod.rs @@ -116,7 +116,6 @@ use lib::*; //////////////////////////////////////////////////////////////////////////////// -#[macro_use] pub mod value; mod from_primitive; diff --git a/serde/src/lib.rs b/serde/src/lib.rs index bc7b9401..8cc8faea 100644 --- a/serde/src/lib.rs +++ b/serde/src/lib.rs @@ -258,7 +258,6 @@ mod macros; #[macro_use] mod integer128; -#[macro_use] pub mod de; pub mod ser; From 85de92e6f7a8acded37569e967ea29a54afa6ed4 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 23 Jan 2021 13:05:21 -0800 Subject: [PATCH 8/9] Inline forward_deserializer for bytes deserializers --- serde/src/de/value.rs | 190 ++++++++++++++++++------------------------ 1 file changed, 82 insertions(+), 108 deletions(-) diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs index 1f878151..6474a2f7 100644 --- a/serde/src/de/value.rs +++ b/serde/src/de/value.rs @@ -44,101 +44,6 @@ macro_rules! impl_copy_clone { }; } -// Creates a deserializer any method of which forwards to the specified visitor -// method. -macro_rules! forward_deserializer { - // Non-borrowed references - ( - $(#[$doc:meta])* - // Actually, * in lifetime should be ?, but that syntax is not supported - // on old Rust versions (<= 1.28) or in 2015 edition - ref $deserializer:ident $(<$lifetime:tt>)* ($ty:ty) => $visit:ident - ) => { - $(#[$doc])* - #[derive(Debug)] - pub struct $deserializer<$($lifetime,)* E> { - value: $ty, - marker: PhantomData, - } - - impl<$($lifetime,)* E> $deserializer<$($lifetime,)* E> { - /// Create a new deserializer from the given value. - pub fn new(value: $ty) -> Self { - $deserializer { - value: value, - marker: PhantomData, - } - } - } - - impl_copy_clone!($deserializer $(<$lifetime>)*); - - impl<'de, $($lifetime,)* E> Deserializer<'de> for $deserializer<$($lifetime,)* E> - where - E: de::Error, - { - type Error = E; - - fn deserialize_any(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.$visit(self.value) - } - - forward_to_deserialize_any! { - bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str - string bytes byte_buf option unit unit_struct newtype_struct seq - tuple tuple_struct map struct enum identifier ignored_any - } - } - }; - // Borrowed references - ( - $(#[$doc:meta])* - borrowed $deserializer:ident($ty:ty) => $visit:ident - ) => { - $(#[$doc])* - #[derive(Debug)] - pub struct $deserializer<'de, E> { - value: $ty, - marker: PhantomData, - } - - impl<'de, E> $deserializer<'de, E> { - /// Create a new borrowed deserializer from the given value. - pub fn new(value: $ty) -> Self { - $deserializer { - value: value, - marker: PhantomData, - } - } - } - - impl_copy_clone!($deserializer<'de>); - - impl<'de, E> Deserializer<'de> for $deserializer<'de, E> - where - E: de::Error, - { - type Error = E; - - fn deserialize_any(self, visitor: V) -> Result - where - V: Visitor<'de>, - { - visitor.$visit(self.value) - } - - forward_to_deserialize_any! { - bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str - string bytes byte_buf option unit unit_struct newtype_struct seq - tuple tuple_struct map struct enum identifier ignored_any - } - } - }; -} - //////////////////////////////////////////////////////////////////////////////// /// A minimal representation of all possible errors that can occur using the @@ -760,19 +665,88 @@ where //////////////////////////////////////////////////////////////////////////////// -forward_deserializer!( - /// A deserializer holding a `&[u8]`. Always call [`Visitor::visit_bytes`] - /// - /// [`Visitor::visit_bytes`]: ../struct.Visitor.html#method.visit_bytes - ref BytesDeserializer<'a>(&'a [u8]) => visit_bytes -); -forward_deserializer!( - /// A deserializer holding a `&[u8]` with a lifetime tied to another - /// deserializer. Always call [`Visitor::visit_borrowed_bytes`] - /// - /// [`Visitor::visit_borrowed_bytes`]: ../struct.Visitor.html#method.visit_borrowed_bytes - borrowed BorrowedBytesDeserializer(&'de [u8]) => visit_borrowed_bytes -); +/// A deserializer holding a `&[u8]`. Always call [`Visitor::visit_bytes`] +/// +/// [`Visitor::visit_bytes`]: ../struct.Visitor.html#method.visit_bytes +#[derive(Debug)] +pub struct BytesDeserializer<'a, E> { + value: &'a [u8], + marker: PhantomData, +} + +impl<'a, E> BytesDeserializer<'a, E> { + /// Create a new deserializer from the given value. + pub fn new(value: &'a [u8]) -> Self { + BytesDeserializer { + value: value, + marker: PhantomData, + } + } +} + +impl_copy_clone!(BytesDeserializer<'a>); + +impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E> +where + E: de::Error, +{ + type Error = E; + + fn deserialize_any(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + visitor.visit_bytes(self.value) + } + + forward_to_deserialize_any! { + bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string + bytes byte_buf option unit unit_struct newtype_struct seq tuple + tuple_struct map struct enum identifier ignored_any + } +} + +/// A deserializer holding a `&[u8]` with a lifetime tied to another +/// deserializer. Always call [`Visitor::visit_borrowed_bytes`] +/// +/// [`Visitor::visit_borrowed_bytes`]: ../struct.Visitor.html#method.visit_borrowed_bytes +#[derive(Debug)] +pub struct BorrowedBytesDeserializer<'de, E> { + value: &'de [u8], + marker: PhantomData, +} + +impl<'de, E> BorrowedBytesDeserializer<'de, E> { + /// Create a new borrowed deserializer from the given value. + pub fn new(value: &'de [u8]) -> Self { + BorrowedBytesDeserializer { + value: value, + marker: PhantomData, + } + } +} + +impl_copy_clone!(BorrowedBytesDeserializer<'de>); + +impl<'de, E> Deserializer<'de> for BorrowedBytesDeserializer<'de, E> +where + E: de::Error, +{ + type Error = E; + + fn deserialize_any(self, visitor: V) -> Result + where + V: Visitor<'de>, + { + visitor.visit_borrowed_bytes(self.value) + } + + forward_to_deserialize_any! { + bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string + bytes byte_buf option unit unit_struct newtype_struct seq tuple + tuple_struct map struct enum identifier ignored_any + } +} //////////////////////////////////////////////////////////////////////////////// From 0b5c56b0db81ad9d045cd8dfc6440e9578ace76c Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 23 Jan 2021 13:08:35 -0800 Subject: [PATCH 9/9] Touch up documentation from PR #1917 --- serde/src/de/value.rs | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs index 6474a2f7..e2f24118 100644 --- a/serde/src/de/value.rs +++ b/serde/src/de/value.rs @@ -665,9 +665,7 @@ where //////////////////////////////////////////////////////////////////////////////// -/// A deserializer holding a `&[u8]`. Always call [`Visitor::visit_bytes`] -/// -/// [`Visitor::visit_bytes`]: ../struct.Visitor.html#method.visit_bytes +/// A deserializer holding a `&[u8]`. Always calls [`Visitor::visit_bytes`]. #[derive(Debug)] pub struct BytesDeserializer<'a, E> { value: &'a [u8], @@ -675,7 +673,7 @@ pub struct BytesDeserializer<'a, E> { } impl<'a, E> BytesDeserializer<'a, E> { - /// Create a new deserializer from the given value. + /// Create a new deserializer from the given bytes. pub fn new(value: &'a [u8]) -> Self { BytesDeserializer { value: value, @@ -707,9 +705,7 @@ where } /// A deserializer holding a `&[u8]` with a lifetime tied to another -/// deserializer. Always call [`Visitor::visit_borrowed_bytes`] -/// -/// [`Visitor::visit_borrowed_bytes`]: ../struct.Visitor.html#method.visit_borrowed_bytes +/// deserializer. Always calls [`Visitor::visit_borrowed_bytes`]. #[derive(Debug)] pub struct BorrowedBytesDeserializer<'de, E> { value: &'de [u8], @@ -717,7 +713,7 @@ pub struct BorrowedBytesDeserializer<'de, E> { } impl<'de, E> BorrowedBytesDeserializer<'de, E> { - /// Create a new borrowed deserializer from the given value. + /// Create a new borrowed deserializer from the given borrowed bytes. pub fn new(value: &'de [u8]) -> Self { BorrowedBytesDeserializer { value: value,