From c13a37d4db1cbfcb47f4e62fb5c5f41a716a844f Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Sat, 15 Apr 2017 12:35:04 -0700 Subject: [PATCH] Rename VariantAccess methods to not conflict with Deserializer --- serde/src/de/impls.rs | 12 +++++------ serde/src/de/mod.rs | 46 ++++++++++++++++++++--------------------- serde/src/de/value.rs | 8 +++---- serde/src/private/de.rs | 16 +++++++------- serde_derive/src/de.rs | 10 ++++----- serde_test/src/de.rs | 8 +++---- 6 files changed, 49 insertions(+), 51 deletions(-) diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs index 37381ca0..6e4c6502 100644 --- a/serde/src/de/impls.rs +++ b/serde/src/de/impls.rs @@ -1025,7 +1025,7 @@ impl<'de> Visitor<'de> for OsStringVisitor { use std::os::unix::ffi::OsStringExt; match try!(data.variant()) { - (OsStringKind::Unix, variant) => variant.deserialize_newtype().map(OsString::from_vec), + (OsStringKind::Unix, v) => v.newtype_variant().map(OsString::from_vec), (OsStringKind::Windows, _) => Err(Error::custom("cannot deserialize Windows OS string on Unix",),), } } @@ -1038,10 +1038,8 @@ impl<'de> Visitor<'de> for OsStringVisitor { use std::os::windows::ffi::OsStringExt; match try!(data.variant()) { - (OsStringKind::Windows, variant) => { - variant - .deserialize_newtype::>() - .map(|vec| OsString::from_wide(&vec)) + (OsStringKind::Windows, v) => { + v.newtype_variant::>().map(|vec| OsString::from_wide(&vec)) } (OsStringKind::Unix, _) => Err(Error::custom("cannot deserialize Unix OS string on Windows",),), } @@ -1539,8 +1537,8 @@ where A: EnumAccess<'de>, { match try!(data.variant()) { - (Field::Ok, variant) => variant.deserialize_newtype().map(Ok), - (Field::Err, variant) => variant.deserialize_newtype().map(Err), + (Field::Ok, v) => v.newtype_variant().map(Ok), + (Field::Err, v) => v.newtype_variant().map(Err), } } } diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs index ab361854..79ecd9b0 100644 --- a/serde/src/de/mod.rs +++ b/serde/src/de/mod.rs @@ -1697,31 +1697,31 @@ pub trait VariantAccess<'de>: Sized { /// # impl<'de> VariantAccess<'de> for X { /// # type Error = value::Error; /// # - /// fn deserialize_unit(self) -> Result<(), Self::Error> { + /// fn unit_variant(self) -> Result<(), Self::Error> { /// // What the data actually contained; suppose it is a tuple variant. /// let unexp = Unexpected::TupleVariant; /// Err(de::Error::invalid_type(unexp, &"unit variant")) /// } /// # - /// # fn deserialize_newtype_seed(self, _: T) -> Result + /// # fn newtype_variant_seed(self, _: T) -> Result /// # where T: DeserializeSeed<'de> /// # { unimplemented!() } /// # - /// # fn deserialize_tuple(self, _: usize, _: V) -> Result + /// # fn tuple_variant(self, _: usize, _: V) -> Result /// # where V: Visitor<'de> /// # { unimplemented!() } /// # - /// # fn deserialize_struct(self, _: &[&str], _: V) -> Result + /// # fn struct_variant(self, _: &[&str], _: V) -> Result /// # where V: Visitor<'de> /// # { unimplemented!() } /// # } /// ``` - fn deserialize_unit(self) -> Result<(), Self::Error>; + fn unit_variant(self) -> Result<(), Self::Error>; /// Called when deserializing a variant with a single value. /// /// `Deserialize` implementations should typically use - /// `VariantAccess::deserialize_newtype` instead. + /// `VariantAccess::newtype_variant` instead. /// /// If the data contains a different type of variant, the following /// `invalid_type` error should be constructed: @@ -1734,11 +1734,11 @@ pub trait VariantAccess<'de>: Sized { /// # impl<'de> VariantAccess<'de> for X { /// # type Error = value::Error; /// # - /// # fn deserialize_unit(self) -> Result<(), Self::Error> { + /// # fn unit_variant(self) -> Result<(), Self::Error> { /// # unimplemented!() /// # } /// # - /// fn deserialize_newtype_seed(self, _seed: T) -> Result + /// fn newtype_variant_seed(self, _seed: T) -> Result /// where T: DeserializeSeed<'de> /// { /// // What the data actually contained; suppose it is a unit variant. @@ -1746,16 +1746,16 @@ pub trait VariantAccess<'de>: Sized { /// Err(de::Error::invalid_type(unexp, &"newtype variant")) /// } /// # - /// # fn deserialize_tuple(self, _: usize, _: V) -> Result + /// # fn tuple_variant(self, _: usize, _: V) -> Result /// # where V: Visitor<'de> /// # { unimplemented!() } /// # - /// # fn deserialize_struct(self, _: &[&str], _: V) -> Result + /// # fn struct_variant(self, _: &[&str], _: V) -> Result /// # where V: Visitor<'de> /// # { unimplemented!() } /// # } /// ``` - fn deserialize_newtype_seed(self, seed: T) -> Result + fn newtype_variant_seed(self, seed: T) -> Result where T: DeserializeSeed<'de>; @@ -1765,11 +1765,11 @@ pub trait VariantAccess<'de>: Sized { /// `VariantAccess` implementations should not override the default /// behavior. #[inline] - fn deserialize_newtype(self) -> Result + fn newtype_variant(self) -> Result where T: Deserialize<'de>, { - self.deserialize_newtype_seed(PhantomData) + self.newtype_variant_seed(PhantomData) } /// Called when deserializing a tuple-like variant. @@ -1787,15 +1787,15 @@ pub trait VariantAccess<'de>: Sized { /// # impl<'de> VariantAccess<'de> for X { /// # type Error = value::Error; /// # - /// # fn deserialize_unit(self) -> Result<(), Self::Error> { + /// # fn unit_variant(self) -> Result<(), Self::Error> { /// # unimplemented!() /// # } /// # - /// # fn deserialize_newtype_seed(self, _: T) -> Result + /// # fn newtype_variant_seed(self, _: T) -> Result /// # where T: DeserializeSeed<'de> /// # { unimplemented!() } /// # - /// fn deserialize_tuple(self, + /// fn tuple_variant(self, /// _len: usize, /// _visitor: V) -> Result /// where V: Visitor<'de> @@ -1805,12 +1805,12 @@ pub trait VariantAccess<'de>: Sized { /// Err(de::Error::invalid_type(unexp, &"tuple variant")) /// } /// # - /// # fn deserialize_struct(self, _: &[&str], _: V) -> Result + /// # fn struct_variant(self, _: &[&str], _: V) -> Result /// # where V: Visitor<'de> /// # { unimplemented!() } /// # } /// ``` - fn deserialize_tuple(self, len: usize, visitor: V) -> Result + fn tuple_variant(self, len: usize, visitor: V) -> Result where V: Visitor<'de>; @@ -1829,19 +1829,19 @@ pub trait VariantAccess<'de>: Sized { /// # impl<'de> VariantAccess<'de> for X { /// # type Error = value::Error; /// # - /// # fn deserialize_unit(self) -> Result<(), Self::Error> { + /// # fn unit_variant(self) -> Result<(), Self::Error> { /// # unimplemented!() /// # } /// # - /// # fn deserialize_newtype_seed(self, _: T) -> Result + /// # fn newtype_variant_seed(self, _: T) -> Result /// # where T: DeserializeSeed<'de> /// # { unimplemented!() } /// # - /// # fn deserialize_tuple(self, _: usize, _: V) -> Result + /// # fn tuple_variant(self, _: usize, _: V) -> Result /// # where V: Visitor<'de> /// # { unimplemented!() } /// # - /// fn deserialize_struct(self, + /// fn struct_variant(self, /// _fields: &'static [&'static str], /// _visitor: V) -> Result /// where V: Visitor<'de> @@ -1852,7 +1852,7 @@ pub trait VariantAccess<'de>: Sized { /// } /// # } /// ``` - fn deserialize_struct( + fn struct_variant( self, fields: &'static [&'static str], visitor: V, diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs index ffedb3ef..97c55881 100644 --- a/serde/src/de/value.rs +++ b/serde/src/de/value.rs @@ -1120,25 +1120,25 @@ mod private { { type Error = E; - fn deserialize_unit(self) -> Result<(), Self::Error> { + fn unit_variant(self) -> Result<(), Self::Error> { Ok(()) } - fn deserialize_newtype_seed(self, _seed: T) -> Result + fn newtype_variant_seed(self, _seed: T) -> Result where T: de::DeserializeSeed<'de>, { Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"),) } - fn deserialize_tuple(self, _len: usize, _visitor: V) -> Result + fn tuple_variant(self, _len: usize, _visitor: V) -> Result where V: de::Visitor<'de>, { Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"),) } - fn deserialize_struct( + fn struct_variant( self, _fields: &'static [&'static str], _visitor: V, diff --git a/serde/src/private/de.rs b/serde/src/private/de.rs index 52d2c143..75111321 100644 --- a/serde/src/private/de.rs +++ b/serde/src/private/de.rs @@ -1056,14 +1056,14 @@ mod content { { type Error = E; - fn deserialize_unit(self) -> Result<(), E> { + fn unit_variant(self) -> Result<(), E> { match self.value { Some(value) => de::Deserialize::deserialize(ContentDeserializer::new(value)), None => Ok(()), } } - fn deserialize_newtype_seed(self, seed: T) -> Result + fn newtype_variant_seed(self, seed: T) -> Result where T: de::DeserializeSeed<'de>, { @@ -1075,7 +1075,7 @@ mod content { } } - fn deserialize_tuple(self, _len: usize, visitor: V) -> Result + fn tuple_variant(self, _len: usize, visitor: V) -> Result where V: de::Visitor<'de>, { @@ -1088,7 +1088,7 @@ mod content { } } - fn deserialize_struct( + fn struct_variant( self, _fields: &'static [&'static str], visitor: V, @@ -1448,14 +1448,14 @@ mod content { { type Error = E; - fn deserialize_unit(self) -> Result<(), E> { + fn unit_variant(self) -> Result<(), E> { match self.value { Some(value) => de::Deserialize::deserialize(ContentRefDeserializer::new(value)), None => Ok(()), } } - fn deserialize_newtype_seed(self, seed: T) -> Result + fn newtype_variant_seed(self, seed: T) -> Result where T: de::DeserializeSeed<'de>, { @@ -1467,7 +1467,7 @@ mod content { } } - fn deserialize_tuple(self, _len: usize, visitor: V) -> Result + fn tuple_variant(self, _len: usize, visitor: V) -> Result where V: de::Visitor<'de>, { @@ -1480,7 +1480,7 @@ mod content { } } - fn deserialize_struct( + fn struct_variant( self, _fields: &'static [&'static str], visitor: V, diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs index 79304878..c0b32f36 100644 --- a/serde_derive/src/de.rs +++ b/serde_derive/src/de.rs @@ -299,7 +299,7 @@ fn deserialize_tuple( let dispatch = if let Some(deserializer) = deserializer { quote!(_serde::Deserializer::deserialize_tuple(#deserializer, #nfields, #visitor_expr)) } else if is_enum { - quote!(_serde::de::VariantAccess::deserialize_tuple(__variant, #nfields, #visitor_expr)) + quote!(_serde::de::VariantAccess::tuple_variant(__variant, #nfields, #visitor_expr)) } else if nfields == 1 { let type_name = cattrs.name().deserialize_name(); quote!(_serde::Deserializer::deserialize_newtype_struct(__deserializer, #type_name, #visitor_expr)) @@ -508,7 +508,7 @@ fn deserialize_struct( } } else if is_enum { quote! { - _serde::de::VariantAccess::deserialize_struct(__variant, FIELDS, #visitor_expr) + _serde::de::VariantAccess::struct_variant(__variant, FIELDS, #visitor_expr) } } else { let type_name = cattrs.name().deserialize_name(); @@ -1048,7 +1048,7 @@ fn deserialize_externally_tagged_variant( Style::Unit => { let this = ¶ms.this; quote_block! { - try!(_serde::de::VariantAccess::deserialize_unit(__variant)); + try!(_serde::de::VariantAccess::unit_variant(__variant)); _serde::export::Ok(#this::#variant_ident) } } @@ -1163,7 +1163,7 @@ fn deserialize_externally_tagged_newtype_variant( let field_ty = &field.ty; quote_expr! { _serde::export::Result::map( - _serde::de::VariantAccess::deserialize_newtype::<#field_ty>(__variant), + _serde::de::VariantAccess::newtype_variant::<#field_ty>(__variant), #this::#variant_ident) } } @@ -1172,7 +1172,7 @@ fn deserialize_externally_tagged_newtype_variant( quote_block! { #wrapper _serde::export::Result::map( - _serde::de::VariantAccess::deserialize_newtype::<#wrapper_ty>(__variant), + _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant), |__wrapper| #this::#variant_ident(__wrapper.value)) } } diff --git a/serde_test/src/de.rs b/serde_test/src/de.rs index 7139dbac..9b5fc85a 100644 --- a/serde_test/src/de.rs +++ b/serde_test/src/de.rs @@ -478,7 +478,7 @@ impl<'de, 'a> EnumAccess<'de> for DeserializerEnumVisitor<'a, 'de> { impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> { type Error = Error; - fn deserialize_unit(self) -> Result<(), Error> { + fn unit_variant(self) -> Result<(), Error> { match self.de.tokens.first() { Some(&Token::UnitVariant(_, _)) => { self.de.next_token(); @@ -489,7 +489,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> { } } - fn deserialize_newtype_seed(self, seed: T) -> Result + fn newtype_variant_seed(self, seed: T) -> Result where T: DeserializeSeed<'de>, { @@ -503,7 +503,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> { } } - fn deserialize_tuple(self, len: usize, visitor: V) -> Result + fn tuple_variant(self, len: usize, visitor: V) -> Result where V: Visitor<'de>, { @@ -532,7 +532,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> { } } - fn deserialize_struct(self, fields: &'static [&'static str], visitor: V) -> Result + fn struct_variant(self, fields: &'static [&'static str], visitor: V) -> Result where V: Visitor<'de>, {