From dc6dbba47c8b866f589afa49761f65ba9e68f856 Mon Sep 17 00:00:00 2001 From: Evgenii P Date: Fri, 1 Nov 2019 02:32:06 +0800 Subject: [PATCH 1/4] Implement derive macros expansion tests using macrotest --- test_suite/Cargo.toml | 1 + test_suite/tests/expand/derive/enum/de_enum.rs | 13 +++++++++++++ .../tests/expand/derive/enum/generic_enum.rs | 9 +++++++++ test_suite/tests/expand/derive/enum/lifetimes.rs | 9 +++++++++ test_suite/tests/expand/derive/enum/ser_enum.rs | 16 ++++++++++++++++ test_suite/tests/expand/derive/enum/void.rs | 4 ++++ .../expand/derive/struct/default_ty_param.rs | 14 ++++++++++++++ .../tests/expand/derive/struct/generic_struct.rs | 9 +++++++++ .../expand/derive/struct/generic_tuple_struct.rs | 4 ++++ .../tests/expand/derive/struct/named_map.rs | 15 +++++++++++++++ .../tests/expand/derive/struct/named_tuple.rs | 7 +++++++ .../tests/expand/derive/struct/named_unit.rs | 4 ++++ test_suite/tests/expandtest.rs | 7 +++++++ 13 files changed, 112 insertions(+) create mode 100644 test_suite/tests/expand/derive/enum/de_enum.rs create mode 100644 test_suite/tests/expand/derive/enum/generic_enum.rs create mode 100644 test_suite/tests/expand/derive/enum/lifetimes.rs create mode 100644 test_suite/tests/expand/derive/enum/ser_enum.rs create mode 100644 test_suite/tests/expand/derive/enum/void.rs create mode 100644 test_suite/tests/expand/derive/struct/default_ty_param.rs create mode 100644 test_suite/tests/expand/derive/struct/generic_struct.rs create mode 100644 test_suite/tests/expand/derive/struct/generic_tuple_struct.rs create mode 100644 test_suite/tests/expand/derive/struct/named_map.rs create mode 100644 test_suite/tests/expand/derive/struct/named_tuple.rs create mode 100644 test_suite/tests/expand/derive/struct/named_unit.rs create mode 100644 test_suite/tests/expandtest.rs diff --git a/test_suite/Cargo.toml b/test_suite/Cargo.toml index be836d67..5c0bdd8c 100644 --- a/test_suite/Cargo.toml +++ b/test_suite/Cargo.toml @@ -18,3 +18,4 @@ serde = { path = "../serde", features = ["rc", "derive"] } serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] } serde_test = { path = "../serde_test" } trybuild = "1.0" +macrotest = "0.1" diff --git a/test_suite/tests/expand/derive/enum/de_enum.rs b/test_suite/tests/expand/derive/enum/de_enum.rs new file mode 100644 index 00000000..59c3bb63 --- /dev/null +++ b/test_suite/tests/expand/derive/enum/de_enum.rs @@ -0,0 +1,13 @@ +use serde::Deserialize; + +#[derive(Debug, PartialEq, Serialize, Deserialize)] +enum DeEnum { + Unit, + Seq(i8, B, C, D), + Map { a: i8, b: B, c: C, d: D }, + + // Make sure we can support more than one variant. + _Unit2, + _Seq2(i8, B, C, D), + _Map2 { a: i8, b: B, c: C, d: D }, +} diff --git a/test_suite/tests/expand/derive/enum/generic_enum.rs b/test_suite/tests/expand/derive/enum/generic_enum.rs new file mode 100644 index 00000000..3fcf71f9 --- /dev/null +++ b/test_suite/tests/expand/derive/enum/generic_enum.rs @@ -0,0 +1,9 @@ +use serde::{Serialize, Deserialize}; + +#[derive(Serialize, Deserialize)] +pub enum GenericEnum { + Unit, + NewType(T), + Seq(T, U), + Map { x: T, y: U }, +} diff --git a/test_suite/tests/expand/derive/enum/lifetimes.rs b/test_suite/tests/expand/derive/enum/lifetimes.rs new file mode 100644 index 00000000..ae7276a4 --- /dev/null +++ b/test_suite/tests/expand/derive/enum/lifetimes.rs @@ -0,0 +1,9 @@ +use serde::{Serialize, Deserialize}; + +#[derive(Serialize, Deserialize)] +enum Lifetimes<'a> { + LifetimeSeq(&'a i32), + NoLifetimeSeq(i32), + LifetimeMap { a: &'a i32 }, + NoLifetimeMap { a: i32 }, +} diff --git a/test_suite/tests/expand/derive/enum/ser_enum.rs b/test_suite/tests/expand/derive/enum/ser_enum.rs new file mode 100644 index 00000000..dac7bd40 --- /dev/null +++ b/test_suite/tests/expand/derive/enum/ser_enum.rs @@ -0,0 +1,16 @@ +use serde::Serialize; + +#[derive(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 }, + + // Make sure we can support more than one variant. + _Unit2, + _Seq2(i8, B, &'a C, &'a mut D), + _Map2 { a: i8, b: B, c: &'a C, d: &'a mut D }, +} diff --git a/test_suite/tests/expand/derive/enum/void.rs b/test_suite/tests/expand/derive/enum/void.rs new file mode 100644 index 00000000..9b20161b --- /dev/null +++ b/test_suite/tests/expand/derive/enum/void.rs @@ -0,0 +1,4 @@ +use serde::{Serialize, Deserialize}; + +#[derive(Serialize, Deserialize)] +enum Void {} diff --git a/test_suite/tests/expand/derive/struct/default_ty_param.rs b/test_suite/tests/expand/derive/struct/default_ty_param.rs new file mode 100644 index 00000000..3b1ed4e0 --- /dev/null +++ b/test_suite/tests/expand/derive/struct/default_ty_param.rs @@ -0,0 +1,14 @@ +use serde::{Serialize, Deserialize}; + +trait AssociatedType { + type X; +} + +impl AssociatedType for i32 { + type X = i32; +} + +#[derive(Serialize, Deserialize)] +struct DefaultTyParam = i32> { + phantom: PhantomData, +} diff --git a/test_suite/tests/expand/derive/struct/generic_struct.rs b/test_suite/tests/expand/derive/struct/generic_struct.rs new file mode 100644 index 00000000..24afac2f --- /dev/null +++ b/test_suite/tests/expand/derive/struct/generic_struct.rs @@ -0,0 +1,9 @@ +use serde::{Serialize, Deserialize}; + +#[derive(Serialize, Deserialize)] +pub struct GenericStruct { + x: T, +} + +#[derive(Serialize, Deserialize)] +pub struct GenericNewTypeStruct(T); diff --git a/test_suite/tests/expand/derive/struct/generic_tuple_struct.rs b/test_suite/tests/expand/derive/struct/generic_tuple_struct.rs new file mode 100644 index 00000000..f50369be --- /dev/null +++ b/test_suite/tests/expand/derive/struct/generic_tuple_struct.rs @@ -0,0 +1,4 @@ +use serde::{Serialize, Deserialize}; + +#[derive(Deserialize)] +pub struct GenericTupleStruct(T, U); diff --git a/test_suite/tests/expand/derive/struct/named_map.rs b/test_suite/tests/expand/derive/struct/named_map.rs new file mode 100644 index 00000000..809ccd0c --- /dev/null +++ b/test_suite/tests/expand/derive/struct/named_map.rs @@ -0,0 +1,15 @@ +use serde::{Serialize, Deserialize}; + +#[derive(Serialize)] +struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> { + a: &'a A, + b: &'b mut B, + c: C, +} + +#[derive(Deserialize)] +struct DeNamedMap { + a: A, + b: B, + c: C, +} diff --git a/test_suite/tests/expand/derive/struct/named_tuple.rs b/test_suite/tests/expand/derive/struct/named_tuple.rs new file mode 100644 index 00000000..166cc85e --- /dev/null +++ b/test_suite/tests/expand/derive/struct/named_tuple.rs @@ -0,0 +1,7 @@ +use serde::{Serialize, Deserialize}; + +#[derive(Serialize)] +struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C); + +#[derive(Deserialize)] +struct DeNamedTuple(A, B, C); diff --git a/test_suite/tests/expand/derive/struct/named_unit.rs b/test_suite/tests/expand/derive/struct/named_unit.rs new file mode 100644 index 00000000..8e8cf36a --- /dev/null +++ b/test_suite/tests/expand/derive/struct/named_unit.rs @@ -0,0 +1,4 @@ +use serde::{Serialize, Deserialize}; + +#[derive(Serialize, Deserialize)] +struct NamedUnit; diff --git a/test_suite/tests/expandtest.rs b/test_suite/tests/expandtest.rs new file mode 100644 index 00000000..790576f9 --- /dev/null +++ b/test_suite/tests/expandtest.rs @@ -0,0 +1,7 @@ +#[cfg(not(target_os = "emscripten"))] +#[rustversion::attr(not(nightly), ignore)] +#[test] +fn expandtest() { + macrotest::expand("tests/expand/**/enum/*.rs"); + macrotest::expand("tests/expand/**/struct/*.rs"); +} From 4dda90502a2ba3d0b811823f0279f31536fb96f3 Mon Sep 17 00:00:00 2001 From: Evgenii P Date: Fri, 1 Nov 2019 02:32:34 +0800 Subject: [PATCH 2/4] Add *.expanded.rs files --- .../expand/derive/enum/de_enum.expanded.rs | 1373 +++++++++++++++++ .../derive/enum/generic_enum.expanded.rs | 582 +++++++ .../expand/derive/enum/lifetimes.expanded.rs | 601 ++++++++ .../expand/derive/enum/ser_enum.expanded.rs | 268 ++++ .../tests/expand/derive/enum/void.expanded.rs | 124 ++ .../struct/default_ty_param.expanded.rs | 401 +++++ .../derive/struct/generic_struct.expanded.rs | 582 +++++++ .../struct/generic_tuple_struct.expanded.rs | 172 +++ .../derive/struct/named_map.expanded.rs | 615 ++++++++ .../derive/struct/named_tuple.expanded.rs | 250 +++ .../derive/struct/named_unit.expanded.rs | 49 + 11 files changed, 5017 insertions(+) create mode 100644 test_suite/tests/expand/derive/enum/de_enum.expanded.rs create mode 100644 test_suite/tests/expand/derive/enum/generic_enum.expanded.rs create mode 100644 test_suite/tests/expand/derive/enum/lifetimes.expanded.rs create mode 100644 test_suite/tests/expand/derive/enum/ser_enum.expanded.rs create mode 100644 test_suite/tests/expand/derive/enum/void.expanded.rs create mode 100644 test_suite/tests/expand/derive/struct/default_ty_param.expanded.rs create mode 100644 test_suite/tests/expand/derive/struct/generic_struct.expanded.rs create mode 100644 test_suite/tests/expand/derive/struct/generic_tuple_struct.expanded.rs create mode 100644 test_suite/tests/expand/derive/struct/named_map.expanded.rs create mode 100644 test_suite/tests/expand/derive/struct/named_tuple.expanded.rs create mode 100644 test_suite/tests/expand/derive/struct/named_unit.expanded.rs 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 From 640f8e0e82104c6ce9cc059b5e1d7acb53e5009b Mon Sep 17 00:00:00 2001 From: Evgenii P Date: Sun, 3 Nov 2019 20:08:39 +0800 Subject: [PATCH 3/4] Remove stdlib derives and fix expanded files to have newlines at the end --- .../expand/derive/enum/de_enum.expanded.rs | 209 +----------------- .../tests/expand/derive/enum/de_enum.rs | 2 +- .../derive/enum/generic_enum.expanded.rs | 2 +- .../expand/derive/enum/lifetimes.expanded.rs | 2 +- .../expand/derive/enum/ser_enum.expanded.rs | 2 +- .../tests/expand/derive/enum/void.expanded.rs | 2 +- .../struct/default_ty_param.expanded.rs | 2 +- .../derive/struct/generic_struct.expanded.rs | 2 +- .../struct/generic_tuple_struct.expanded.rs | 2 +- .../derive/struct/named_map.expanded.rs | 2 +- .../derive/struct/named_tuple.expanded.rs | 2 +- .../derive/struct/named_unit.expanded.rs | 2 +- 12 files changed, 12 insertions(+), 219 deletions(-) diff --git a/test_suite/tests/expand/derive/enum/de_enum.expanded.rs b/test_suite/tests/expand/derive/enum/de_enum.expanded.rs index 224a5468..d47c1406 100644 --- a/test_suite/tests/expand/derive/enum/de_enum.expanded.rs +++ b/test_suite/tests/expand/derive/enum/de_enum.expanded.rs @@ -7,213 +7,6 @@ enum DeEnum { _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)] @@ -1370,4 +1163,4 @@ const _IMPL_DESERIALIZE_FOR_DeEnum: () = { ) } } -}; \ No newline at end of file +}; diff --git a/test_suite/tests/expand/derive/enum/de_enum.rs b/test_suite/tests/expand/derive/enum/de_enum.rs index 59c3bb63..642ea328 100644 --- a/test_suite/tests/expand/derive/enum/de_enum.rs +++ b/test_suite/tests/expand/derive/enum/de_enum.rs @@ -1,6 +1,6 @@ use serde::Deserialize; -#[derive(Debug, PartialEq, Serialize, Deserialize)] +#[derive(Serialize, Deserialize)] enum DeEnum { Unit, Seq(i8, B, C, D), diff --git a/test_suite/tests/expand/derive/enum/generic_enum.expanded.rs b/test_suite/tests/expand/derive/enum/generic_enum.expanded.rs index 2248d30f..0f8b98d9 100644 --- a/test_suite/tests/expand/derive/enum/generic_enum.expanded.rs +++ b/test_suite/tests/expand/derive/enum/generic_enum.expanded.rs @@ -579,4 +579,4 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = { ) } } -}; \ 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 index d90de2f3..941e08f7 100644 --- a/test_suite/tests/expand/derive/enum/lifetimes.expanded.rs +++ b/test_suite/tests/expand/derive/enum/lifetimes.expanded.rs @@ -598,4 +598,4 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = { ) } } -}; \ 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 index 1efead3f..8d917dcc 100644 --- a/test_suite/tests/expand/derive/enum/ser_enum.expanded.rs +++ b/test_suite/tests/expand/derive/enum/ser_enum.expanded.rs @@ -265,4 +265,4 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = { } } } -}; \ 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 index 36499321..f7a83aa4 100644 --- a/test_suite/tests/expand/derive/enum/void.expanded.rs +++ b/test_suite/tests/expand/derive/enum/void.expanded.rs @@ -121,4 +121,4 @@ const _IMPL_DESERIALIZE_FOR_Void: () = { ) } } -}; \ 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 index 65326f0a..8f9afefc 100644 --- a/test_suite/tests/expand/derive/struct/default_ty_param.expanded.rs +++ b/test_suite/tests/expand/derive/struct/default_ty_param.expanded.rs @@ -398,4 +398,4 @@ const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = { ) } } -}; \ 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 index 468e5fc0..fb9aa906 100644 --- a/test_suite/tests/expand/derive/struct/generic_struct.expanded.rs +++ b/test_suite/tests/expand/derive/struct/generic_struct.expanded.rs @@ -579,4 +579,4 @@ const _IMPL_DESERIALIZE_FOR_GenericNewTypeStruct: () = { ) } } -}; \ 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 index bf3e95a9..8227dc07 100644 --- a/test_suite/tests/expand/derive/struct/generic_tuple_struct.expanded.rs +++ b/test_suite/tests/expand/derive/struct/generic_tuple_struct.expanded.rs @@ -169,4 +169,4 @@ const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = { ) } } -}; \ 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 index c04e8b9e..88fa708d 100644 --- a/test_suite/tests/expand/derive/struct/named_map.expanded.rs +++ b/test_suite/tests/expand/derive/struct/named_map.expanded.rs @@ -612,4 +612,4 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = { ) } } -}; \ 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 index 7329de6b..aab87a21 100644 --- a/test_suite/tests/expand/derive/struct/named_tuple.expanded.rs +++ b/test_suite/tests/expand/derive/struct/named_tuple.expanded.rs @@ -247,4 +247,4 @@ const _IMPL_DESERIALIZE_FOR_DeNamedTuple: () = { ) } } -}; \ 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 index eda641ca..4156d75b 100644 --- a/test_suite/tests/expand/derive/struct/named_unit.expanded.rs +++ b/test_suite/tests/expand/derive/struct/named_unit.expanded.rs @@ -46,4 +46,4 @@ const _IMPL_DESERIALIZE_FOR_NamedUnit: () = { _serde::Deserializer::deserialize_unit_struct(__deserializer, "NamedUnit", __Visitor) } } -}; \ No newline at end of file +}; From 9a0e4e0176393d98fb0db23fd1958a9dabd7da0f Mon Sep 17 00:00:00 2001 From: Evgenii P Date: Sun, 3 Nov 2019 20:31:08 +0800 Subject: [PATCH 4/4] Ignore expansion test if cargo-expand subcommand isn't present --- test_suite/Cargo.toml | 1 + test_suite/build.rs | 28 ++++++++++++++++++++++++++++ test_suite/tests/expandtest.rs | 1 + 3 files changed, 30 insertions(+) create mode 100644 test_suite/build.rs diff --git a/test_suite/Cargo.toml b/test_suite/Cargo.toml index 5c0bdd8c..1bfecca4 100644 --- a/test_suite/Cargo.toml +++ b/test_suite/Cargo.toml @@ -4,6 +4,7 @@ version = "0.0.0" authors = ["Erick Tryzelaar ", "David Tolnay "] edition = "2018" publish = false +build = "build.rs" [features] unstable = ["serde/unstable"] diff --git a/test_suite/build.rs b/test_suite/build.rs new file mode 100644 index 00000000..eaaabcb2 --- /dev/null +++ b/test_suite/build.rs @@ -0,0 +1,28 @@ +use std::env; +use std::path::PathBuf; + +#[cfg(not(windows))] +const CARGO_EXPAND_BIN: &str = "cargo-expand"; + +#[cfg(windows)] +const CARGO_EXPAND_BIN: &str = "cargo-expand.exe"; + +/// Scans paths in PATH env variable for a presence of `CARGO_EXPAND_BIN` file. +fn is_cargo_expand_present() -> bool { + if let Ok(var) = env::var("PATH") { + for path in var.split(":").map(PathBuf::from) { + let cargo_expand_path = path.join(CARGO_EXPAND_BIN); + if cargo_expand_path.exists() { + return true; + } + } + } + + false +} + +pub fn main() { + if is_cargo_expand_present() { + println!("cargo:rustc-cfg=cargo_expand"); + } +} diff --git a/test_suite/tests/expandtest.rs b/test_suite/tests/expandtest.rs index 790576f9..b51ab054 100644 --- a/test_suite/tests/expandtest.rs +++ b/test_suite/tests/expandtest.rs @@ -1,5 +1,6 @@ #[cfg(not(target_os = "emscripten"))] #[rustversion::attr(not(nightly), ignore)] +#[cfg_attr(not(cargo_expand), ignore)] #[test] fn expandtest() { macrotest::expand("tests/expand/**/enum/*.rs");