diff --git a/test_suite/tests/expand/derive/enum/de_enum.expanded.rs b/test_suite/tests/expand/derive/enum/de_enum.expanded.rs new file mode 100644 index 00000000..224a5468 --- /dev/null +++ b/test_suite/tests/expand/derive/enum/de_enum.expanded.rs @@ -0,0 +1,1373 @@ +use serde::Deserialize; +enum DeEnum { + Unit, + Seq(i8, B, C, D), + Map { a: i8, b: B, c: C, d: D }, + _Unit2, + _Seq2(i8, B, C, D), + _Map2 { a: i8, b: B, c: C, d: D }, +} +#[automatically_derived] +#[allow(unused_qualifications)] +impl ::core::fmt::Debug + for DeEnum +{ + fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result { + match (&*self,) { + (&DeEnum::Unit,) => { + let mut debug_trait_builder = f.debug_tuple("Unit"); + debug_trait_builder.finish() + } + (&DeEnum::Seq(ref __self_0, ref __self_1, ref __self_2, ref __self_3),) => { + let mut debug_trait_builder = f.debug_tuple("Seq"); + let _ = debug_trait_builder.field(&&(*__self_0)); + let _ = debug_trait_builder.field(&&(*__self_1)); + let _ = debug_trait_builder.field(&&(*__self_2)); + let _ = debug_trait_builder.field(&&(*__self_3)); + debug_trait_builder.finish() + } + (&DeEnum::Map { + a: ref __self_0, + b: ref __self_1, + c: ref __self_2, + d: ref __self_3, + },) => { + let mut debug_trait_builder = f.debug_struct("Map"); + let _ = debug_trait_builder.field("a", &&(*__self_0)); + let _ = debug_trait_builder.field("b", &&(*__self_1)); + let _ = debug_trait_builder.field("c", &&(*__self_2)); + let _ = debug_trait_builder.field("d", &&(*__self_3)); + debug_trait_builder.finish() + } + (&DeEnum::_Unit2,) => { + let mut debug_trait_builder = f.debug_tuple("_Unit2"); + debug_trait_builder.finish() + } + (&DeEnum::_Seq2(ref __self_0, ref __self_1, ref __self_2, ref __self_3),) => { + let mut debug_trait_builder = f.debug_tuple("_Seq2"); + let _ = debug_trait_builder.field(&&(*__self_0)); + let _ = debug_trait_builder.field(&&(*__self_1)); + let _ = debug_trait_builder.field(&&(*__self_2)); + let _ = debug_trait_builder.field(&&(*__self_3)); + debug_trait_builder.finish() + } + (&DeEnum::_Map2 { + a: ref __self_0, + b: ref __self_1, + c: ref __self_2, + d: ref __self_3, + },) => { + let mut debug_trait_builder = f.debug_struct("_Map2"); + let _ = debug_trait_builder.field("a", &&(*__self_0)); + let _ = debug_trait_builder.field("b", &&(*__self_1)); + let _ = debug_trait_builder.field("c", &&(*__self_2)); + let _ = debug_trait_builder.field("d", &&(*__self_3)); + debug_trait_builder.finish() + } + } + } +} +impl ::core::marker::StructuralPartialEq for DeEnum {} +#[automatically_derived] +#[allow(unused_qualifications)] +impl + ::core::cmp::PartialEq for DeEnum +{ + #[inline] + fn eq(&self, other: &DeEnum) -> bool { + { + let __self_vi = unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize; + let __arg_1_vi = unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + ( + &DeEnum::Seq(ref __self_0, ref __self_1, ref __self_2, ref __self_3), + &DeEnum::Seq(ref __arg_1_0, ref __arg_1_1, ref __arg_1_2, ref __arg_1_3), + ) => { + (*__self_0) == (*__arg_1_0) + && (*__self_1) == (*__arg_1_1) + && (*__self_2) == (*__arg_1_2) + && (*__self_3) == (*__arg_1_3) + } + ( + &DeEnum::Map { + a: ref __self_0, + b: ref __self_1, + c: ref __self_2, + d: ref __self_3, + }, + &DeEnum::Map { + a: ref __arg_1_0, + b: ref __arg_1_1, + c: ref __arg_1_2, + d: ref __arg_1_3, + }, + ) => { + (*__self_0) == (*__arg_1_0) + && (*__self_1) == (*__arg_1_1) + && (*__self_2) == (*__arg_1_2) + && (*__self_3) == (*__arg_1_3) + } + ( + &DeEnum::_Seq2(ref __self_0, ref __self_1, ref __self_2, ref __self_3), + &DeEnum::_Seq2(ref __arg_1_0, ref __arg_1_1, ref __arg_1_2, ref __arg_1_3), + ) => { + (*__self_0) == (*__arg_1_0) + && (*__self_1) == (*__arg_1_1) + && (*__self_2) == (*__arg_1_2) + && (*__self_3) == (*__arg_1_3) + } + ( + &DeEnum::_Map2 { + a: ref __self_0, + b: ref __self_1, + c: ref __self_2, + d: ref __self_3, + }, + &DeEnum::_Map2 { + a: ref __arg_1_0, + b: ref __arg_1_1, + c: ref __arg_1_2, + d: ref __arg_1_3, + }, + ) => { + (*__self_0) == (*__arg_1_0) + && (*__self_1) == (*__arg_1_1) + && (*__self_2) == (*__arg_1_2) + && (*__self_3) == (*__arg_1_3) + } + _ => true, + } + } else { + false + } + } + } + #[inline] + fn ne(&self, other: &DeEnum) -> bool { + { + let __self_vi = unsafe { ::core::intrinsics::discriminant_value(&*self) } as isize; + let __arg_1_vi = unsafe { ::core::intrinsics::discriminant_value(&*other) } as isize; + if true && __self_vi == __arg_1_vi { + match (&*self, &*other) { + ( + &DeEnum::Seq(ref __self_0, ref __self_1, ref __self_2, ref __self_3), + &DeEnum::Seq(ref __arg_1_0, ref __arg_1_1, ref __arg_1_2, ref __arg_1_3), + ) => { + (*__self_0) != (*__arg_1_0) + || (*__self_1) != (*__arg_1_1) + || (*__self_2) != (*__arg_1_2) + || (*__self_3) != (*__arg_1_3) + } + ( + &DeEnum::Map { + a: ref __self_0, + b: ref __self_1, + c: ref __self_2, + d: ref __self_3, + }, + &DeEnum::Map { + a: ref __arg_1_0, + b: ref __arg_1_1, + c: ref __arg_1_2, + d: ref __arg_1_3, + }, + ) => { + (*__self_0) != (*__arg_1_0) + || (*__self_1) != (*__arg_1_1) + || (*__self_2) != (*__arg_1_2) + || (*__self_3) != (*__arg_1_3) + } + ( + &DeEnum::_Seq2(ref __self_0, ref __self_1, ref __self_2, ref __self_3), + &DeEnum::_Seq2(ref __arg_1_0, ref __arg_1_1, ref __arg_1_2, ref __arg_1_3), + ) => { + (*__self_0) != (*__arg_1_0) + || (*__self_1) != (*__arg_1_1) + || (*__self_2) != (*__arg_1_2) + || (*__self_3) != (*__arg_1_3) + } + ( + &DeEnum::_Map2 { + a: ref __self_0, + b: ref __self_1, + c: ref __self_2, + d: ref __self_3, + }, + &DeEnum::_Map2 { + a: ref __arg_1_0, + b: ref __arg_1_1, + c: ref __arg_1_2, + d: ref __arg_1_3, + }, + ) => { + (*__self_0) != (*__arg_1_0) + || (*__self_1) != (*__arg_1_1) + || (*__self_2) != (*__arg_1_2) + || (*__self_3) != (*__arg_1_3) + } + _ => false, + } + } else { + true + } + } + } +} +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_DESERIALIZE_FOR_DeEnum: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de, B, C, D> _serde::Deserialize<'de> for DeEnum + where + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + D: _serde::Deserialize<'de>, + { + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __field4, + __field5, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "variant identifier") + } + fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + 2u64 => _serde::export::Ok(__Field::__field2), + 3u64 => _serde::export::Ok(__Field::__field3), + 4u64 => _serde::export::Ok(__Field::__field4), + 5u64 => _serde::export::Ok(__Field::__field5), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 6", + )), + } + } + fn visit_str<__E>(self, __value: &str) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "Unit" => _serde::export::Ok(__Field::__field0), + "Seq" => _serde::export::Ok(__Field::__field1), + "Map" => _serde::export::Ok(__Field::__field2), + "_Unit2" => _serde::export::Ok(__Field::__field3), + "_Seq2" => _serde::export::Ok(__Field::__field4), + "_Map2" => _serde::export::Ok(__Field::__field5), + _ => _serde::export::Err(_serde::de::Error::unknown_variant( + __value, VARIANTS, + )), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"Unit" => _serde::export::Ok(__Field::__field0), + b"Seq" => _serde::export::Ok(__Field::__field1), + b"Map" => _serde::export::Ok(__Field::__field2), + b"_Unit2" => _serde::export::Ok(__Field::__field3), + b"_Seq2" => _serde::export::Ok(__Field::__field4), + b"_Map2" => _serde::export::Ok(__Field::__field5), + _ => { + let __value = &_serde::export::from_utf8_lossy(__value); + _serde::export::Err(_serde::de::Error::unknown_variant( + __value, VARIANTS, + )) + } + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor) + } + } + struct __Visitor<'de, B, C, D> + where + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + D: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, B, C, D> _serde::de::Visitor<'de> for __Visitor<'de, B, C, D> + where + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + D: _serde::Deserialize<'de>, + { + type Value = DeEnum; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "enum DeEnum") + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::export::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match match _serde::de::EnumAccess::variant(__data) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + (__Field::__field0, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(DeEnum::Unit) + } + (__Field::__field1, __variant) => { + struct __Visitor<'de, B, C, D> + where + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + D: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, B, C, D> _serde::de::Visitor<'de> for __Visitor<'de, B, C, D> + where + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + D: _serde::Deserialize<'de>, + { + type Value = DeEnum; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "tuple variant DeEnum::Seq", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::< + i8, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 0usize, + &"tuple variant DeEnum::Seq with 4 elements", + ), + ); + } + }; + let __field1 = match match _serde::de::SeqAccess::next_element::< + B, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 1usize, + &"tuple variant DeEnum::Seq with 4 elements", + ), + ); + } + }; + let __field2 = match match _serde::de::SeqAccess::next_element::< + C, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 2usize, + &"tuple variant DeEnum::Seq with 4 elements", + ), + ); + } + }; + let __field3 = match match _serde::de::SeqAccess::next_element::< + D, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 3usize, + &"tuple variant DeEnum::Seq with 4 elements", + ), + ); + } + }; + _serde::export::Ok(DeEnum::Seq( + __field0, __field1, __field2, __field3, + )) + } + } + _serde::de::VariantAccess::tuple_variant( + __variant, + 4usize, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + (__Field::__field2, __variant) => { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + 2u64 => _serde::export::Ok(__Field::__field2), + 3u64 => _serde::export::Ok(__Field::__field3), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 4", + )), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "a" => _serde::export::Ok(__Field::__field0), + "b" => _serde::export::Ok(__Field::__field1), + "c" => _serde::export::Ok(__Field::__field2), + "d" => _serde::export::Ok(__Field::__field3), + _ => _serde::export::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"a" => _serde::export::Ok(__Field::__field0), + b"b" => _serde::export::Ok(__Field::__field1), + b"c" => _serde::export::Ok(__Field::__field2), + b"d" => _serde::export::Ok(__Field::__field3), + _ => _serde::export::Ok(__Field::__ignore), + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + struct __Visitor<'de, B, C, D> + where + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + D: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, B, C, D> _serde::de::Visitor<'de> for __Visitor<'de, B, C, D> + where + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + D: _serde::Deserialize<'de>, + { + type Value = DeEnum; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "struct variant DeEnum::Map", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::< + i8, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct variant DeEnum::Map with 4 elements", + ), + ); + } + }; + let __field1 = match match _serde::de::SeqAccess::next_element::< + B, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct variant DeEnum::Map with 4 elements", + ), + ); + } + }; + let __field2 = match match _serde::de::SeqAccess::next_element::< + C, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct variant DeEnum::Map with 4 elements", + ), + ); + } + }; + let __field3 = match match _serde::de::SeqAccess::next_element::< + D, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct variant DeEnum::Map with 4 elements", + ), + ); + } + }; + _serde::export::Ok(DeEnum::Map { + a: __field0, + b: __field1, + c: __field2, + d: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::export::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::export::Option = + _serde::export::None; + let mut __field1: _serde::export::Option = + _serde::export::None; + let mut __field2: _serde::export::Option = + _serde::export::None; + let mut __field3: _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) { + return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "a" ) ) ; + } + __field0 = _serde::export::Some( + match _serde::de::MapAccess::next_value::( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) { + return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "b" ) ) ; + } + __field1 = _serde::export::Some( + match _serde::de::MapAccess::next_value::( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) { + return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "c" ) ) ; + } + __field2 = _serde::export::Some( + match _serde::de::MapAccess::next_value::( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) { + return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "d" ) ) ; + } + __field3 = _serde::export::Some( + match _serde::de::MapAccess::next_value::( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + _ => { + let _ = match _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >( + &mut __map + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = match __field0 { + _serde::export::Some(__field0) => __field0, + _serde::export::None => { + match _serde::private::de::missing_field("a") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + } + }; + let __field1 = match __field1 { + _serde::export::Some(__field1) => __field1, + _serde::export::None => { + match _serde::private::de::missing_field("b") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + } + }; + let __field2 = match __field2 { + _serde::export::Some(__field2) => __field2, + _serde::export::None => { + match _serde::private::de::missing_field("c") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + } + }; + let __field3 = match __field3 { + _serde::export::Some(__field3) => __field3, + _serde::export::None => { + match _serde::private::de::missing_field("d") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + } + }; + _serde::export::Ok(DeEnum::Map { + a: __field0, + b: __field1, + c: __field2, + d: __field3, + }) + } + } + const FIELDS: &'static [&'static str] = &["a", "b", "c", "d"]; + _serde::de::VariantAccess::struct_variant( + __variant, + FIELDS, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + (__Field::__field3, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(DeEnum::_Unit2) + } + (__Field::__field4, __variant) => { + struct __Visitor<'de, B, C, D> + where + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + D: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, B, C, D> _serde::de::Visitor<'de> for __Visitor<'de, B, C, D> + where + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + D: _serde::Deserialize<'de>, + { + type Value = DeEnum; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "tuple variant DeEnum::_Seq2", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::< + i8, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 0usize, + &"tuple variant DeEnum::_Seq2 with 4 elements", + ), + ); + } + }; + let __field1 = match match _serde::de::SeqAccess::next_element::< + B, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 1usize, + &"tuple variant DeEnum::_Seq2 with 4 elements", + ), + ); + } + }; + let __field2 = match match _serde::de::SeqAccess::next_element::< + C, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 2usize, + &"tuple variant DeEnum::_Seq2 with 4 elements", + ), + ); + } + }; + let __field3 = match match _serde::de::SeqAccess::next_element::< + D, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 3usize, + &"tuple variant DeEnum::_Seq2 with 4 elements", + ), + ); + } + }; + _serde::export::Ok(DeEnum::_Seq2( + __field0, __field1, __field2, __field3, + )) + } + } + _serde::de::VariantAccess::tuple_variant( + __variant, + 4usize, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + (__Field::__field5, __variant) => { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + __ignore, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + 2u64 => _serde::export::Ok(__Field::__field2), + 3u64 => _serde::export::Ok(__Field::__field3), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 4", + )), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "a" => _serde::export::Ok(__Field::__field0), + "b" => _serde::export::Ok(__Field::__field1), + "c" => _serde::export::Ok(__Field::__field2), + "d" => _serde::export::Ok(__Field::__field3), + _ => _serde::export::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"a" => _serde::export::Ok(__Field::__field0), + b"b" => _serde::export::Ok(__Field::__field1), + b"c" => _serde::export::Ok(__Field::__field2), + b"d" => _serde::export::Ok(__Field::__field3), + _ => _serde::export::Ok(__Field::__ignore), + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + struct __Visitor<'de, B, C, D> + where + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + D: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, B, C, D> _serde::de::Visitor<'de> for __Visitor<'de, B, C, D> + where + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + D: _serde::Deserialize<'de>, + { + type Value = DeEnum; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "struct variant DeEnum::_Map2", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::< + i8, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 0usize, + &"struct variant DeEnum::_Map2 with 4 elements", + ), + ); + } + }; + let __field1 = match match _serde::de::SeqAccess::next_element::< + B, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 1usize, + &"struct variant DeEnum::_Map2 with 4 elements", + ), + ); + } + }; + let __field2 = match match _serde::de::SeqAccess::next_element::< + C, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 2usize, + &"struct variant DeEnum::_Map2 with 4 elements", + ), + ); + } + }; + let __field3 = match match _serde::de::SeqAccess::next_element::< + D, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err( + _serde::de::Error::invalid_length( + 3usize, + &"struct variant DeEnum::_Map2 with 4 elements", + ), + ); + } + }; + _serde::export::Ok(DeEnum::_Map2 { + a: __field0, + b: __field1, + c: __field2, + d: __field3, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::export::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::export::Option = + _serde::export::None; + let mut __field1: _serde::export::Option = + _serde::export::None; + let mut __field2: _serde::export::Option = + _serde::export::None; + let mut __field3: _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) { + return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "a" ) ) ; + } + __field0 = _serde::export::Some( + match _serde::de::MapAccess::next_value::( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) { + return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "b" ) ) ; + } + __field1 = _serde::export::Some( + match _serde::de::MapAccess::next_value::( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) { + return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "c" ) ) ; + } + __field2 = _serde::export::Some( + match _serde::de::MapAccess::next_value::( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + __Field::__field3 => { + if _serde::export::Option::is_some(&__field3) { + return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "d" ) ) ; + } + __field3 = _serde::export::Some( + match _serde::de::MapAccess::next_value::( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + _ => { + let _ = match _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >( + &mut __map + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = match __field0 { + _serde::export::Some(__field0) => __field0, + _serde::export::None => { + match _serde::private::de::missing_field("a") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + } + }; + let __field1 = match __field1 { + _serde::export::Some(__field1) => __field1, + _serde::export::None => { + match _serde::private::de::missing_field("b") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + } + }; + let __field2 = match __field2 { + _serde::export::Some(__field2) => __field2, + _serde::export::None => { + match _serde::private::de::missing_field("c") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + } + }; + let __field3 = match __field3 { + _serde::export::Some(__field3) => __field3, + _serde::export::None => { + match _serde::private::de::missing_field("d") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + } + }; + _serde::export::Ok(DeEnum::_Map2 { + a: __field0, + b: __field1, + c: __field2, + d: __field3, + }) + } + } + const FIELDS: &'static [&'static str] = &["a", "b", "c", "d"]; + _serde::de::VariantAccess::struct_variant( + __variant, + FIELDS, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + } + } + } + const VARIANTS: &'static [&'static str] = + &["Unit", "Seq", "Map", "_Unit2", "_Seq2", "_Map2"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "DeEnum", + VARIANTS, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + } +}; \ No newline at end of file diff --git a/test_suite/tests/expand/derive/enum/generic_enum.expanded.rs b/test_suite/tests/expand/derive/enum/generic_enum.expanded.rs new file mode 100644 index 00000000..2248d30f --- /dev/null +++ b/test_suite/tests/expand/derive/enum/generic_enum.expanded.rs @@ -0,0 +1,582 @@ +use serde::{Deserialize, Serialize}; +pub enum GenericEnum { + Unit, + NewType(T), + Seq(T, U), + Map { x: T, y: U }, +} +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_SERIALIZE_FOR_GenericEnum: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for GenericEnum + where + T: _serde::Serialize, + U: _serde::Serialize, + { + fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + GenericEnum::Unit => _serde::Serializer::serialize_unit_variant( + __serializer, + "GenericEnum", + 0u32, + "Unit", + ), + GenericEnum::NewType(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "GenericEnum", + 1u32, + "NewType", + __field0, + ) + } + GenericEnum::Seq(ref __field0, ref __field1) => { + let mut __serde_state = match _serde::Serializer::serialize_tuple_variant( + __serializer, + "GenericEnum", + 2u32, + "Seq", + 0 + 1 + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field0, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeTupleVariant::end(__serde_state) + } + GenericEnum::Map { ref x, ref y } => { + let mut __serde_state = match _serde::Serializer::serialize_struct_variant( + __serializer, + "GenericEnum", + 3u32, + "Map", + 0 + 1 + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStructVariant::serialize_field( + &mut __serde_state, + "x", + x, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStructVariant::serialize_field( + &mut __serde_state, + "y", + y, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStructVariant::end(__serde_state) + } + } + } + } +}; +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_DESERIALIZE_FOR_GenericEnum: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de, T, U> _serde::Deserialize<'de> for GenericEnum + where + T: _serde::Deserialize<'de>, + U: _serde::Deserialize<'de>, + { + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "variant identifier") + } + fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + 2u64 => _serde::export::Ok(__Field::__field2), + 3u64 => _serde::export::Ok(__Field::__field3), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 4", + )), + } + } + fn visit_str<__E>(self, __value: &str) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "Unit" => _serde::export::Ok(__Field::__field0), + "NewType" => _serde::export::Ok(__Field::__field1), + "Seq" => _serde::export::Ok(__Field::__field2), + "Map" => _serde::export::Ok(__Field::__field3), + _ => _serde::export::Err(_serde::de::Error::unknown_variant( + __value, VARIANTS, + )), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"Unit" => _serde::export::Ok(__Field::__field0), + b"NewType" => _serde::export::Ok(__Field::__field1), + b"Seq" => _serde::export::Ok(__Field::__field2), + b"Map" => _serde::export::Ok(__Field::__field3), + _ => { + let __value = &_serde::export::from_utf8_lossy(__value); + _serde::export::Err(_serde::de::Error::unknown_variant( + __value, VARIANTS, + )) + } + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor) + } + } + struct __Visitor<'de, T, U> + where + T: _serde::Deserialize<'de>, + U: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U> + where + T: _serde::Deserialize<'de>, + U: _serde::Deserialize<'de>, + { + type Value = GenericEnum; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "enum GenericEnum") + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::export::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match match _serde::de::EnumAccess::variant(__data) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + (__Field::__field0, __variant) => { + match _serde::de::VariantAccess::unit_variant(__variant) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(GenericEnum::Unit) + } + (__Field::__field1, __variant) => _serde::export::Result::map( + _serde::de::VariantAccess::newtype_variant::(__variant), + GenericEnum::NewType, + ), + (__Field::__field2, __variant) => { + struct __Visitor<'de, T, U> + where + T: _serde::Deserialize<'de>, + U: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U> + where + T: _serde::Deserialize<'de>, + U: _serde::Deserialize<'de>, + { + type Value = GenericEnum; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "tuple variant GenericEnum::Seq", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::< + T, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "tuple variant GenericEnum::Seq with 2 elements" ) ) ; + } + }; + let __field1 = match match _serde::de::SeqAccess::next_element::< + U, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "tuple variant GenericEnum::Seq with 2 elements" ) ) ; + } + }; + _serde::export::Ok(GenericEnum::Seq(__field0, __field1)) + } + } + _serde::de::VariantAccess::tuple_variant( + __variant, + 2usize, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + (__Field::__field3, __variant) => { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __ignore, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 2", + )), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "x" => _serde::export::Ok(__Field::__field0), + "y" => _serde::export::Ok(__Field::__field1), + _ => _serde::export::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"x" => _serde::export::Ok(__Field::__field0), + b"y" => _serde::export::Ok(__Field::__field1), + _ => _serde::export::Ok(__Field::__ignore), + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + struct __Visitor<'de, T, U> + where + T: _serde::Deserialize<'de>, + U: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U> + where + T: _serde::Deserialize<'de>, + U: _serde::Deserialize<'de>, + { + type Value = GenericEnum; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "struct variant GenericEnum::Map", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::< + T, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant GenericEnum::Map with 2 elements" ) ) ; + } + }; + let __field1 = match match _serde::de::SeqAccess::next_element::< + U, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant GenericEnum::Map with 2 elements" ) ) ; + } + }; + _serde::export::Ok(GenericEnum::Map { + x: __field0, + y: __field1, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::export::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::export::Option = + _serde::export::None; + let mut __field1: _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) { + return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "x" ) ) ; + } + __field0 = _serde::export::Some( + match _serde::de::MapAccess::next_value::( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) { + return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "y" ) ) ; + } + __field1 = _serde::export::Some( + match _serde::de::MapAccess::next_value::( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + _ => { + let _ = match _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >( + &mut __map + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = match __field0 { + _serde::export::Some(__field0) => __field0, + _serde::export::None => { + match _serde::private::de::missing_field("x") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + } + }; + let __field1 = match __field1 { + _serde::export::Some(__field1) => __field1, + _serde::export::None => { + match _serde::private::de::missing_field("y") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + } + }; + _serde::export::Ok(GenericEnum::Map { + x: __field0, + y: __field1, + }) + } + } + const FIELDS: &'static [&'static str] = &["x", "y"]; + _serde::de::VariantAccess::struct_variant( + __variant, + FIELDS, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + } + } + } + const VARIANTS: &'static [&'static str] = &["Unit", "NewType", "Seq", "Map"]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "GenericEnum", + VARIANTS, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + } +}; \ No newline at end of file diff --git a/test_suite/tests/expand/derive/enum/lifetimes.expanded.rs b/test_suite/tests/expand/derive/enum/lifetimes.expanded.rs new file mode 100644 index 00000000..d90de2f3 --- /dev/null +++ b/test_suite/tests/expand/derive/enum/lifetimes.expanded.rs @@ -0,0 +1,601 @@ +use serde::{Deserialize, Serialize}; +enum Lifetimes<'a> { + LifetimeSeq(&'a i32), + NoLifetimeSeq(i32), + LifetimeMap { a: &'a i32 }, + NoLifetimeMap { a: i32 }, +} +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_SERIALIZE_FOR_Lifetimes: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'a> _serde::Serialize for Lifetimes<'a> { + fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + Lifetimes::LifetimeSeq(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Lifetimes", + 0u32, + "LifetimeSeq", + __field0, + ) + } + Lifetimes::NoLifetimeSeq(ref __field0) => { + _serde::Serializer::serialize_newtype_variant( + __serializer, + "Lifetimes", + 1u32, + "NoLifetimeSeq", + __field0, + ) + } + Lifetimes::LifetimeMap { ref a } => { + let mut __serde_state = match _serde::Serializer::serialize_struct_variant( + __serializer, + "Lifetimes", + 2u32, + "LifetimeMap", + 0 + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStructVariant::serialize_field( + &mut __serde_state, + "a", + a, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStructVariant::end(__serde_state) + } + Lifetimes::NoLifetimeMap { ref a } => { + let mut __serde_state = match _serde::Serializer::serialize_struct_variant( + __serializer, + "Lifetimes", + 3u32, + "NoLifetimeMap", + 0 + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStructVariant::serialize_field( + &mut __serde_state, + "a", + a, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStructVariant::end(__serde_state) + } + } + } + } +}; +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_DESERIALIZE_FOR_Lifetimes: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de, 'a> _serde::Deserialize<'de> for Lifetimes<'a> { + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __field3, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "variant identifier") + } + fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + 2u64 => _serde::export::Ok(__Field::__field2), + 3u64 => _serde::export::Ok(__Field::__field3), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 4", + )), + } + } + fn visit_str<__E>(self, __value: &str) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "LifetimeSeq" => _serde::export::Ok(__Field::__field0), + "NoLifetimeSeq" => _serde::export::Ok(__Field::__field1), + "LifetimeMap" => _serde::export::Ok(__Field::__field2), + "NoLifetimeMap" => _serde::export::Ok(__Field::__field3), + _ => _serde::export::Err(_serde::de::Error::unknown_variant( + __value, VARIANTS, + )), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"LifetimeSeq" => _serde::export::Ok(__Field::__field0), + b"NoLifetimeSeq" => _serde::export::Ok(__Field::__field1), + b"LifetimeMap" => _serde::export::Ok(__Field::__field2), + b"NoLifetimeMap" => _serde::export::Ok(__Field::__field3), + _ => { + let __value = &_serde::export::from_utf8_lossy(__value); + _serde::export::Err(_serde::de::Error::unknown_variant( + __value, VARIANTS, + )) + } + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor) + } + } + struct __Visitor<'de, 'a> { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> { + type Value = Lifetimes<'a>; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "enum Lifetimes") + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::export::Result + where + __A: _serde::de::EnumAccess<'de>, + { + match match _serde::de::EnumAccess::variant(__data) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + (__Field::__field0, __variant) => _serde::export::Result::map( + _serde::de::VariantAccess::newtype_variant::<&'a i32>(__variant), + Lifetimes::LifetimeSeq, + ), + (__Field::__field1, __variant) => _serde::export::Result::map( + _serde::de::VariantAccess::newtype_variant::(__variant), + Lifetimes::NoLifetimeSeq, + ), + (__Field::__field2, __variant) => { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __ignore, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 1", + )), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "a" => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"a" => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Ok(__Field::__ignore), + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + struct __Visitor<'de, 'a> { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> { + type Value = Lifetimes<'a>; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "struct variant Lifetimes::LifetimeMap", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::< + &'a i32, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant Lifetimes::LifetimeMap with 1 element" ) ) ; + } + }; + _serde::export::Ok(Lifetimes::LifetimeMap { a: __field0 }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::export::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::export::Option<&'a i32> = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) { + return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "a" ) ) ; + } + __field0 = _serde::export::Some( + match _serde::de::MapAccess::next_value::<&'a i32>( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + _ => { + let _ = match _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >( + &mut __map + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = match __field0 { + _serde::export::Some(__field0) => __field0, + _serde::export::None => { + match _serde::private::de::missing_field("a") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + } + }; + _serde::export::Ok(Lifetimes::LifetimeMap { a: __field0 }) + } + } + const FIELDS: &'static [&'static str] = &["a"]; + _serde::de::VariantAccess::struct_variant( + __variant, + FIELDS, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + (__Field::__field3, __variant) => { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __ignore, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "field identifier", + ) + } + fn visit_u64<__E>( + self, + __value: u64, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 1", + )), + } + } + fn visit_str<__E>( + self, + __value: &str, + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "a" => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"a" => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Ok(__Field::__ignore), + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>( + __deserializer: __D, + ) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier( + __deserializer, + __FieldVisitor, + ) + } + } + struct __Visitor<'de, 'a> { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> { + type Value = Lifetimes<'a>; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "struct variant Lifetimes::NoLifetimeMap", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::< + i32, + >( + &mut __seq + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant Lifetimes::NoLifetimeMap with 1 element" ) ) ; + } + }; + _serde::export::Ok(Lifetimes::NoLifetimeMap { a: __field0 }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::export::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::export::Option = + _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) { + return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "a" ) ) ; + } + __field0 = _serde::export::Some( + match _serde::de::MapAccess::next_value::( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + _ => { + let _ = match _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >( + &mut __map + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = match __field0 { + _serde::export::Some(__field0) => __field0, + _serde::export::None => { + match _serde::private::de::missing_field("a") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + } + }; + _serde::export::Ok(Lifetimes::NoLifetimeMap { a: __field0 }) + } + } + const FIELDS: &'static [&'static str] = &["a"]; + _serde::de::VariantAccess::struct_variant( + __variant, + FIELDS, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + } + } + } + const VARIANTS: &'static [&'static str] = &[ + "LifetimeSeq", + "NoLifetimeSeq", + "LifetimeMap", + "NoLifetimeMap", + ]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "Lifetimes", + VARIANTS, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + } +}; \ No newline at end of file diff --git a/test_suite/tests/expand/derive/enum/ser_enum.expanded.rs b/test_suite/tests/expand/derive/enum/ser_enum.expanded.rs new file mode 100644 index 00000000..1efead3f --- /dev/null +++ b/test_suite/tests/expand/derive/enum/ser_enum.expanded.rs @@ -0,0 +1,268 @@ +use serde::Serialize; +enum SerEnum<'a, B: 'a, C: 'a, D> +where + D: 'a, +{ + Unit, + Seq(i8, B, &'a C, &'a mut D), + Map { a: i8, b: B, c: &'a C, d: &'a mut D }, + _Unit2, + _Seq2(i8, B, &'a C, &'a mut D), + _Map2 { a: i8, b: B, c: &'a C, d: &'a mut D }, +} +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_SERIALIZE_FOR_SerEnum: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'a, B: 'a, C: 'a, D> _serde::Serialize for SerEnum<'a, B, C, D> + where + D: 'a, + B: _serde::Serialize, + C: _serde::Serialize, + D: _serde::Serialize, + { + fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self { + SerEnum::Unit => _serde::Serializer::serialize_unit_variant( + __serializer, + "SerEnum", + 0u32, + "Unit", + ), + SerEnum::Seq(ref __field0, ref __field1, ref __field2, ref __field3) => { + let mut __serde_state = match _serde::Serializer::serialize_tuple_variant( + __serializer, + "SerEnum", + 1u32, + "Seq", + 0 + 1 + 1 + 1 + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field0, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field2, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field3, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeTupleVariant::end(__serde_state) + } + SerEnum::Map { + ref a, + ref b, + ref c, + ref d, + } => { + let mut __serde_state = match _serde::Serializer::serialize_struct_variant( + __serializer, + "SerEnum", + 2u32, + "Map", + 0 + 1 + 1 + 1 + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStructVariant::serialize_field( + &mut __serde_state, + "a", + a, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStructVariant::serialize_field( + &mut __serde_state, + "b", + b, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStructVariant::serialize_field( + &mut __serde_state, + "c", + c, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStructVariant::serialize_field( + &mut __serde_state, + "d", + d, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStructVariant::end(__serde_state) + } + SerEnum::_Unit2 => _serde::Serializer::serialize_unit_variant( + __serializer, + "SerEnum", + 3u32, + "_Unit2", + ), + SerEnum::_Seq2(ref __field0, ref __field1, ref __field2, ref __field3) => { + let mut __serde_state = match _serde::Serializer::serialize_tuple_variant( + __serializer, + "SerEnum", + 4u32, + "_Seq2", + 0 + 1 + 1 + 1 + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field0, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field2, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeTupleVariant::serialize_field( + &mut __serde_state, + __field3, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeTupleVariant::end(__serde_state) + } + SerEnum::_Map2 { + ref a, + ref b, + ref c, + ref d, + } => { + let mut __serde_state = match _serde::Serializer::serialize_struct_variant( + __serializer, + "SerEnum", + 5u32, + "_Map2", + 0 + 1 + 1 + 1 + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStructVariant::serialize_field( + &mut __serde_state, + "a", + a, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStructVariant::serialize_field( + &mut __serde_state, + "b", + b, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStructVariant::serialize_field( + &mut __serde_state, + "c", + c, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStructVariant::serialize_field( + &mut __serde_state, + "d", + d, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStructVariant::end(__serde_state) + } + } + } + } +}; \ No newline at end of file diff --git a/test_suite/tests/expand/derive/enum/void.expanded.rs b/test_suite/tests/expand/derive/enum/void.expanded.rs new file mode 100644 index 00000000..36499321 --- /dev/null +++ b/test_suite/tests/expand/derive/enum/void.expanded.rs @@ -0,0 +1,124 @@ +use serde::{Deserialize, Serialize}; +enum Void {} +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_SERIALIZE_FOR_Void: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for Void { + fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + match *self {} + } + } +}; +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_DESERIALIZE_FOR_Void: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for Void { + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + enum __Field {} + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "variant identifier") + } + fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"variant index 0 <= i < 0", + )), + } + } + fn visit_str<__E>(self, __value: &str) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + _ => _serde::export::Err(_serde::de::Error::unknown_variant( + __value, VARIANTS, + )), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + _ => { + let __value = &_serde::export::from_utf8_lossy(__value); + _serde::export::Err(_serde::de::Error::unknown_variant( + __value, VARIANTS, + )) + } + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor) + } + } + struct __Visitor<'de> { + marker: _serde::export::PhantomData, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { + type Value = Void; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "enum Void") + } + fn visit_enum<__A>( + self, + __data: __A, + ) -> _serde::export::Result + where + __A: _serde::de::EnumAccess<'de>, + { + _serde::export::Result::map( + _serde::de::EnumAccess::variant::<__Field>(__data), + |(__impossible, _)| match __impossible {}, + ) + } + } + const VARIANTS: &'static [&'static str] = &[]; + _serde::Deserializer::deserialize_enum( + __deserializer, + "Void", + VARIANTS, + __Visitor { + marker: _serde::export::PhantomData::, + lifetime: _serde::export::PhantomData, + }, + ) + } + } +}; \ No newline at end of file diff --git a/test_suite/tests/expand/derive/struct/default_ty_param.expanded.rs b/test_suite/tests/expand/derive/struct/default_ty_param.expanded.rs new file mode 100644 index 00000000..65326f0a --- /dev/null +++ b/test_suite/tests/expand/derive/struct/default_ty_param.expanded.rs @@ -0,0 +1,401 @@ +use serde::{Deserialize, Serialize}; +trait AssociatedType { + type X; +} +impl AssociatedType for i32 { + type X = i32; +} +struct DefaultTyParam = i32> { + phantom: PhantomData, +} +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_SERIALIZE_FOR_DefaultTyParam: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl> _serde::Serialize for DefaultTyParam { + fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = match _serde::Serializer::serialize_struct( + __serializer, + "DefaultTyParam", + false as usize + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field( + &mut __serde_state, + "phantom", + &self.phantom, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } +}; +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de, T: AssociatedType> _serde::Deserialize<'de> for DefaultTyParam { + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __ignore, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "field identifier") + } + fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 1", + )), + } + } + fn visit_str<__E>(self, __value: &str) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "phantom" => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"phantom" => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Ok(__Field::__ignore), + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor) + } + } + struct __Visitor<'de, T: AssociatedType> { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, T: AssociatedType> _serde::de::Visitor<'de> for __Visitor<'de, T> { + type Value = DefaultTyParam; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "struct DefaultTyParam") + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::>( + &mut __seq, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"struct DefaultTyParam with 1 element", + )); + } + }; + _serde::export::Ok(DefaultTyParam { phantom: __field0 }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::export::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::export::Option> = _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "phantom", + ), + ); + } + __field0 = _serde::export::Some( + match _serde::de::MapAccess::next_value::>( + &mut __map, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + _ => { + let _ = match _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = match __field0 { + _serde::export::Some(__field0) => __field0, + _serde::export::None => match _serde::private::de::missing_field("phantom") + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(DefaultTyParam { phantom: __field0 }) + } + } + const FIELDS: &'static [&'static str] = &["phantom"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "DefaultTyParam", + FIELDS, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + fn deserialize_in_place<__D>( + __deserializer: __D, + __place: &mut Self, + ) -> _serde::export::Result<(), __D::Error> + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __ignore, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "field identifier") + } + fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 1", + )), + } + } + fn visit_str<__E>(self, __value: &str) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "phantom" => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"phantom" => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Ok(__Field::__ignore), + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor) + } + } + struct __Visitor<'de, 'place, T: AssociatedType + 'place> { + place: &'place mut DefaultTyParam, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, 'place, T: AssociatedType + 'place> _serde::de::Visitor<'de> + for __Visitor<'de, 'place, T> + { + type Value = (); + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "struct DefaultTyParam") + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( + &mut __seq, + _serde::private::de::InPlaceSeed(&mut self.place.phantom), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"struct DefaultTyParam with 1 element", + )); + } + _serde::export::Ok(()) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::export::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: bool = false; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + { + match __key { + __Field::__field0 => { + if __field0 { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field( + "phantom", + ), + ); + } + match _serde::de::MapAccess::next_value_seed( + &mut __map, + _serde::private::de::InPlaceSeed(&mut self.place.phantom), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + __field0 = true; + } + _ => { + let _ = match _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + } + } + if !__field0 { + self.place.phantom = match _serde::private::de::missing_field("phantom") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + }; + _serde::export::Ok(()) + } + } + const FIELDS: &'static [&'static str] = &["phantom"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "DefaultTyParam", + FIELDS, + __Visitor { + place: __place, + lifetime: _serde::export::PhantomData, + }, + ) + } + } +}; \ No newline at end of file diff --git a/test_suite/tests/expand/derive/struct/generic_struct.expanded.rs b/test_suite/tests/expand/derive/struct/generic_struct.expanded.rs new file mode 100644 index 00000000..468e5fc0 --- /dev/null +++ b/test_suite/tests/expand/derive/struct/generic_struct.expanded.rs @@ -0,0 +1,582 @@ +use serde::{Deserialize, Serialize}; +pub struct GenericStruct { + x: T, +} +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_SERIALIZE_FOR_GenericStruct: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for GenericStruct + where + T: _serde::Serialize, + { + fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = match _serde::Serializer::serialize_struct( + __serializer, + "GenericStruct", + false as usize + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "x", &self.x) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } +}; +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_DESERIALIZE_FOR_GenericStruct: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de, T> _serde::Deserialize<'de> for GenericStruct + where + T: _serde::Deserialize<'de>, + { + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __ignore, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "field identifier") + } + fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 1", + )), + } + } + fn visit_str<__E>(self, __value: &str) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "x" => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"x" => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Ok(__Field::__ignore), + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor) + } + } + struct __Visitor<'de, T> + where + T: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T> + where + T: _serde::Deserialize<'de>, + { + type Value = GenericStruct; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "struct GenericStruct") + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"struct GenericStruct with 1 element", + )); + } + }; + _serde::export::Ok(GenericStruct { x: __field0 }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::export::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::export::Option = _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field("x"), + ); + } + __field0 = _serde::export::Some( + match _serde::de::MapAccess::next_value::(&mut __map) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + _ => { + let _ = match _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = match __field0 { + _serde::export::Some(__field0) => __field0, + _serde::export::None => match _serde::private::de::missing_field("x") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(GenericStruct { x: __field0 }) + } + } + const FIELDS: &'static [&'static str] = &["x"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "GenericStruct", + FIELDS, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + fn deserialize_in_place<__D>( + __deserializer: __D, + __place: &mut Self, + ) -> _serde::export::Result<(), __D::Error> + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __ignore, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "field identifier") + } + fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 1", + )), + } + } + fn visit_str<__E>(self, __value: &str) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "x" => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"x" => _serde::export::Ok(__Field::__field0), + _ => _serde::export::Ok(__Field::__ignore), + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor) + } + } + struct __Visitor<'de, 'place, T: 'place> + where + T: _serde::Deserialize<'de>, + { + place: &'place mut GenericStruct, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T> + where + T: _serde::Deserialize<'de>, + { + type Value = (); + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "struct GenericStruct") + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( + &mut __seq, + _serde::private::de::InPlaceSeed(&mut self.place.x), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"struct GenericStruct with 1 element", + )); + } + _serde::export::Ok(()) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::export::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: bool = false; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + { + match __key { + __Field::__field0 => { + if __field0 { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field("x"), + ); + } + match _serde::de::MapAccess::next_value_seed( + &mut __map, + _serde::private::de::InPlaceSeed(&mut self.place.x), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + __field0 = true; + } + _ => { + let _ = match _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + } + } + if !__field0 { + self.place.x = match _serde::private::de::missing_field("x") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + }; + _serde::export::Ok(()) + } + } + const FIELDS: &'static [&'static str] = &["x"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "GenericStruct", + FIELDS, + __Visitor { + place: __place, + lifetime: _serde::export::PhantomData, + }, + ) + } + } +}; +pub struct GenericNewTypeStruct(T); +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_SERIALIZE_FOR_GenericNewTypeStruct: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for GenericNewTypeStruct + where + T: _serde::Serialize, + { + fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + _serde::Serializer::serialize_newtype_struct( + __serializer, + "GenericNewTypeStruct", + &self.0, + ) + } + } +}; +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_DESERIALIZE_FOR_GenericNewTypeStruct: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de, T> _serde::Deserialize<'de> for GenericNewTypeStruct + where + T: _serde::Deserialize<'de>, + { + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + struct __Visitor<'de, T> + where + T: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T> + where + T: _serde::Deserialize<'de>, + { + type Value = GenericNewTypeStruct; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "tuple struct GenericNewTypeStruct", + ) + } + #[inline] + fn visit_newtype_struct<__E>( + self, + __e: __E, + ) -> _serde::export::Result + where + __E: _serde::Deserializer<'de>, + { + let __field0: T = match ::deserialize(__e) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::export::Ok(GenericNewTypeStruct(__field0)) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"tuple struct GenericNewTypeStruct with 1 element", + )); + } + }; + _serde::export::Ok(GenericNewTypeStruct(__field0)) + } + } + _serde::Deserializer::deserialize_newtype_struct( + __deserializer, + "GenericNewTypeStruct", + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + fn deserialize_in_place<__D>( + __deserializer: __D, + __place: &mut Self, + ) -> _serde::export::Result<(), __D::Error> + where + __D: _serde::Deserializer<'de>, + { + struct __Visitor<'de, 'place, T: 'place> + where + T: _serde::Deserialize<'de>, + { + place: &'place mut GenericNewTypeStruct, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T> + where + T: _serde::Deserialize<'de>, + { + type Value = (); + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "tuple struct GenericNewTypeStruct", + ) + } + #[inline] + fn visit_newtype_struct<__E>( + self, + __e: __E, + ) -> _serde::export::Result + where + __E: _serde::Deserializer<'de>, + { + _serde::Deserialize::deserialize_in_place(__e, &mut self.place.0) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( + &mut __seq, + _serde::private::de::InPlaceSeed(&mut self.place.0), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"tuple struct GenericNewTypeStruct with 1 element", + )); + } + _serde::export::Ok(()) + } + } + _serde::Deserializer::deserialize_newtype_struct( + __deserializer, + "GenericNewTypeStruct", + __Visitor { + place: __place, + lifetime: _serde::export::PhantomData, + }, + ) + } + } +}; \ No newline at end of file diff --git a/test_suite/tests/expand/derive/struct/generic_tuple_struct.expanded.rs b/test_suite/tests/expand/derive/struct/generic_tuple_struct.expanded.rs new file mode 100644 index 00000000..bf3e95a9 --- /dev/null +++ b/test_suite/tests/expand/derive/struct/generic_tuple_struct.expanded.rs @@ -0,0 +1,172 @@ +use serde::{Deserialize, Serialize}; +pub struct GenericTupleStruct(T, U); +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de, T, U> _serde::Deserialize<'de> for GenericTupleStruct + where + T: _serde::Deserialize<'de>, + U: _serde::Deserialize<'de>, + { + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + struct __Visitor<'de, T, U> + where + T: _serde::Deserialize<'de>, + U: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U> + where + T: _serde::Deserialize<'de>, + U: _serde::Deserialize<'de>, + { + type Value = GenericTupleStruct; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "tuple struct GenericTupleStruct", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"tuple struct GenericTupleStruct with 2 elements", + )); + } + }; + let __field1 = match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 1usize, + &"tuple struct GenericTupleStruct with 2 elements", + )); + } + }; + _serde::export::Ok(GenericTupleStruct(__field0, __field1)) + } + } + _serde::Deserializer::deserialize_tuple_struct( + __deserializer, + "GenericTupleStruct", + 2usize, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + fn deserialize_in_place<__D>( + __deserializer: __D, + __place: &mut Self, + ) -> _serde::export::Result<(), __D::Error> + where + __D: _serde::Deserializer<'de>, + { + struct __Visitor<'de, 'place, T: 'place, U: 'place> + where + T: _serde::Deserialize<'de>, + U: _serde::Deserialize<'de>, + { + place: &'place mut GenericTupleStruct, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, 'place, T: 'place, U: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T, U> + where + T: _serde::Deserialize<'de>, + U: _serde::Deserialize<'de>, + { + type Value = (); + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str( + __formatter, + "tuple struct GenericTupleStruct", + ) + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( + &mut __seq, + _serde::private::de::InPlaceSeed(&mut self.place.0), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"tuple struct GenericTupleStruct with 2 elements", + )); + } + if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( + &mut __seq, + _serde::private::de::InPlaceSeed(&mut self.place.1), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + return _serde::export::Err(_serde::de::Error::invalid_length( + 1usize, + &"tuple struct GenericTupleStruct with 2 elements", + )); + } + _serde::export::Ok(()) + } + } + _serde::Deserializer::deserialize_tuple_struct( + __deserializer, + "GenericTupleStruct", + 2usize, + __Visitor { + place: __place, + lifetime: _serde::export::PhantomData, + }, + ) + } + } +}; \ No newline at end of file diff --git a/test_suite/tests/expand/derive/struct/named_map.expanded.rs b/test_suite/tests/expand/derive/struct/named_map.expanded.rs new file mode 100644 index 00000000..c04e8b9e --- /dev/null +++ b/test_suite/tests/expand/derive/struct/named_map.expanded.rs @@ -0,0 +1,615 @@ +use serde::{Deserialize, Serialize}; +struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> { + a: &'a A, + b: &'b mut B, + c: C, +} +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_SERIALIZE_FOR_SerNamedMap: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'a, 'b, A: 'a, B: 'b, C> _serde::Serialize for SerNamedMap<'a, 'b, A, B, C> + where + A: _serde::Serialize, + B: _serde::Serialize, + C: _serde::Serialize, + { + fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = match _serde::Serializer::serialize_struct( + __serializer, + "SerNamedMap", + false as usize + 1 + 1 + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "a", &self.a) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "b", &self.b) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "c", &self.c) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeStruct::end(__serde_state) + } + } +}; +struct DeNamedMap { + a: A, + b: B, + c: C, +} +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de, A, B, C> _serde::Deserialize<'de> for DeNamedMap + where + A: _serde::Deserialize<'de>, + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + { + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "field identifier") + } + fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + 2u64 => _serde::export::Ok(__Field::__field2), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 3", + )), + } + } + fn visit_str<__E>(self, __value: &str) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "a" => _serde::export::Ok(__Field::__field0), + "b" => _serde::export::Ok(__Field::__field1), + "c" => _serde::export::Ok(__Field::__field2), + _ => _serde::export::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"a" => _serde::export::Ok(__Field::__field0), + b"b" => _serde::export::Ok(__Field::__field1), + b"c" => _serde::export::Ok(__Field::__field2), + _ => _serde::export::Ok(__Field::__ignore), + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor) + } + } + struct __Visitor<'de, A, B, C> + where + A: _serde::Deserialize<'de>, + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C> + where + A: _serde::Deserialize<'de>, + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + { + type Value = DeNamedMap; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "struct DeNamedMap") + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"struct DeNamedMap with 3 elements", + )); + } + }; + let __field1 = match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 1usize, + &"struct DeNamedMap with 3 elements", + )); + } + }; + let __field2 = match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 2usize, + &"struct DeNamedMap with 3 elements", + )); + } + }; + _serde::export::Ok(DeNamedMap { + a: __field0, + b: __field1, + c: __field2, + }) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::export::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: _serde::export::Option = _serde::export::None; + let mut __field1: _serde::export::Option = _serde::export::None; + let mut __field2: _serde::export::Option = _serde::export::None; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + { + match __key { + __Field::__field0 => { + if _serde::export::Option::is_some(&__field0) { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field("a"), + ); + } + __field0 = _serde::export::Some( + match _serde::de::MapAccess::next_value::(&mut __map) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + __Field::__field1 => { + if _serde::export::Option::is_some(&__field1) { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field("b"), + ); + } + __field1 = _serde::export::Some( + match _serde::de::MapAccess::next_value::(&mut __map) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + __Field::__field2 => { + if _serde::export::Option::is_some(&__field2) { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field("c"), + ); + } + __field2 = _serde::export::Some( + match _serde::de::MapAccess::next_value::(&mut __map) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + ); + } + _ => { + let _ = match _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + } + } + let __field0 = match __field0 { + _serde::export::Some(__field0) => __field0, + _serde::export::None => match _serde::private::de::missing_field("a") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field1 = match __field1 { + _serde::export::Some(__field1) => __field1, + _serde::export::None => match _serde::private::de::missing_field("b") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + let __field2 = match __field2 { + _serde::export::Some(__field2) => __field2, + _serde::export::None => match _serde::private::de::missing_field("c") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }, + }; + _serde::export::Ok(DeNamedMap { + a: __field0, + b: __field1, + c: __field2, + }) + } + } + const FIELDS: &'static [&'static str] = &["a", "b", "c"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "DeNamedMap", + FIELDS, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + fn deserialize_in_place<__D>( + __deserializer: __D, + __place: &mut Self, + ) -> _serde::export::Result<(), __D::Error> + where + __D: _serde::Deserializer<'de>, + { + #[allow(non_camel_case_types)] + enum __Field { + __field0, + __field1, + __field2, + __ignore, + } + struct __FieldVisitor; + impl<'de> _serde::de::Visitor<'de> for __FieldVisitor { + type Value = __Field; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "field identifier") + } + fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + 0u64 => _serde::export::Ok(__Field::__field0), + 1u64 => _serde::export::Ok(__Field::__field1), + 2u64 => _serde::export::Ok(__Field::__field2), + _ => _serde::export::Err(_serde::de::Error::invalid_value( + _serde::de::Unexpected::Unsigned(__value), + &"field index 0 <= i < 3", + )), + } + } + fn visit_str<__E>(self, __value: &str) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + "a" => _serde::export::Ok(__Field::__field0), + "b" => _serde::export::Ok(__Field::__field1), + "c" => _serde::export::Ok(__Field::__field2), + _ => _serde::export::Ok(__Field::__ignore), + } + } + fn visit_bytes<__E>( + self, + __value: &[u8], + ) -> _serde::export::Result + where + __E: _serde::de::Error, + { + match __value { + b"a" => _serde::export::Ok(__Field::__field0), + b"b" => _serde::export::Ok(__Field::__field1), + b"c" => _serde::export::Ok(__Field::__field2), + _ => _serde::export::Ok(__Field::__ignore), + } + } + } + impl<'de> _serde::Deserialize<'de> for __Field { + #[inline] + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor) + } + } + struct __Visitor<'de, 'place, A: 'place, B: 'place, C: 'place> + where + A: _serde::Deserialize<'de>, + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + { + place: &'place mut DeNamedMap, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, 'place, A: 'place, B: 'place, C: 'place> _serde::de::Visitor<'de> + for __Visitor<'de, 'place, A, B, C> + where + A: _serde::Deserialize<'de>, + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + { + type Value = (); + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "struct DeNamedMap") + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( + &mut __seq, + _serde::private::de::InPlaceSeed(&mut self.place.a), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"struct DeNamedMap with 3 elements", + )); + } + if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( + &mut __seq, + _serde::private::de::InPlaceSeed(&mut self.place.b), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + return _serde::export::Err(_serde::de::Error::invalid_length( + 1usize, + &"struct DeNamedMap with 3 elements", + )); + } + if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( + &mut __seq, + _serde::private::de::InPlaceSeed(&mut self.place.c), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + return _serde::export::Err(_serde::de::Error::invalid_length( + 2usize, + &"struct DeNamedMap with 3 elements", + )); + } + _serde::export::Ok(()) + } + #[inline] + fn visit_map<__A>( + self, + mut __map: __A, + ) -> _serde::export::Result + where + __A: _serde::de::MapAccess<'de>, + { + let mut __field0: bool = false; + let mut __field1: bool = false; + let mut __field2: bool = false; + while let _serde::export::Some(__key) = + match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } + { + match __key { + __Field::__field0 => { + if __field0 { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field("a"), + ); + } + match _serde::de::MapAccess::next_value_seed( + &mut __map, + _serde::private::de::InPlaceSeed(&mut self.place.a), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + __field0 = true; + } + __Field::__field1 => { + if __field1 { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field("b"), + ); + } + match _serde::de::MapAccess::next_value_seed( + &mut __map, + _serde::private::de::InPlaceSeed(&mut self.place.b), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + __field1 = true; + } + __Field::__field2 => { + if __field2 { + return _serde::export::Err( + <__A::Error as _serde::de::Error>::duplicate_field("c"), + ); + } + match _serde::de::MapAccess::next_value_seed( + &mut __map, + _serde::private::de::InPlaceSeed(&mut self.place.c), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + __field2 = true; + } + _ => { + let _ = match _serde::de::MapAccess::next_value::< + _serde::de::IgnoredAny, + >(&mut __map) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + } + } + } + if !__field0 { + self.place.a = match _serde::private::de::missing_field("a") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + }; + if !__field1 { + self.place.b = match _serde::private::de::missing_field("b") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + }; + if !__field2 { + self.place.c = match _serde::private::de::missing_field("c") { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + }; + _serde::export::Ok(()) + } + } + const FIELDS: &'static [&'static str] = &["a", "b", "c"]; + _serde::Deserializer::deserialize_struct( + __deserializer, + "DeNamedMap", + FIELDS, + __Visitor { + place: __place, + lifetime: _serde::export::PhantomData, + }, + ) + } + } +}; \ No newline at end of file diff --git a/test_suite/tests/expand/derive/struct/named_tuple.expanded.rs b/test_suite/tests/expand/derive/struct/named_tuple.expanded.rs new file mode 100644 index 00000000..7329de6b --- /dev/null +++ b/test_suite/tests/expand/derive/struct/named_tuple.expanded.rs @@ -0,0 +1,250 @@ +use serde::{Deserialize, Serialize}; +struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C); +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_SERIALIZE_FOR_SerNamedTuple: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'a, 'b, A: 'a, B: 'b, C> _serde::Serialize for SerNamedTuple<'a, 'b, A, B, C> + where + A: _serde::Serialize, + B: _serde::Serialize, + C: _serde::Serialize, + { + fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + let mut __serde_state = match _serde::Serializer::serialize_tuple_struct( + __serializer, + "SerNamedTuple", + 0 + 1 + 1 + 1, + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.0) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.1) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.2) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + }; + _serde::ser::SerializeTupleStruct::end(__serde_state) + } + } +}; +struct DeNamedTuple(A, B, C); +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_DESERIALIZE_FOR_DeNamedTuple: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de, A, B, C> _serde::Deserialize<'de> for DeNamedTuple + where + A: _serde::Deserialize<'de>, + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + { + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + struct __Visitor<'de, A, B, C> + where + A: _serde::Deserialize<'de>, + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + { + marker: _serde::export::PhantomData>, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C> + where + A: _serde::Deserialize<'de>, + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + { + type Value = DeNamedTuple; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "tuple struct DeNamedTuple") + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + let __field0 = match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"tuple struct DeNamedTuple with 3 elements", + )); + } + }; + let __field1 = match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 1usize, + &"tuple struct DeNamedTuple with 3 elements", + )); + } + }; + let __field2 = match match _serde::de::SeqAccess::next_element::(&mut __seq) + { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + _serde::export::Some(__value) => __value, + _serde::export::None => { + return _serde::export::Err(_serde::de::Error::invalid_length( + 2usize, + &"tuple struct DeNamedTuple with 3 elements", + )); + } + }; + _serde::export::Ok(DeNamedTuple(__field0, __field1, __field2)) + } + } + _serde::Deserializer::deserialize_tuple_struct( + __deserializer, + "DeNamedTuple", + 3usize, + __Visitor { + marker: _serde::export::PhantomData::>, + lifetime: _serde::export::PhantomData, + }, + ) + } + fn deserialize_in_place<__D>( + __deserializer: __D, + __place: &mut Self, + ) -> _serde::export::Result<(), __D::Error> + where + __D: _serde::Deserializer<'de>, + { + struct __Visitor<'de, 'place, A: 'place, B: 'place, C: 'place> + where + A: _serde::Deserialize<'de>, + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + { + place: &'place mut DeNamedTuple, + lifetime: _serde::export::PhantomData<&'de ()>, + } + impl<'de, 'place, A: 'place, B: 'place, C: 'place> _serde::de::Visitor<'de> + for __Visitor<'de, 'place, A, B, C> + where + A: _serde::Deserialize<'de>, + B: _serde::Deserialize<'de>, + C: _serde::Deserialize<'de>, + { + type Value = (); + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "tuple struct DeNamedTuple") + } + #[inline] + fn visit_seq<__A>( + self, + mut __seq: __A, + ) -> _serde::export::Result + where + __A: _serde::de::SeqAccess<'de>, + { + if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( + &mut __seq, + _serde::private::de::InPlaceSeed(&mut self.place.0), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + return _serde::export::Err(_serde::de::Error::invalid_length( + 0usize, + &"tuple struct DeNamedTuple with 3 elements", + )); + } + if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( + &mut __seq, + _serde::private::de::InPlaceSeed(&mut self.place.1), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + return _serde::export::Err(_serde::de::Error::invalid_length( + 1usize, + &"tuple struct DeNamedTuple with 3 elements", + )); + } + if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( + &mut __seq, + _serde::private::de::InPlaceSeed(&mut self.place.2), + ) { + _serde::export::Ok(__val) => __val, + _serde::export::Err(__err) => { + return _serde::export::Err(__err); + } + } { + return _serde::export::Err(_serde::de::Error::invalid_length( + 2usize, + &"tuple struct DeNamedTuple with 3 elements", + )); + } + _serde::export::Ok(()) + } + } + _serde::Deserializer::deserialize_tuple_struct( + __deserializer, + "DeNamedTuple", + 3usize, + __Visitor { + place: __place, + lifetime: _serde::export::PhantomData, + }, + ) + } + } +}; \ No newline at end of file diff --git a/test_suite/tests/expand/derive/struct/named_unit.expanded.rs b/test_suite/tests/expand/derive/struct/named_unit.expanded.rs new file mode 100644 index 00000000..eda641ca --- /dev/null +++ b/test_suite/tests/expand/derive/struct/named_unit.expanded.rs @@ -0,0 +1,49 @@ +use serde::{Deserialize, Serialize}; +struct NamedUnit; +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_SERIALIZE_FOR_NamedUnit: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl _serde::Serialize for NamedUnit { + fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> + where + __S: _serde::Serializer, + { + _serde::Serializer::serialize_unit_struct(__serializer, "NamedUnit") + } + } +}; +#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] +const _IMPL_DESERIALIZE_FOR_NamedUnit: () = { + #[allow(unknown_lints)] + #[allow(rust_2018_idioms)] + extern crate serde as _serde; + #[automatically_derived] + impl<'de> _serde::Deserialize<'de> for NamedUnit { + fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result + where + __D: _serde::Deserializer<'de>, + { + struct __Visitor; + impl<'de> _serde::de::Visitor<'de> for __Visitor { + type Value = NamedUnit; + fn expecting( + &self, + __formatter: &mut _serde::export::Formatter, + ) -> _serde::export::fmt::Result { + _serde::export::Formatter::write_str(__formatter, "unit struct NamedUnit") + } + #[inline] + fn visit_unit<__E>(self) -> _serde::export::Result + where + __E: _serde::de::Error, + { + _serde::export::Ok(NamedUnit) + } + } + _serde::Deserializer::deserialize_unit_struct(__deserializer, "NamedUnit", __Visitor) + } + } +}; \ No newline at end of file