Release 1.0.119

error[E0432]: unresolved import `private::de::size_hint`
      --> src/de/value.rs:28:5
       |
    28 | use private::de::size_hint;
       |     ^^^^^^^^^^^^^^^^^^^^^^ Maybe a missing `extern crate private`?

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.118" # remember to update html_root_url and serde_derive dependency
+version = "1.0.119" # remember to update html_root_url and serde_derive dependency
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -14,7 +14,7 @@ include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APAC
 build = "build.rs"
 
 [dependencies]
-serde_derive = { version = "=1.0.118", optional = true, path = "../serde_derive" }
+serde_derive = { version = "=1.0.119", optional = true, path = "../serde_derive" }
 
 [dev-dependencies]
 serde_derive = { version = "1.0", path = "../serde_derive" }

serde/src/de/impls.rs

@@ -7,11 +7,11 @@ use de::{
 #[cfg(any(core_duration, feature = "std", feature = "alloc"))]
 use de::MapAccess;
 
+use __private::de::InPlaceSeed;
 use de::from_primitive::FromPrimitive;
-use private::de::InPlaceSeed;
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-use private::de::size_hint;
+use __private::de::size_hint;
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -1906,7 +1906,7 @@ impl<'de> Deserialize<'de> for Duration {
                             b"secs" => Ok(Field::Secs),
                             b"nanos" => Ok(Field::Nanos),
                             _ => {
-                                let value = ::export::from_utf8_lossy(value);
+                                let value = ::__private::from_utf8_lossy(value);
                                 Err(Error::unknown_field(&value, FIELDS))
                             }
                         }
@@ -2214,7 +2214,7 @@ mod range {
                         b"start" => Ok(Field::Start),
                         b"end" => Ok(Field::End),
                         _ => {
-                            let value = ::export::from_utf8_lossy(value);
+                            let value = ::__private::from_utf8_lossy(value);
                             Err(Error::unknown_field(&value, FIELDS))
                         }
                     }

serde/src/de/value.rs

@@ -24,8 +24,8 @@
 use lib::*;
 
 use self::private::{First, Second};
+use __private::de::size_hint;
 use de::{self, Expected, IntoDeserializer, SeqAccess};
-use private::de::size_hint;
 use ser;
 
 ////////////////////////////////////////////////////////////////////////////////

serde/src/export.rs

@@ -1,39 +0,0 @@
-pub use lib::clone::Clone;
-pub use lib::convert::{From, Into};
-pub use lib::default::Default;
-pub use lib::fmt::{self, Formatter};
-pub use lib::marker::PhantomData;
-pub use lib::option::Option::{self, None, Some};
-pub use lib::result::Result::{self, Err, Ok};
-
-pub use self::string::from_utf8_lossy;
-
-#[cfg(any(feature = "alloc", feature = "std"))]
-pub use lib::{ToString, Vec};
-
-#[cfg(core_try_from)]
-pub use lib::convert::TryFrom;
-
-mod string {
-    use lib::*;
-
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> {
-        String::from_utf8_lossy(bytes)
-    }
-
-    // The generated code calls this like:
-    //
-    //     let value = &_serde::export::from_utf8_lossy(bytes);
-    //     Err(_serde::de::Error::unknown_variant(value, VARIANTS))
-    //
-    // so it is okay for the return type to be different from the std case as long
-    // as the above works.
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
-    pub fn from_utf8_lossy(bytes: &[u8]) -> &str {
-        // Three unicode replacement characters if it fails. They look like a
-        // white-on-black question mark. The user will recognize it as invalid
-        // UTF-8.
-        str::from_utf8(bytes).unwrap_or("\u{fffd}\u{fffd}\u{fffd}")
-    }
-}

serde/src/integer128.rs

@@ -10,7 +10,7 @@
 /// bother with this macro and may assume support for 128-bit integers.
 ///
 /// ```edition2018
-/// # use serde::private::ser::Error;
+/// # use serde::__private::ser::Error;
 /// #
 /// # struct MySerializer;
 /// #

serde/src/lib.rs

@@ -9,11 +9,9 @@
 //! these two groups interact with each other, allowing any supported data
 //! structure to be serialized and deserialized using any supported data format.
 //!
-//! See the Serde website [https://serde.rs/] for additional documentation and
+//! See the Serde website <https://serde.rs/> for additional documentation and
 //! usage examples.
 //!
-//! [https://serde.rs/]: https://serde.rs/
-//!
 //! ## Design
 //!
 //! Where many other languages rely on runtime reflection for serializing data,
@@ -57,6 +55,8 @@
 //!   Lisp language family.
 //! - [D-Bus]'s binary wire format.
 //! - [FlexBuffers], the schemaless cousin of Google's FlatBuffers zero-copy serialization format.
+//! - [DynamoDB Items], the format used by [rusoto_dynamodb] to transfer data to
+//!   and from DynamoDB.
 //!
 //! [JSON]: https://github.com/serde-rs/json
 //! [Bincode]: https://github.com/servo/bincode
@@ -78,11 +78,13 @@
 //! [S-expressions]: https://github.com/rotty/lexpr-rs
 //! [D-Bus]: https://docs.rs/zvariant
 //! [FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers
+//! [DynamoDB Items]: https://docs.rs/serde_dynamo
+//! [rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.118")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.119")]
 // Support using Serde without the standard library!
 #![cfg_attr(not(feature = "std"), no_std)]
 // Unstable functionality only if the user asks for it. For tracking and
@@ -264,13 +266,15 @@ pub use de::{Deserialize, Deserializer};
 #[doc(inline)]
 pub use ser::{Serialize, Serializer};
 
-// Generated code uses these to support no_std. Not public API.
+// Used by generated code and doc tests. Not public API.
 #[doc(hidden)]
-pub mod export;
+#[path = "private/mod.rs"]
+pub mod __private;
 
-// Helpers used by generated code and doc tests. Not public API.
+#[allow(unused_imports)]
-#[doc(hidden)]
+use self::__private as export;
-pub mod private;
+#[allow(unused_imports)]
+use self::__private as private;
 
 #[cfg(not(feature = "std"))]
 mod std_error;

serde/src/macros.rs

@@ -124,7 +124,7 @@ macro_rules! forward_to_deserialize_any {
 macro_rules! forward_to_deserialize_any_method {
     ($func:ident<$l:tt, $v:ident>($($arg:ident : $ty:ty),*)) => {
         #[inline]
-        fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::export::Result<$v::Value, Self::Error>
+        fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::__private::Result<$v::Value, Self::Error>
         where
             $v: $crate::de::Visitor<$l>,
         {

serde/src/private/macros.rs

@@ -37,7 +37,7 @@ macro_rules! __serialize_unimplemented {
 #[macro_export]
 macro_rules! __serialize_unimplemented_method {
     ($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => {
-        fn $func $(<$t: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::export::Result<Self::$ret, Self::Error> {
+        fn $func $(<$t: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error> {
             unimplemented!()
         }
     };

serde/src/private/mod.rs

@@ -2,3 +2,43 @@ mod macros;
 
 pub mod de;
 pub mod ser;
+
+pub use lib::clone::Clone;
+pub use lib::convert::{From, Into};
+pub use lib::default::Default;
+pub use lib::fmt::{self, Formatter};
+pub use lib::marker::PhantomData;
+pub use lib::option::Option::{self, None, Some};
+pub use lib::result::Result::{self, Err, Ok};
+
+pub use self::string::from_utf8_lossy;
+
+#[cfg(any(feature = "alloc", feature = "std"))]
+pub use lib::{ToString, Vec};
+
+#[cfg(core_try_from)]
+pub use lib::convert::TryFrom;
+
+mod string {
+    use lib::*;
+
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> {
+        String::from_utf8_lossy(bytes)
+    }
+
+    // The generated code calls this like:
+    //
+    //     let value = &_serde::__private::from_utf8_lossy(bytes);
+    //     Err(_serde::de::Error::unknown_variant(value, VARIANTS))
+    //
+    // so it is okay for the return type to be different from the std case as long
+    // as the above works.
+    #[cfg(not(any(feature = "std", feature = "alloc")))]
+    pub fn from_utf8_lossy(bytes: &[u8]) -> &str {
+        // Three unicode replacement characters if it fails. They look like a
+        // white-on-black question mark. The user will recognize it as invalid
+        // UTF-8.
+        str::from_utf8(bytes).unwrap_or("\u{fffd}\u{fffd}\u{fffd}")
+    }
+}

serde/src/ser/impossible.rs

@@ -17,7 +17,7 @@ use ser::{
 ///
 /// ```edition2018
 /// # use serde::ser::{Serializer, Impossible};
-/// # use serde::private::ser::Error;
+/// # use serde::__private::ser::Error;
 /// #
 /// # struct MySerializer;
 /// #

serde/src/ser/mod.rs

@@ -711,7 +711,7 @@ pub trait Serializer: Sized {
     ///
     /// ```edition2018
     /// # use serde::ser::{Serializer, SerializeSeq};
-    /// # use serde::private::ser::Error;
+    /// # use serde::__private::ser::Error;
     /// #
     /// # struct MySerializer;
     /// #

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.118" # remember to update html_root_url
+version = "1.0.119" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
@@ -22,7 +22,7 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0.33", features = ["visit"] }
+syn = { version = "1.0.58", features = ["visit"] }
 
 [dev-dependencies]
 serde = { version = "1.0", path = "../serde" }

serde_derive/src/internals/attr.rs

@@ -1393,7 +1393,7 @@ impl Field {
                 };
                 let span = Span::call_site();
                 path.segments.push(Ident::new("_serde", span).into());
-                path.segments.push(Ident::new("private", span).into());
+                path.segments.push(Ident::new("__private", span).into());
                 path.segments.push(Ident::new("de", span).into());
                 path.segments
                     .push(Ident::new("borrow_cow_str", span).into());
@@ -1410,7 +1410,7 @@ impl Field {
                 };
                 let span = Span::call_site();
                 path.segments.push(Ident::new("_serde", span).into());
-                path.segments.push(Ident::new("private", span).into());
+                path.segments.push(Ident::new("__private", span).into());
                 path.segments.push(Ident::new("de", span).into());
                 path.segments
                     .push(Ident::new("borrow_cow_bytes", span).into());

serde_derive/src/lib.rs

@@ -13,7 +13,7 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.118")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.119")]
 #![allow(unknown_lints, bare_trait_objects)]
 #![deny(clippy::all, clippy::pedantic)]
 // Ignored clippy lints

serde_derive/src/pretend.rs

@@ -74,9 +74,9 @@ fn pretend_fields_used(cont: &Container) -> TokenStream {
     };
 
     quote! {
-        match _serde::export::None::<#type_ident #ty_generics> {
+        match _serde::__private::None::<#type_ident #ty_generics> {
             #(
-                _serde::export::Some(#patterns) => {}
+                _serde::__private::Some(#patterns) => {}
             )*
             _ => {}
         }
@@ -120,8 +120,8 @@ fn pretend_variants_used(cont: &Container) -> TokenStream {
         };
 
         quote! {
-            match _serde::export::None {
+            match _serde::__private::None {
-                _serde::export::Some((#(#placeholders,)*)) => {
+                _serde::__private::Some((#(#placeholders,)*)) => {
                     let _ = #type_ident::#variant_ident #turbofish #pat;
                 }
                 _ => {}

serde_derive/src/ser.rs

@@ -29,7 +29,7 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
         let used = pretend::pretend_used(&cont);
         quote! {
             impl #impl_generics #ident #ty_generics #where_clause {
-                #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> #serde::export::Result<__S::Ok, __S::Error>
+                #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> #serde::__private::Result<__S::Ok, __S::Error>
                 where
                     __S: #serde::Serializer,
                 {
@@ -42,7 +42,7 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
         quote! {
             #[automatically_derived]
             impl #impl_generics #serde::Serialize for #ident #ty_generics #where_clause {
-                fn serialize<__S>(&self, __serializer: __S) -> #serde::export::Result<__S::Ok, __S::Error>
+                fn serialize<__S>(&self, __serializer: __S) -> #serde::__private::Result<__S::Ok, __S::Error>
                 where
                     __S: #serde::Serializer,
                 {
@@ -211,7 +211,7 @@ fn serialize_into(params: &Parameters, type_into: &syn::Type) -> Fragment {
     let self_var = &params.self_var;
     quote_block! {
         _serde::Serialize::serialize(
-            &_serde::export::Into::<#type_into>::into(_serde::export::Clone::clone(#self_var)),
+            &_serde::__private::Into::<#type_into>::into(_serde::__private::Clone::clone(#self_var)),
             __serializer)
     }
 }
@@ -372,7 +372,7 @@ fn serialize_struct_as_map(
     let let_mut = mut_if(serialized_fields.peek().is_some() || tag_field_exists);
 
     let len = if cattrs.has_flatten() {
-        quote!(_serde::export::None)
+        quote!(_serde::__private::None)
     } else {
         let len = serialized_fields
             .map(|field| match field.attrs.skip_serializing_if() {
@@ -386,7 +386,7 @@ fn serialize_struct_as_map(
                 quote!(#tag_field_exists as usize),
                 |sum, expr| quote!(#sum + #expr),
             );
-        quote!(_serde::export::Some(#len))
+        quote!(_serde::__private::Some(#len))
     };
 
     quote_block! {
@@ -433,7 +433,7 @@ fn serialize_variant(
             variant_ident
         );
         let skipped_err = quote! {
-            _serde::export::Err(_serde::ser::Error::custom(#skipped_msg))
+            _serde::__private::Err(_serde::ser::Error::custom(#skipped_msg))
         };
         let fields_pat = match variant.style {
             Style::Unit => quote!(),
@@ -578,7 +578,7 @@ fn serialize_internally_tagged_variant(
     if let Some(path) = variant.attrs.serialize_with() {
         let ser = wrap_serialize_variant_with(params, path, variant);
         return quote_expr! {
-            _serde::private::ser::serialize_tagged_newtype(
+            _serde::__private::ser::serialize_tagged_newtype(
                 __serializer,
                 #enum_ident_str,
                 #variant_ident_str,
@@ -607,7 +607,7 @@ fn serialize_internally_tagged_variant(
             }
 
             let span = field.original.span();
-            let func = quote_spanned!(span=> _serde::private::ser::serialize_tagged_newtype);
+            let func = quote_spanned!(span=> _serde::__private::ser::serialize_tagged_newtype);
             quote_expr! {
                 #func(
                     __serializer,
@@ -715,11 +715,11 @@ fn serialize_adjacently_tagged_variant(
     quote_block! {
         struct __AdjacentlyTagged #wrapper_generics #where_clause {
             data: (#(&'__a #fields_ty,)*),
-            phantom: _serde::export::PhantomData<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData<#this #ty_generics>,
         }
 
         impl #wrapper_impl_generics _serde::Serialize for __AdjacentlyTagged #wrapper_ty_generics #where_clause {
-            fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+            fn serialize<__S>(&self, __serializer: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
             where
                 __S: _serde::Serializer,
             {
@@ -737,7 +737,7 @@ fn serialize_adjacently_tagged_variant(
         try!(_serde::ser::SerializeStruct::serialize_field(
             &mut __struct, #content, &__AdjacentlyTagged {
                 data: (#(#fields_ident,)*),
-                phantom: _serde::export::PhantomData::<#this #ty_generics>,
+                phantom: _serde::__private::PhantomData::<#this #ty_generics>,
             }));
         _serde::ser::SerializeStruct::end(__struct)
     }
@@ -978,18 +978,18 @@ fn serialize_struct_variant_with_flatten<'a>(
             quote_block! {
                 struct __EnumFlatten #wrapper_generics #where_clause {
                     data: (#(&'__a #fields_ty,)*),
-                    phantom: _serde::export::PhantomData<#this #ty_generics>,
+                    phantom: _serde::__private::PhantomData<#this #ty_generics>,
                 }
 
                 impl #wrapper_impl_generics _serde::Serialize for __EnumFlatten #wrapper_ty_generics #where_clause {
-                    fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+                    fn serialize<__S>(&self, __serializer: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
                     where
                         __S: _serde::Serializer,
                     {
                         let (#(#members,)*) = self.data;
                         let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
                             __serializer,
-                            _serde::export::None));
+                            _serde::__private::None));
                         #(#serialize_fields)*
                         _serde::ser::SerializeMap::end(__serde_state)
                     }
@@ -1002,7 +1002,7 @@ fn serialize_struct_variant_with_flatten<'a>(
                     #variant_name,
                     &__EnumFlatten {
                         data: (#(#members,)*),
-                        phantom: _serde::export::PhantomData::<#this #ty_generics>,
+                        phantom: _serde::__private::PhantomData::<#this #ty_generics>,
                     })
             }
         }
@@ -1010,7 +1010,7 @@ fn serialize_struct_variant_with_flatten<'a>(
             quote_block! {
                 let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
                     __serializer,
-                    _serde::export::None));
+                    _serde::__private::None));
                 try!(_serde::ser::SerializeMap::serialize_entry(
                     &mut __serde_state,
                     #tag,
@@ -1024,7 +1024,7 @@ fn serialize_struct_variant_with_flatten<'a>(
             quote_block! {
                 let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
                     __serializer,
-                    _serde::export::None));
+                    _serde::__private::None));
                 #(#serialize_fields)*
                 _serde::ser::SerializeMap::end(__serde_state)
             }
@@ -1113,7 +1113,7 @@ fn serialize_struct_visitor(
             let ser = if field.attrs.flatten() {
                 let func = quote_spanned!(span=> _serde::Serialize::serialize);
                 quote! {
-                    try!(#func(&#field_expr, _serde::private::ser::FlatMapSerializer(&mut __serde_state)));
+                    try!(#func(&#field_expr, _serde::__private::ser::FlatMapSerializer(&mut __serde_state)));
                 }
             } else {
                 let func = struct_trait.serialize_field(span);
@@ -1208,11 +1208,11 @@ fn wrap_serialize_with(
     quote!({
         struct __SerializeWith #wrapper_impl_generics #where_clause {
             values: (#(&'__a #field_tys, )*),
-            phantom: _serde::export::PhantomData<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData<#this #ty_generics>,
         }
 
         impl #wrapper_impl_generics _serde::Serialize for __SerializeWith #wrapper_ty_generics #where_clause {
-            fn serialize<__S>(&self, __s: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+            fn serialize<__S>(&self, __s: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
             where
                 __S: _serde::Serializer,
             {
@@ -1222,7 +1222,7 @@ fn wrap_serialize_with(
 
         &__SerializeWith {
             values: (#(#field_exprs, )*),
-            phantom: _serde::export::PhantomData::<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData::<#this #ty_generics>,
         }
     })
 }
@@ -1258,11 +1258,11 @@ fn get_member(params: &Parameters, field: &Field, member: &Member) -> TokenStrea
                 quote!(&#self_var.#member)
             };
             let ty = field.ty;
-            quote!(_serde::private::ser::constrain::<#ty>(#inner))
+            quote!(_serde::__private::ser::constrain::<#ty>(#inner))
         }
         (true, Some(getter)) => {
             let ty = field.ty;
-            quote!(_serde::private::ser::constrain::<#ty>(&#getter(#self_var)))
+            quote!(_serde::__private::ser::constrain::<#ty>(&#getter(#self_var)))
         }
         (false, Some(_)) => {
             unreachable!("getter is only allowed for remote impls");

serde_derive/src/try.rs

@@ -13,9 +13,9 @@ pub fn replacement() -> TokenStream {
         macro_rules! try {
             (#dollar __expr:expr) => {
                 match #dollar __expr {
-                    _serde::export::Ok(__val) => __val,
+                    _serde::__private::Ok(__val) => __val,
-                    _serde::export::Err(__err) => {
+                    _serde::__private::Err(__err) => {
-                        return _serde::export::Err(__err);
+                        return _serde::__private::Err(__err);
                     }
                 }
             }

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "1.0.118" # remember to update html_root_url
+version = "1.0.119" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"

serde_test/src/lib.rs

@@ -144,7 +144,7 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.118")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.119")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy lints

test_suite/tests/expand/default_ty_param.expanded.rs

@@ -15,7 +15,10 @@ const _: () = {
     extern crate serde as _serde;
     #[automatically_derived]
     impl<T: AssociatedType<X = i32>> _serde::Serialize for DefaultTyParam<T> {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -24,9 +27,9 @@ const _: () = {
                 "DefaultTyParam",
                 false as usize + 1,
             ) {
-                _serde::export::Ok(__val) => __val,
+                _serde::__private::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
+                _serde::__private::Err(__err) => {
-                    return _serde::export::Err(__err);
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeStruct::serialize_field(
@@ -34,9 +37,9 @@ const _: () = {
                 "phantom",
                 &self.phantom,
             ) {
-                _serde::export::Ok(__val) => __val,
+                _serde::__private::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
+                _serde::__private::Err(__err) => {
-                    return _serde::export::Err(__err);
+                    return _serde::__private::Err(__err);
                 }
             };
             _serde::ser::SerializeStruct::end(__serde_state)
@@ -50,7 +53,7 @@ const _: () = {
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de, T: AssociatedType<X = i32>> _serde::Deserialize<'de> for DefaultTyParam<T> {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -64,47 +67,52 @@ const _: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
+                        0u64 => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        _ => _serde::__private::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<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "phantom" => _serde::export::Ok(__Field::__field0),
+                        "phantom" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"phantom" => _serde::export::Ok(__Field::__field0),
+                        b"phantom" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -112,76 +120,77 @@ const _: () = {
                 }
             }
             struct __Visitor<'de, T: AssociatedType<X = i32>> {
-                marker: _serde::export::PhantomData<DefaultTyParam<T>>,
+                marker: _serde::__private::PhantomData<DefaultTyParam<T>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, T: AssociatedType<X = i32>> _serde::de::Visitor<'de> for __Visitor<'de, T> {
                 type Value = DefaultTyParam<T>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct DefaultTyParam")
+                    _serde::__private::Formatter::write_str(__formatter, "struct DefaultTyParam")
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
                     let __field0 = match match _serde::de::SeqAccess::next_element::<PhantomData<T>>(
                         &mut __seq,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
+                        _serde::__private::Some(__value) => __value,
-                        _serde::export::None => {
+                        _serde::__private::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 0usize,
                                 &"struct DefaultTyParam with 1 element",
                             ));
                         }
                     };
-                    _serde::export::Ok(DefaultTyParam { phantom: __field0 })
+                    _serde::__private::Ok(DefaultTyParam { phantom: __field0 })
                 }
                 #[inline]
                 fn visit_map<__A>(
                     self,
                     mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::MapAccess<'de>,
                 {
-                    let mut __field0: _serde::export::Option<PhantomData<T>> = _serde::export::None;
+                    let mut __field0: _serde::__private::Option<PhantomData<T>> =
-                    while let _serde::export::Some(__key) =
+                        _serde::__private::None;
+                    while let _serde::__private::Some(__key) =
                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
+                            _serde::__private::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
+                            _serde::__private::Err(__err) => {
-                                return _serde::export::Err(__err);
+                                return _serde::__private::Err(__err);
                             }
                         }
                     {
                         match __key {
                             __Field::__field0 => {
-                                if _serde::export::Option::is_some(&__field0) {
+                                if _serde::__private::Option::is_some(&__field0) {
-                                    return _serde::export::Err(
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field(
                                             "phantom",
                                         ),
                                     );
                                 }
-                                __field0 = _serde::export::Some(
+                                __field0 = _serde::__private::Some(
                                     match _serde::de::MapAccess::next_value::<PhantomData<T>>(
                                         &mut __map,
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
+                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
+                                        _serde::__private::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                            return _serde::__private::Err(__err);
                                         }
                                     },
                                 );
@@ -191,25 +200,26 @@ const _: () = {
                                     _serde::de::IgnoredAny,
                                 >(&mut __map)
                                 {
-                                    _serde::export::Ok(__val) => __val,
+                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
+                                    _serde::__private::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                             }
                         }
                     }
                     let __field0 = match __field0 {
-                        _serde::export::Some(__field0) => __field0,
+                        _serde::__private::Some(__field0) => __field0,
-                        _serde::export::None => match _serde::private::de::missing_field("phantom")
+                        _serde::__private::None => {
-                        {
+                            match _serde::__private::de::missing_field("phantom") {
-                            _serde::export::Ok(__val) => __val,
+                                _serde::__private::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
+                                _serde::__private::Err(__err) => {
-                                return _serde::export::Err(__err);
+                                    return _serde::__private::Err(__err);
+                                }
                             }
-                        },
+                        }
                     };
-                    _serde::export::Ok(DefaultTyParam { phantom: __field0 })
+                    _serde::__private::Ok(DefaultTyParam { phantom: __field0 })
                 }
             }
             const FIELDS: &'static [&'static str] = &["phantom"];
@@ -218,15 +228,15 @@ const _: () = {
                 "DefaultTyParam",
                 FIELDS,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<DefaultTyParam<T>>,
+                    marker: _serde::__private::PhantomData::<DefaultTyParam<T>>,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
         fn deserialize_in_place<__D>(
             __deserializer: __D,
             __place: &mut Self,
-        ) -> _serde::export::Result<(), __D::Error>
+        ) -> _serde::__private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -240,47 +250,52 @@ const _: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
+                        0u64 => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        _ => _serde::__private::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<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "phantom" => _serde::export::Ok(__Field::__field0),
+                        "phantom" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"phantom" => _serde::export::Ok(__Field::__field0),
+                        b"phantom" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -289,7 +304,7 @@ const _: () = {
             }
             struct __Visitor<'de, 'place, T: AssociatedType<X = i32> + 'place> {
                 place: &'place mut DefaultTyParam<T>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, T: AssociatedType<X = i32> + 'place> _serde::de::Visitor<'de>
                 for __Visitor<'de, 'place, T>
@@ -297,55 +312,55 @@ const _: () = {
                 type Value = ();
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct DefaultTyParam")
+                    _serde::__private::Formatter::write_str(__formatter, "struct DefaultTyParam")
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.phantom),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.phantom),
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             0usize,
                             &"struct DefaultTyParam with 1 element",
                         ));
                     }
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
                 #[inline]
                 fn visit_map<__A>(
                     self,
                     mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::MapAccess<'de>,
                 {
                     let mut __field0: bool = false;
-                    while let _serde::export::Some(__key) =
+                    while let _serde::__private::Some(__key) =
                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
+                            _serde::__private::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
+                            _serde::__private::Err(__err) => {
-                                return _serde::export::Err(__err);
+                                return _serde::__private::Err(__err);
                             }
                         }
                     {
                         match __key {
                             __Field::__field0 => {
                                 if __field0 {
-                                    return _serde::export::Err(
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field(
                                             "phantom",
                                         ),
@@ -353,11 +368,11 @@ const _: () = {
                                 }
                                 match _serde::de::MapAccess::next_value_seed(
                                     &mut __map,
-                                    _serde::private::de::InPlaceSeed(&mut self.place.phantom),
+                                    _serde::__private::de::InPlaceSeed(&mut self.place.phantom),
                                 ) {
-                                    _serde::export::Ok(__val) => __val,
+                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
+                                    _serde::__private::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                                 __field0 = true;
@@ -367,23 +382,23 @@ const _: () = {
                                     _serde::de::IgnoredAny,
                                 >(&mut __map)
                                 {
-                                    _serde::export::Ok(__val) => __val,
+                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
+                                    _serde::__private::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                             }
                         }
                     }
                     if !__field0 {
-                        self.place.phantom = match _serde::private::de::missing_field("phantom") {
+                        self.place.phantom = match _serde::__private::de::missing_field("phantom") {
-                            _serde::export::Ok(__val) => __val,
+                            _serde::__private::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
+                            _serde::__private::Err(__err) => {
-                                return _serde::export::Err(__err);
+                                return _serde::__private::Err(__err);
                             }
                         };
                     };
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
             }
             const FIELDS: &'static [&'static str] = &["phantom"];
@@ -393,7 +408,7 @@ const _: () = {
                 FIELDS,
                 __Visitor {
                     place: __place,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/generic_enum.expanded.rs

@@ -16,7 +16,10 @@ const _: () = {
         T: _serde::Serialize,
         U: _serde::Serialize,
     {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -44,27 +47,27 @@ const _: () = {
                         "Seq",
                         0 + 1 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field0,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
@@ -77,9 +80,9 @@ const _: () = {
                         "Map",
                         0 + 1 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -87,9 +90,9 @@ const _: () = {
                         "x",
                         x,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -97,9 +100,9 @@ const _: () = {
                         "y",
                         y,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)
@@ -119,7 +122,7 @@ const _: () = {
         T: _serde::Deserialize<'de>,
         U: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -135,35 +138,38 @@ const _: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "variant identifier")
+                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
+                        0u64 => _serde::__private::Ok(__Field::__field0),
-                        1u64 => _serde::export::Ok(__Field::__field1),
+                        1u64 => _serde::__private::Ok(__Field::__field1),
-                        2u64 => _serde::export::Ok(__Field::__field2),
+                        2u64 => _serde::__private::Ok(__Field::__field2),
-                        3u64 => _serde::export::Ok(__Field::__field3),
+                        3u64 => _serde::__private::Ok(__Field::__field3),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        _ => _serde::__private::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<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "Unit" => _serde::export::Ok(__Field::__field0),
+                        "Unit" => _serde::__private::Ok(__Field::__field0),
-                        "NewType" => _serde::export::Ok(__Field::__field1),
+                        "NewType" => _serde::__private::Ok(__Field::__field1),
-                        "Seq" => _serde::export::Ok(__Field::__field2),
+                        "Seq" => _serde::__private::Ok(__Field::__field2),
-                        "Map" => _serde::export::Ok(__Field::__field3),
+                        "Map" => _serde::__private::Ok(__Field::__field3),
-                        _ => _serde::export::Err(_serde::de::Error::unknown_variant(
+                        _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
                             __value, VARIANTS,
                         )),
                     }
@@ -171,18 +177,18 @@ const _: () = {
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"Unit" => _serde::export::Ok(__Field::__field0),
+                        b"Unit" => _serde::__private::Ok(__Field::__field0),
-                        b"NewType" => _serde::export::Ok(__Field::__field1),
+                        b"NewType" => _serde::__private::Ok(__Field::__field1),
-                        b"Seq" => _serde::export::Ok(__Field::__field2),
+                        b"Seq" => _serde::__private::Ok(__Field::__field2),
-                        b"Map" => _serde::export::Ok(__Field::__field3),
+                        b"Map" => _serde::__private::Ok(__Field::__field3),
                         _ => {
-                            let __value = &_serde::export::from_utf8_lossy(__value);
+                            let __value = &_serde::__private::from_utf8_lossy(__value);
-                            _serde::export::Err(_serde::de::Error::unknown_variant(
+                            _serde::__private::Err(_serde::de::Error::unknown_variant(
                                 __value, VARIANTS,
                             ))
                         }
@@ -191,7 +197,9 @@ const _: () = {
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -203,8 +211,8 @@ const _: () = {
                 T: _serde::Deserialize<'de>,
                 U: _serde::Deserialize<'de>,
             {
-                marker: _serde::export::PhantomData<GenericEnum<T, U>>,
+                marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
             where
@@ -214,33 +222,33 @@ const _: () = {
                 type Value = GenericEnum<T, U>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "enum GenericEnum")
+                    _serde::__private::Formatter::write_str(__formatter, "enum GenericEnum")
                 }
                 fn visit_enum<__A>(
                     self,
                     __data: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::EnumAccess<'de>,
                 {
                     match match _serde::de::EnumAccess::variant(__data) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
                         (__Field::__field0, __variant) => {
                             match _serde::de::VariantAccess::unit_variant(__variant) {
-                                _serde::export::Ok(__val) => __val,
+                                _serde::__private::Ok(__val) => __val,
-                                _serde::export::Err(__err) => {
+                                _serde::__private::Err(__err) => {
-                                    return _serde::export::Err(__err);
+                                    return _serde::__private::Err(__err);
                                 }
                             };
-                            _serde::export::Ok(GenericEnum::Unit)
+                            _serde::__private::Ok(GenericEnum::Unit)
                         }
-                        (__Field::__field1, __variant) => _serde::export::Result::map(
+                        (__Field::__field1, __variant) => _serde::__private::Result::map(
                             _serde::de::VariantAccess::newtype_variant::<T>(__variant),
                             GenericEnum::NewType,
                         ),
@@ -250,8 +258,8 @@ const _: () = {
                                 T: _serde::Deserialize<'de>,
                                 U: _serde::Deserialize<'de>,
                             {
-                                marker: _serde::export::PhantomData<GenericEnum<T, U>>,
+                                marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
-                                lifetime: _serde::export::PhantomData<&'de ()>,
+                                lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
                             impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
                             where
@@ -261,9 +269,10 @@ const _: () = {
                                 type Value = GenericEnum<T, U>;
                                 fn expecting(
                                     &self,
-                                    __formatter: &mut _serde::export::Formatter,
+                                    __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::export::fmt::Result {
+                                ) -> _serde::__private::fmt::Result
-                                    _serde::export::Formatter::write_str(
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "tuple variant GenericEnum::Seq",
                                     )
@@ -272,7 +281,7 @@ const _: () = {
                                 fn visit_seq<__A>(
                                     self,
                                     mut __seq: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::SeqAccess<'de>,
                                 {
@@ -281,14 +290,14 @@ const _: () = {
                                     >(
                                         &mut __seq
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
+                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
+                                        _serde::__private::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                            return _serde::__private::Err(__err);
                                         }
                                     } {
-                                        _serde::export::Some(__value) => __value,
+                                        _serde::__private::Some(__value) => __value,
-                                        _serde::export::None => {
+                                        _serde::__private::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "tuple variant GenericEnum::Seq with 2 elements" ) ) ;
+                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "tuple variant GenericEnum::Seq with 2 elements")) ;
                                         }
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
@@ -296,25 +305,25 @@ const _: () = {
                                     >(
                                         &mut __seq
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
+                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
+                                        _serde::__private::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                            return _serde::__private::Err(__err);
                                         }
                                     } {
-                                        _serde::export::Some(__value) => __value,
+                                        _serde::__private::Some(__value) => __value,
-                                        _serde::export::None => {
+                                        _serde::__private::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "tuple variant GenericEnum::Seq with 2 elements" ) ) ;
+                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (1usize , & "tuple variant GenericEnum::Seq with 2 elements")) ;
                                         }
                                     };
-                                    _serde::export::Ok(GenericEnum::Seq(__field0, __field1))
+                                    _serde::__private::Ok(GenericEnum::Seq(__field0, __field1))
                                 }
                             }
                             _serde::de::VariantAccess::tuple_variant(
                                 __variant,
                                 2usize,
                                 __Visitor {
-                                    marker: _serde::export::PhantomData::<GenericEnum<T, U>>,
+                                    marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
-                                    lifetime: _serde::export::PhantomData,
+                                    lifetime: _serde::__private::PhantomData,
                                 },
                             )
                         }
@@ -330,9 +339,10 @@ const _: () = {
                                 type Value = __Field;
                                 fn expecting(
                                     &self,
-                                    __formatter: &mut _serde::export::Formatter,
+                                    __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::export::fmt::Result {
+                                ) -> _serde::__private::fmt::Result
-                                    _serde::export::Formatter::write_str(
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
                                     )
@@ -340,43 +350,45 @@ const _: () = {
                                 fn visit_u64<__E>(
                                     self,
                                     __value: u64,
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        0u64 => _serde::export::Ok(__Field::__field0),
+                                        0u64 => _serde::__private::Ok(__Field::__field0),
-                                        1u64 => _serde::export::Ok(__Field::__field1),
+                                        1u64 => _serde::__private::Ok(__Field::__field1),
-                                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                                        _ => _serde::__private::Err(
-                                            _serde::de::Unexpected::Unsigned(__value),
+                                            _serde::de::Error::invalid_value(
-                                            &"field index 0 <= i < 2",
+                                                _serde::de::Unexpected::Unsigned(__value),
-                                        )),
+                                                &"field index 0 <= i < 2",
+                                            ),
+                                        ),
                                     }
                                 }
                                 fn visit_str<__E>(
                                     self,
                                     __value: &str,
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        "x" => _serde::export::Ok(__Field::__field0),
+                                        "x" => _serde::__private::Ok(__Field::__field0),
-                                        "y" => _serde::export::Ok(__Field::__field1),
+                                        "y" => _serde::__private::Ok(__Field::__field1),
-                                        _ => _serde::export::Ok(__Field::__ignore),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                                 fn visit_bytes<__E>(
                                     self,
                                     __value: &[u8],
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        b"x" => _serde::export::Ok(__Field::__field0),
+                                        b"x" => _serde::__private::Ok(__Field::__field0),
-                                        b"y" => _serde::export::Ok(__Field::__field1),
+                                        b"y" => _serde::__private::Ok(__Field::__field1),
-                                        _ => _serde::export::Ok(__Field::__ignore),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                             }
@@ -384,7 +396,7 @@ const _: () = {
                                 #[inline]
                                 fn deserialize<__D>(
                                     __deserializer: __D,
-                                ) -> _serde::export::Result<Self, __D::Error>
+                                ) -> _serde::__private::Result<Self, __D::Error>
                                 where
                                     __D: _serde::Deserializer<'de>,
                                 {
@@ -399,8 +411,8 @@ const _: () = {
                                 T: _serde::Deserialize<'de>,
                                 U: _serde::Deserialize<'de>,
                             {
-                                marker: _serde::export::PhantomData<GenericEnum<T, U>>,
+                                marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
-                                lifetime: _serde::export::PhantomData<&'de ()>,
+                                lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
                             impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
                             where
@@ -410,9 +422,10 @@ const _: () = {
                                 type Value = GenericEnum<T, U>;
                                 fn expecting(
                                     &self,
-                                    __formatter: &mut _serde::export::Formatter,
+                                    __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::export::fmt::Result {
+                                ) -> _serde::__private::fmt::Result
-                                    _serde::export::Formatter::write_str(
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant GenericEnum::Map",
                                     )
@@ -421,7 +434,7 @@ const _: () = {
                                 fn visit_seq<__A>(
                                     self,
                                     mut __seq: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::SeqAccess<'de>,
                                 {
@@ -430,14 +443,14 @@ const _: () = {
                                     >(
                                         &mut __seq
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
+                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
+                                        _serde::__private::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                            return _serde::__private::Err(__err);
                                         }
                                     } {
-                                        _serde::export::Some(__value) => __value,
+                                        _serde::__private::Some(__value) => __value,
-                                        _serde::export::None => {
+                                        _serde::__private::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant GenericEnum::Map with 2 elements" ) ) ;
+                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant GenericEnum::Map with 2 elements")) ;
                                         }
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
@@ -445,17 +458,17 @@ const _: () = {
                                     >(
                                         &mut __seq
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
+                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
+                                        _serde::__private::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                            return _serde::__private::Err(__err);
                                         }
                                     } {
-                                        _serde::export::Some(__value) => __value,
+                                        _serde::__private::Some(__value) => __value,
-                                        _serde::export::None => {
+                                        _serde::__private::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant GenericEnum::Map with 2 elements" ) ) ;
+                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (1usize , & "struct variant GenericEnum::Map with 2 elements")) ;
                                         }
                                     };
-                                    _serde::export::Ok(GenericEnum::Map {
+                                    _serde::__private::Ok(GenericEnum::Map {
                                         x: __field0,
                                         y: __field1,
                                     })
@@ -464,50 +477,50 @@ const _: () = {
                                 fn visit_map<__A>(
                                     self,
                                     mut __map: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::export::Option<T> =
+                                    let mut __field0: _serde::__private::Option<T> =
-                                        _serde::export::None;
+                                        _serde::__private::None;
-                                    let mut __field1: _serde::export::Option<U> =
+                                    let mut __field1: _serde::__private::Option<U> =
-                                        _serde::export::None;
+                                        _serde::__private::None;
-                                    while let _serde::export::Some(__key) =
+                                    while let _serde::__private::Some(__key) =
                                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                         {
-                                            _serde::export::Ok(__val) => __val,
+                                            _serde::__private::Ok(__val) => __val,
-                                            _serde::export::Err(__err) => {
+                                            _serde::__private::Err(__err) => {
-                                                return _serde::export::Err(__err);
+                                                return _serde::__private::Err(__err);
                                             }
                                         }
                                     {
                                         match __key {
                                             __Field::__field0 => {
-                                                if _serde::export::Option::is_some(&__field0) {
+                                                if _serde::__private::Option::is_some(&__field0) {
-                                                    return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "x" ) ) ;
+                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("x")) ;
                                                 }
-                                                __field0 = _serde::export::Some(
+                                                __field0 = _serde::__private::Some(
                                                     match _serde::de::MapAccess::next_value::<T>(
                                                         &mut __map,
                                                     ) {
-                                                        _serde::export::Ok(__val) => __val,
+                                                        _serde::__private::Ok(__val) => __val,
-                                                        _serde::export::Err(__err) => {
+                                                        _serde::__private::Err(__err) => {
-                                                            return _serde::export::Err(__err);
+                                                            return _serde::__private::Err(__err);
                                                         }
                                                     },
                                                 );
                                             }
                                             __Field::__field1 => {
-                                                if _serde::export::Option::is_some(&__field1) {
+                                                if _serde::__private::Option::is_some(&__field1) {
-                                                    return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "y" ) ) ;
+                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("y")) ;
                                                 }
-                                                __field1 = _serde::export::Some(
+                                                __field1 = _serde::__private::Some(
                                                     match _serde::de::MapAccess::next_value::<U>(
                                                         &mut __map,
                                                     ) {
-                                                        _serde::export::Ok(__val) => __val,
+                                                        _serde::__private::Ok(__val) => __val,
-                                                        _serde::export::Err(__err) => {
+                                                        _serde::__private::Err(__err) => {
-                                                            return _serde::export::Err(__err);
+                                                            return _serde::__private::Err(__err);
                                                         }
                                                     },
                                                 );
@@ -518,37 +531,37 @@ const _: () = {
                                                 >(
                                                     &mut __map
                                                 ) {
-                                                    _serde::export::Ok(__val) => __val,
+                                                    _serde::__private::Ok(__val) => __val,
-                                                    _serde::export::Err(__err) => {
+                                                    _serde::__private::Err(__err) => {
-                                                        return _serde::export::Err(__err);
+                                                        return _serde::__private::Err(__err);
                                                     }
                                                 };
                                             }
                                         }
                                     }
                                     let __field0 = match __field0 {
-                                        _serde::export::Some(__field0) => __field0,
+                                        _serde::__private::Some(__field0) => __field0,
-                                        _serde::export::None => {
+                                        _serde::__private::None => {
-                                            match _serde::private::de::missing_field("x") {
+                                            match _serde::__private::de::missing_field("x") {
-                                                _serde::export::Ok(__val) => __val,
+                                                _serde::__private::Ok(__val) => __val,
-                                                _serde::export::Err(__err) => {
+                                                _serde::__private::Err(__err) => {
-                                                    return _serde::export::Err(__err);
+                                                    return _serde::__private::Err(__err);
                                                 }
                                             }
                                         }
                                     };
                                     let __field1 = match __field1 {
-                                        _serde::export::Some(__field1) => __field1,
+                                        _serde::__private::Some(__field1) => __field1,
-                                        _serde::export::None => {
+                                        _serde::__private::None => {
-                                            match _serde::private::de::missing_field("y") {
+                                            match _serde::__private::de::missing_field("y") {
-                                                _serde::export::Ok(__val) => __val,
+                                                _serde::__private::Ok(__val) => __val,
-                                                _serde::export::Err(__err) => {
+                                                _serde::__private::Err(__err) => {
-                                                    return _serde::export::Err(__err);
+                                                    return _serde::__private::Err(__err);
                                                 }
                                             }
                                         }
                                     };
-                                    _serde::export::Ok(GenericEnum::Map {
+                                    _serde::__private::Ok(GenericEnum::Map {
                                         x: __field0,
                                         y: __field1,
                                     })
@@ -559,8 +572,8 @@ const _: () = {
                                 __variant,
                                 FIELDS,
                                 __Visitor {
-                                    marker: _serde::export::PhantomData::<GenericEnum<T, U>>,
+                                    marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
-                                    lifetime: _serde::export::PhantomData,
+                                    lifetime: _serde::__private::PhantomData,
                                 },
                             )
                         }
@@ -573,8 +586,8 @@ const _: () = {
                 "GenericEnum",
                 VARIANTS,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<GenericEnum<T, U>>,
+                    marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/generic_struct.expanded.rs

@@ -12,7 +12,10 @@ const _: () = {
     where
         T: _serde::Serialize,
     {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -21,15 +24,15 @@ const _: () = {
                 "GenericStruct",
                 false as usize + 1,
             ) {
-                _serde::export::Ok(__val) => __val,
+                _serde::__private::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
+                _serde::__private::Err(__err) => {
-                    return _serde::export::Err(__err);
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "x", &self.x) {
-                _serde::export::Ok(__val) => __val,
+                _serde::__private::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
+                _serde::__private::Err(__err) => {
-                    return _serde::export::Err(__err);
+                    return _serde::__private::Err(__err);
                 }
             };
             _serde::ser::SerializeStruct::end(__serde_state)
@@ -46,7 +49,7 @@ const _: () = {
     where
         T: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -60,47 +63,52 @@ const _: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
+                        0u64 => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        _ => _serde::__private::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<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "x" => _serde::export::Ok(__Field::__field0),
+                        "x" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"x" => _serde::export::Ok(__Field::__field0),
+                        b"x" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -111,8 +119,8 @@ const _: () = {
             where
                 T: _serde::Deserialize<'de>,
             {
-                marker: _serde::export::PhantomData<GenericStruct<T>>,
+                marker: _serde::__private::PhantomData<GenericStruct<T>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T>
             where
@@ -121,64 +129,64 @@ const _: () = {
                 type Value = GenericStruct<T>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct GenericStruct")
+                    _serde::__private::Formatter::write_str(__formatter, "struct GenericStruct")
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
                     let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
+                        _serde::__private::Some(__value) => __value,
-                        _serde::export::None => {
+                        _serde::__private::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 0usize,
                                 &"struct GenericStruct with 1 element",
                             ));
                         }
                     };
-                    _serde::export::Ok(GenericStruct { x: __field0 })
+                    _serde::__private::Ok(GenericStruct { x: __field0 })
                 }
                 #[inline]
                 fn visit_map<__A>(
                     self,
                     mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::MapAccess<'de>,
                 {
-                    let mut __field0: _serde::export::Option<T> = _serde::export::None;
+                    let mut __field0: _serde::__private::Option<T> = _serde::__private::None;
-                    while let _serde::export::Some(__key) =
+                    while let _serde::__private::Some(__key) =
                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
+                            _serde::__private::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
+                            _serde::__private::Err(__err) => {
-                                return _serde::export::Err(__err);
+                                return _serde::__private::Err(__err);
                             }
                         }
                     {
                         match __key {
                             __Field::__field0 => {
-                                if _serde::export::Option::is_some(&__field0) {
+                                if _serde::__private::Option::is_some(&__field0) {
-                                    return _serde::export::Err(
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field("x"),
                                     );
                                 }
-                                __field0 = _serde::export::Some(
+                                __field0 = _serde::__private::Some(
                                     match _serde::de::MapAccess::next_value::<T>(&mut __map) {
-                                        _serde::export::Ok(__val) => __val,
+                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
+                                        _serde::__private::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                            return _serde::__private::Err(__err);
                                         }
                                     },
                                 );
@@ -188,24 +196,26 @@ const _: () = {
                                     _serde::de::IgnoredAny,
                                 >(&mut __map)
                                 {
-                                    _serde::export::Ok(__val) => __val,
+                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
+                                    _serde::__private::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                             }
                         }
                     }
                     let __field0 = match __field0 {
-                        _serde::export::Some(__field0) => __field0,
+                        _serde::__private::Some(__field0) => __field0,
-                        _serde::export::None => match _serde::private::de::missing_field("x") {
+                        _serde::__private::None => {
-                            _serde::export::Ok(__val) => __val,
+                            match _serde::__private::de::missing_field("x") {
-                            _serde::export::Err(__err) => {
+                                _serde::__private::Ok(__val) => __val,
-                                return _serde::export::Err(__err);
+                                _serde::__private::Err(__err) => {
+                                    return _serde::__private::Err(__err);
+                                }
                             }
-                        },
+                        }
                     };
-                    _serde::export::Ok(GenericStruct { x: __field0 })
+                    _serde::__private::Ok(GenericStruct { x: __field0 })
                 }
             }
             const FIELDS: &'static [&'static str] = &["x"];
@@ -214,15 +224,15 @@ const _: () = {
                 "GenericStruct",
                 FIELDS,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<GenericStruct<T>>,
+                    marker: _serde::__private::PhantomData::<GenericStruct<T>>,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
         fn deserialize_in_place<__D>(
             __deserializer: __D,
             __place: &mut Self,
-        ) -> _serde::export::Result<(), __D::Error>
+        ) -> _serde::__private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -236,47 +246,52 @@ const _: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
+                        0u64 => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        _ => _serde::__private::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<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "x" => _serde::export::Ok(__Field::__field0),
+                        "x" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"x" => _serde::export::Ok(__Field::__field0),
+                        b"x" => _serde::__private::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -288,7 +303,7 @@ const _: () = {
                 T: _serde::Deserialize<'de>,
             {
                 place: &'place mut GenericStruct<T>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T>
             where
@@ -297,65 +312,65 @@ const _: () = {
                 type Value = ();
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct GenericStruct")
+                    _serde::__private::Formatter::write_str(__formatter, "struct GenericStruct")
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.x),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.x),
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             0usize,
                             &"struct GenericStruct with 1 element",
                         ));
                     }
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
                 #[inline]
                 fn visit_map<__A>(
                     self,
                     mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::MapAccess<'de>,
                 {
                     let mut __field0: bool = false;
-                    while let _serde::export::Some(__key) =
+                    while let _serde::__private::Some(__key) =
                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
+                            _serde::__private::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
+                            _serde::__private::Err(__err) => {
-                                return _serde::export::Err(__err);
+                                return _serde::__private::Err(__err);
                             }
                         }
                     {
                         match __key {
                             __Field::__field0 => {
                                 if __field0 {
-                                    return _serde::export::Err(
+                                    return _serde::__private::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::__private::de::InPlaceSeed(&mut self.place.x),
                                 ) {
-                                    _serde::export::Ok(__val) => __val,
+                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
+                                    _serde::__private::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                                 __field0 = true;
@@ -365,23 +380,23 @@ const _: () = {
                                     _serde::de::IgnoredAny,
                                 >(&mut __map)
                                 {
-                                    _serde::export::Ok(__val) => __val,
+                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
+                                    _serde::__private::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                             }
                         }
                     }
                     if !__field0 {
-                        self.place.x = match _serde::private::de::missing_field("x") {
+                        self.place.x = match _serde::__private::de::missing_field("x") {
-                            _serde::export::Ok(__val) => __val,
+                            _serde::__private::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
+                            _serde::__private::Err(__err) => {
-                                return _serde::export::Err(__err);
+                                return _serde::__private::Err(__err);
                             }
                         };
                     };
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
             }
             const FIELDS: &'static [&'static str] = &["x"];
@@ -391,7 +406,7 @@ const _: () = {
                 FIELDS,
                 __Visitor {
                     place: __place,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
@@ -408,7 +423,10 @@ const _: () = {
     where
         T: _serde::Serialize,
     {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -430,7 +448,7 @@ const _: () = {
     where
         T: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -438,8 +456,8 @@ const _: () = {
             where
                 T: _serde::Deserialize<'de>,
             {
-                marker: _serde::export::PhantomData<GenericNewTypeStruct<T>>,
+                marker: _serde::__private::PhantomData<GenericNewTypeStruct<T>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T>
             where
@@ -448,9 +466,9 @@ const _: () = {
                 type Value = GenericNewTypeStruct<T>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(
+                    _serde::__private::Formatter::write_str(
                         __formatter,
                         "tuple struct GenericNewTypeStruct",
                     )
@@ -459,57 +477,57 @@ const _: () = {
                 fn visit_newtype_struct<__E>(
                     self,
                     __e: __E,
-                ) -> _serde::export::Result<Self::Value, __E::Error>
+                ) -> _serde::__private::Result<Self::Value, __E::Error>
                 where
                     __E: _serde::Deserializer<'de>,
                 {
                     let __field0: T = match <T as _serde::Deserialize>::deserialize(__e) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
-                    _serde::export::Ok(GenericNewTypeStruct(__field0))
+                    _serde::__private::Ok(GenericNewTypeStruct(__field0))
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
                     let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
+                        _serde::__private::Some(__value) => __value,
-                        _serde::export::None => {
+                        _serde::__private::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 0usize,
                                 &"tuple struct GenericNewTypeStruct with 1 element",
                             ));
                         }
                     };
-                    _serde::export::Ok(GenericNewTypeStruct(__field0))
+                    _serde::__private::Ok(GenericNewTypeStruct(__field0))
                 }
             }
             _serde::Deserializer::deserialize_newtype_struct(
                 __deserializer,
                 "GenericNewTypeStruct",
                 __Visitor {
-                    marker: _serde::export::PhantomData::<GenericNewTypeStruct<T>>,
+                    marker: _serde::__private::PhantomData::<GenericNewTypeStruct<T>>,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
         fn deserialize_in_place<__D>(
             __deserializer: __D,
             __place: &mut Self,
-        ) -> _serde::export::Result<(), __D::Error>
+        ) -> _serde::__private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -518,7 +536,7 @@ const _: () = {
                 T: _serde::Deserialize<'de>,
             {
                 place: &'place mut GenericNewTypeStruct<T>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T>
             where
@@ -527,9 +545,9 @@ const _: () = {
                 type Value = ();
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(
+                    _serde::__private::Formatter::write_str(
                         __formatter,
                         "tuple struct GenericNewTypeStruct",
                     )
@@ -538,7 +556,7 @@ const _: () = {
                 fn visit_newtype_struct<__E>(
                     self,
                     __e: __E,
-                ) -> _serde::export::Result<Self::Value, __E::Error>
+                ) -> _serde::__private::Result<Self::Value, __E::Error>
                 where
                     __E: _serde::Deserializer<'de>,
                 {
@@ -548,25 +566,25 @@ const _: () = {
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.0),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.0),
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             0usize,
                             &"tuple struct GenericNewTypeStruct with 1 element",
                         ));
                     }
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
             }
             _serde::Deserializer::deserialize_newtype_struct(
@@ -574,7 +592,7 @@ const _: () = {
                 "GenericNewTypeStruct",
                 __Visitor {
                     place: __place,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/generic_tuple_struct.expanded.rs

@@ -11,7 +11,7 @@ const _: () = {
         T: _serde::Deserialize<'de>,
         U: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -20,8 +20,8 @@ const _: () = {
                 T: _serde::Deserialize<'de>,
                 U: _serde::Deserialize<'de>,
             {
-                marker: _serde::export::PhantomData<GenericTupleStruct<T, U>>,
+                marker: _serde::__private::PhantomData<GenericTupleStruct<T, U>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
             where
@@ -31,9 +31,9 @@ const _: () = {
                 type Value = GenericTupleStruct<T, U>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(
+                    _serde::__private::Formatter::write_str(
                         __formatter,
                         "tuple struct GenericTupleStruct",
                     )
@@ -42,20 +42,20 @@ const _: () = {
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
                     let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
+                        _serde::__private::Some(__value) => __value,
-                        _serde::export::None => {
+                        _serde::__private::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 0usize,
                                 &"tuple struct GenericTupleStruct with 2 elements",
                             ));
@@ -63,20 +63,20 @@ const _: () = {
                     };
                     let __field1 = match match _serde::de::SeqAccess::next_element::<U>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
+                        _serde::__private::Some(__value) => __value,
-                        _serde::export::None => {
+                        _serde::__private::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 1usize,
                                 &"tuple struct GenericTupleStruct with 2 elements",
                             ));
                         }
                     };
-                    _serde::export::Ok(GenericTupleStruct(__field0, __field1))
+                    _serde::__private::Ok(GenericTupleStruct(__field0, __field1))
                 }
             }
             _serde::Deserializer::deserialize_tuple_struct(
@@ -84,15 +84,15 @@ const _: () = {
                 "GenericTupleStruct",
                 2usize,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<GenericTupleStruct<T, U>>,
+                    marker: _serde::__private::PhantomData::<GenericTupleStruct<T, U>>,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
         fn deserialize_in_place<__D>(
             __deserializer: __D,
             __place: &mut Self,
-        ) -> _serde::export::Result<(), __D::Error>
+        ) -> _serde::__private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -102,7 +102,7 @@ const _: () = {
                 U: _serde::Deserialize<'de>,
             {
                 place: &'place mut GenericTupleStruct<T, U>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, T: 'place, U: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T, U>
             where
@@ -112,9 +112,9 @@ const _: () = {
                 type Value = ();
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(
+                    _serde::__private::Formatter::write_str(
                         __formatter,
                         "tuple struct GenericTupleStruct",
                     )
@@ -123,39 +123,39 @@ const _: () = {
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.0),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.0),
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::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(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.1),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.1),
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             1usize,
                             &"tuple struct GenericTupleStruct with 2 elements",
                         ));
                     }
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
             }
             _serde::Deserializer::deserialize_tuple_struct(
@@ -164,7 +164,7 @@ const _: () = {
                 2usize,
                 __Visitor {
                     place: __place,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/lifetimes.expanded.rs

@@ -12,7 +12,10 @@ const _: () = {
     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>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -43,9 +46,9 @@ const _: () = {
                         "LifetimeMap",
                         0 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -53,9 +56,9 @@ const _: () = {
                         "a",
                         a,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)
@@ -68,9 +71,9 @@ const _: () = {
                         "NoLifetimeMap",
                         0 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -78,9 +81,9 @@ const _: () = {
                         "a",
                         a,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)
@@ -96,7 +99,7 @@ const _: () = {
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de, 'a> _serde::Deserialize<'de> for Lifetimes<'a> {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -112,35 +115,38 @@ const _: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "variant identifier")
+                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
+                        0u64 => _serde::__private::Ok(__Field::__field0),
-                        1u64 => _serde::export::Ok(__Field::__field1),
+                        1u64 => _serde::__private::Ok(__Field::__field1),
-                        2u64 => _serde::export::Ok(__Field::__field2),
+                        2u64 => _serde::__private::Ok(__Field::__field2),
-                        3u64 => _serde::export::Ok(__Field::__field3),
+                        3u64 => _serde::__private::Ok(__Field::__field3),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        _ => _serde::__private::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<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "LifetimeSeq" => _serde::export::Ok(__Field::__field0),
+                        "LifetimeSeq" => _serde::__private::Ok(__Field::__field0),
-                        "NoLifetimeSeq" => _serde::export::Ok(__Field::__field1),
+                        "NoLifetimeSeq" => _serde::__private::Ok(__Field::__field1),
-                        "LifetimeMap" => _serde::export::Ok(__Field::__field2),
+                        "LifetimeMap" => _serde::__private::Ok(__Field::__field2),
-                        "NoLifetimeMap" => _serde::export::Ok(__Field::__field3),
+                        "NoLifetimeMap" => _serde::__private::Ok(__Field::__field3),
-                        _ => _serde::export::Err(_serde::de::Error::unknown_variant(
+                        _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
                             __value, VARIANTS,
                         )),
                     }
@@ -148,18 +154,18 @@ const _: () = {
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"LifetimeSeq" => _serde::export::Ok(__Field::__field0),
+                        b"LifetimeSeq" => _serde::__private::Ok(__Field::__field0),
-                        b"NoLifetimeSeq" => _serde::export::Ok(__Field::__field1),
+                        b"NoLifetimeSeq" => _serde::__private::Ok(__Field::__field1),
-                        b"LifetimeMap" => _serde::export::Ok(__Field::__field2),
+                        b"LifetimeMap" => _serde::__private::Ok(__Field::__field2),
-                        b"NoLifetimeMap" => _serde::export::Ok(__Field::__field3),
+                        b"NoLifetimeMap" => _serde::__private::Ok(__Field::__field3),
                         _ => {
-                            let __value = &_serde::export::from_utf8_lossy(__value);
+                            let __value = &_serde::__private::from_utf8_lossy(__value);
-                            _serde::export::Err(_serde::de::Error::unknown_variant(
+                            _serde::__private::Err(_serde::de::Error::unknown_variant(
                                 __value, VARIANTS,
                             ))
                         }
@@ -168,7 +174,9 @@ const _: () = {
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -176,35 +184,35 @@ const _: () = {
                 }
             }
             struct __Visitor<'de, 'a> {
-                marker: _serde::export::PhantomData<Lifetimes<'a>>,
+                marker: _serde::__private::PhantomData<Lifetimes<'a>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::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,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "enum Lifetimes")
+                    _serde::__private::Formatter::write_str(__formatter, "enum Lifetimes")
                 }
                 fn visit_enum<__A>(
                     self,
                     __data: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::EnumAccess<'de>,
                 {
                     match match _serde::de::EnumAccess::variant(__data) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        (__Field::__field0, __variant) => _serde::export::Result::map(
+                        (__Field::__field0, __variant) => _serde::__private::Result::map(
                             _serde::de::VariantAccess::newtype_variant::<&'a i32>(__variant),
                             Lifetimes::LifetimeSeq,
                         ),
-                        (__Field::__field1, __variant) => _serde::export::Result::map(
+                        (__Field::__field1, __variant) => _serde::__private::Result::map(
                             _serde::de::VariantAccess::newtype_variant::<i32>(__variant),
                             Lifetimes::NoLifetimeSeq,
                         ),
@@ -219,9 +227,10 @@ const _: () = {
                                 type Value = __Field;
                                 fn expecting(
                                     &self,
-                                    __formatter: &mut _serde::export::Formatter,
+                                    __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::export::fmt::Result {
+                                ) -> _serde::__private::fmt::Result
-                                    _serde::export::Formatter::write_str(
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
                                     )
@@ -229,40 +238,42 @@ const _: () = {
                                 fn visit_u64<__E>(
                                     self,
                                     __value: u64,
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        0u64 => _serde::export::Ok(__Field::__field0),
+                                        0u64 => _serde::__private::Ok(__Field::__field0),
-                                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                                        _ => _serde::__private::Err(
-                                            _serde::de::Unexpected::Unsigned(__value),
+                                            _serde::de::Error::invalid_value(
-                                            &"field index 0 <= i < 1",
+                                                _serde::de::Unexpected::Unsigned(__value),
-                                        )),
+                                                &"field index 0 <= i < 1",
+                                            ),
+                                        ),
                                     }
                                 }
                                 fn visit_str<__E>(
                                     self,
                                     __value: &str,
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        "a" => _serde::export::Ok(__Field::__field0),
+                                        "a" => _serde::__private::Ok(__Field::__field0),
-                                        _ => _serde::export::Ok(__Field::__ignore),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                                 fn visit_bytes<__E>(
                                     self,
                                     __value: &[u8],
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        b"a" => _serde::export::Ok(__Field::__field0),
+                                        b"a" => _serde::__private::Ok(__Field::__field0),
-                                        _ => _serde::export::Ok(__Field::__ignore),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                             }
@@ -270,7 +281,7 @@ const _: () = {
                                 #[inline]
                                 fn deserialize<__D>(
                                     __deserializer: __D,
-                                ) -> _serde::export::Result<Self, __D::Error>
+                                ) -> _serde::__private::Result<Self, __D::Error>
                                 where
                                     __D: _serde::Deserializer<'de>,
                                 {
@@ -281,16 +292,17 @@ const _: () = {
                                 }
                             }
                             struct __Visitor<'de, 'a> {
-                                marker: _serde::export::PhantomData<Lifetimes<'a>>,
+                                marker: _serde::__private::PhantomData<Lifetimes<'a>>,
-                                lifetime: _serde::export::PhantomData<&'de ()>,
+                                lifetime: _serde::__private::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,
+                                    __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::export::fmt::Result {
+                                ) -> _serde::__private::fmt::Result
-                                    _serde::export::Formatter::write_str(
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant Lifetimes::LifetimeMap",
                                     )
@@ -299,7 +311,7 @@ const _: () = {
                                 fn visit_seq<__A>(
                                     self,
                                     mut __seq: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::SeqAccess<'de>,
                                 {
@@ -308,49 +320,49 @@ const _: () = {
                                     >(
                                         &mut __seq
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
+                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
+                                        _serde::__private::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                            return _serde::__private::Err(__err);
                                         }
                                     } {
-                                        _serde::export::Some(__value) => __value,
+                                        _serde::__private::Some(__value) => __value,
-                                        _serde::export::None => {
+                                        _serde::__private::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant Lifetimes::LifetimeMap with 1 element" ) ) ;
+                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant Lifetimes::LifetimeMap with 1 element")) ;
                                         }
                                     };
-                                    _serde::export::Ok(Lifetimes::LifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::LifetimeMap { a: __field0 })
                                 }
                                 #[inline]
                                 fn visit_map<__A>(
                                     self,
                                     mut __map: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::export::Option<&'a i32> =
+                                    let mut __field0: _serde::__private::Option<&'a i32> =
-                                        _serde::export::None;
+                                        _serde::__private::None;
-                                    while let _serde::export::Some(__key) =
+                                    while let _serde::__private::Some(__key) =
                                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                         {
-                                            _serde::export::Ok(__val) => __val,
+                                            _serde::__private::Ok(__val) => __val,
-                                            _serde::export::Err(__err) => {
+                                            _serde::__private::Err(__err) => {
-                                                return _serde::export::Err(__err);
+                                                return _serde::__private::Err(__err);
                                             }
                                         }
                                     {
                                         match __key {
                                             __Field::__field0 => {
-                                                if _serde::export::Option::is_some(&__field0) {
+                                                if _serde::__private::Option::is_some(&__field0) {
-                                                    return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "a" ) ) ;
+                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
                                                 }
-                                                __field0 = _serde::export::Some(
+                                                __field0 = _serde::__private::Some(
                                                     match _serde::de::MapAccess::next_value::<&'a i32>(
                                                         &mut __map,
                                                     ) {
-                                                        _serde::export::Ok(__val) => __val,
+                                                        _serde::__private::Ok(__val) => __val,
-                                                        _serde::export::Err(__err) => {
+                                                        _serde::__private::Err(__err) => {
-                                                            return _serde::export::Err(__err);
+                                                            return _serde::__private::Err(__err);
                                                         }
                                                     },
                                                 );
@@ -361,26 +373,26 @@ const _: () = {
                                                 >(
                                                     &mut __map
                                                 ) {
-                                                    _serde::export::Ok(__val) => __val,
+                                                    _serde::__private::Ok(__val) => __val,
-                                                    _serde::export::Err(__err) => {
+                                                    _serde::__private::Err(__err) => {
-                                                        return _serde::export::Err(__err);
+                                                        return _serde::__private::Err(__err);
                                                     }
                                                 };
                                             }
                                         }
                                     }
                                     let __field0 = match __field0 {
-                                        _serde::export::Some(__field0) => __field0,
+                                        _serde::__private::Some(__field0) => __field0,
-                                        _serde::export::None => {
+                                        _serde::__private::None => {
-                                            match _serde::private::de::missing_field("a") {
+                                            match _serde::__private::de::missing_field("a") {
-                                                _serde::export::Ok(__val) => __val,
+                                                _serde::__private::Ok(__val) => __val,
-                                                _serde::export::Err(__err) => {
+                                                _serde::__private::Err(__err) => {
-                                                    return _serde::export::Err(__err);
+                                                    return _serde::__private::Err(__err);
                                                 }
                                             }
                                         }
                                     };
-                                    _serde::export::Ok(Lifetimes::LifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::LifetimeMap { a: __field0 })
                                 }
                             }
                             const FIELDS: &'static [&'static str] = &["a"];
@@ -388,8 +400,8 @@ const _: () = {
                                 __variant,
                                 FIELDS,
                                 __Visitor {
-                                    marker: _serde::export::PhantomData::<Lifetimes<'a>>,
+                                    marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
-                                    lifetime: _serde::export::PhantomData,
+                                    lifetime: _serde::__private::PhantomData,
                                 },
                             )
                         }
@@ -404,9 +416,10 @@ const _: () = {
                                 type Value = __Field;
                                 fn expecting(
                                     &self,
-                                    __formatter: &mut _serde::export::Formatter,
+                                    __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::export::fmt::Result {
+                                ) -> _serde::__private::fmt::Result
-                                    _serde::export::Formatter::write_str(
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
                                     )
@@ -414,40 +427,42 @@ const _: () = {
                                 fn visit_u64<__E>(
                                     self,
                                     __value: u64,
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        0u64 => _serde::export::Ok(__Field::__field0),
+                                        0u64 => _serde::__private::Ok(__Field::__field0),
-                                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                                        _ => _serde::__private::Err(
-                                            _serde::de::Unexpected::Unsigned(__value),
+                                            _serde::de::Error::invalid_value(
-                                            &"field index 0 <= i < 1",
+                                                _serde::de::Unexpected::Unsigned(__value),
-                                        )),
+                                                &"field index 0 <= i < 1",
+                                            ),
+                                        ),
                                     }
                                 }
                                 fn visit_str<__E>(
                                     self,
                                     __value: &str,
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        "a" => _serde::export::Ok(__Field::__field0),
+                                        "a" => _serde::__private::Ok(__Field::__field0),
-                                        _ => _serde::export::Ok(__Field::__ignore),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                                 fn visit_bytes<__E>(
                                     self,
                                     __value: &[u8],
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        b"a" => _serde::export::Ok(__Field::__field0),
+                                        b"a" => _serde::__private::Ok(__Field::__field0),
-                                        _ => _serde::export::Ok(__Field::__ignore),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                             }
@@ -455,7 +470,7 @@ const _: () = {
                                 #[inline]
                                 fn deserialize<__D>(
                                     __deserializer: __D,
-                                ) -> _serde::export::Result<Self, __D::Error>
+                                ) -> _serde::__private::Result<Self, __D::Error>
                                 where
                                     __D: _serde::Deserializer<'de>,
                                 {
@@ -466,16 +481,17 @@ const _: () = {
                                 }
                             }
                             struct __Visitor<'de, 'a> {
-                                marker: _serde::export::PhantomData<Lifetimes<'a>>,
+                                marker: _serde::__private::PhantomData<Lifetimes<'a>>,
-                                lifetime: _serde::export::PhantomData<&'de ()>,
+                                lifetime: _serde::__private::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,
+                                    __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::export::fmt::Result {
+                                ) -> _serde::__private::fmt::Result
-                                    _serde::export::Formatter::write_str(
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant Lifetimes::NoLifetimeMap",
                                     )
@@ -484,7 +500,7 @@ const _: () = {
                                 fn visit_seq<__A>(
                                     self,
                                     mut __seq: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::SeqAccess<'de>,
                                 {
@@ -493,49 +509,49 @@ const _: () = {
                                     >(
                                         &mut __seq
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
+                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
+                                        _serde::__private::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                            return _serde::__private::Err(__err);
                                         }
                                     } {
-                                        _serde::export::Some(__value) => __value,
+                                        _serde::__private::Some(__value) => __value,
-                                        _serde::export::None => {
+                                        _serde::__private::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant Lifetimes::NoLifetimeMap with 1 element" ) ) ;
+                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant Lifetimes::NoLifetimeMap with 1 element")) ;
                                         }
                                     };
-                                    _serde::export::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
                                 }
                                 #[inline]
                                 fn visit_map<__A>(
                                     self,
                                     mut __map: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::export::Option<i32> =
+                                    let mut __field0: _serde::__private::Option<i32> =
-                                        _serde::export::None;
+                                        _serde::__private::None;
-                                    while let _serde::export::Some(__key) =
+                                    while let _serde::__private::Some(__key) =
                                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                         {
-                                            _serde::export::Ok(__val) => __val,
+                                            _serde::__private::Ok(__val) => __val,
-                                            _serde::export::Err(__err) => {
+                                            _serde::__private::Err(__err) => {
-                                                return _serde::export::Err(__err);
+                                                return _serde::__private::Err(__err);
                                             }
                                         }
                                     {
                                         match __key {
                                             __Field::__field0 => {
-                                                if _serde::export::Option::is_some(&__field0) {
+                                                if _serde::__private::Option::is_some(&__field0) {
-                                                    return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "a" ) ) ;
+                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
                                                 }
-                                                __field0 = _serde::export::Some(
+                                                __field0 = _serde::__private::Some(
                                                     match _serde::de::MapAccess::next_value::<i32>(
                                                         &mut __map,
                                                     ) {
-                                                        _serde::export::Ok(__val) => __val,
+                                                        _serde::__private::Ok(__val) => __val,
-                                                        _serde::export::Err(__err) => {
+                                                        _serde::__private::Err(__err) => {
-                                                            return _serde::export::Err(__err);
+                                                            return _serde::__private::Err(__err);
                                                         }
                                                     },
                                                 );
@@ -546,26 +562,26 @@ const _: () = {
                                                 >(
                                                     &mut __map
                                                 ) {
-                                                    _serde::export::Ok(__val) => __val,
+                                                    _serde::__private::Ok(__val) => __val,
-                                                    _serde::export::Err(__err) => {
+                                                    _serde::__private::Err(__err) => {
-                                                        return _serde::export::Err(__err);
+                                                        return _serde::__private::Err(__err);
                                                     }
                                                 };
                                             }
                                         }
                                     }
                                     let __field0 = match __field0 {
-                                        _serde::export::Some(__field0) => __field0,
+                                        _serde::__private::Some(__field0) => __field0,
-                                        _serde::export::None => {
+                                        _serde::__private::None => {
-                                            match _serde::private::de::missing_field("a") {
+                                            match _serde::__private::de::missing_field("a") {
-                                                _serde::export::Ok(__val) => __val,
+                                                _serde::__private::Ok(__val) => __val,
-                                                _serde::export::Err(__err) => {
+                                                _serde::__private::Err(__err) => {
-                                                    return _serde::export::Err(__err);
+                                                    return _serde::__private::Err(__err);
                                                 }
                                             }
                                         }
                                     };
-                                    _serde::export::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
                                 }
                             }
                             const FIELDS: &'static [&'static str] = &["a"];
@@ -573,8 +589,8 @@ const _: () = {
                                 __variant,
                                 FIELDS,
                                 __Visitor {
-                                    marker: _serde::export::PhantomData::<Lifetimes<'a>>,
+                                    marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
-                                    lifetime: _serde::export::PhantomData,
+                                    lifetime: _serde::__private::PhantomData,
                                 },
                             )
                         }
@@ -592,8 +608,8 @@ const _: () = {
                 "Lifetimes",
                 VARIANTS,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<Lifetimes<'a>>,
+                    marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/named_map.expanded.rs

@@ -16,7 +16,10 @@ const _: () = {
         B: _serde::Serialize,
         C: _serde::Serialize,
     {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -25,27 +28,27 @@ const _: () = {
                 "SerNamedMap",
                 false as usize + 1 + 1 + 1,
             ) {
-                _serde::export::Ok(__val) => __val,
+                _serde::__private::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
+                _serde::__private::Err(__err) => {
-                    return _serde::export::Err(__err);
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "a", &self.a) {
-                _serde::export::Ok(__val) => __val,
+                _serde::__private::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
+                _serde::__private::Err(__err) => {
-                    return _serde::export::Err(__err);
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "b", &self.b) {
-                _serde::export::Ok(__val) => __val,
+                _serde::__private::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
+                _serde::__private::Err(__err) => {
-                    return _serde::export::Err(__err);
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "c", &self.c) {
-                _serde::export::Ok(__val) => __val,
+                _serde::__private::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
+                _serde::__private::Err(__err) => {
-                    return _serde::export::Err(__err);
+                    return _serde::__private::Err(__err);
                 }
             };
             _serde::ser::SerializeStruct::end(__serde_state)
@@ -69,7 +72,7 @@ const _: () = {
         B: _serde::Deserialize<'de>,
         C: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -85,53 +88,58 @@ const _: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
+                        0u64 => _serde::__private::Ok(__Field::__field0),
-                        1u64 => _serde::export::Ok(__Field::__field1),
+                        1u64 => _serde::__private::Ok(__Field::__field1),
-                        2u64 => _serde::export::Ok(__Field::__field2),
+                        2u64 => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        _ => _serde::__private::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<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "a" => _serde::export::Ok(__Field::__field0),
+                        "a" => _serde::__private::Ok(__Field::__field0),
-                        "b" => _serde::export::Ok(__Field::__field1),
+                        "b" => _serde::__private::Ok(__Field::__field1),
-                        "c" => _serde::export::Ok(__Field::__field2),
+                        "c" => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"a" => _serde::export::Ok(__Field::__field0),
+                        b"a" => _serde::__private::Ok(__Field::__field0),
-                        b"b" => _serde::export::Ok(__Field::__field1),
+                        b"b" => _serde::__private::Ok(__Field::__field1),
-                        b"c" => _serde::export::Ok(__Field::__field2),
+                        b"c" => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -144,8 +152,8 @@ const _: () = {
                 B: _serde::Deserialize<'de>,
                 C: _serde::Deserialize<'de>,
             {
-                marker: _serde::export::PhantomData<DeNamedMap<A, B, C>>,
+                marker: _serde::__private::PhantomData<DeNamedMap<A, B, C>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C>
             where
@@ -156,28 +164,28 @@ const _: () = {
                 type Value = DeNamedMap<A, B, C>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct DeNamedMap")
+                    _serde::__private::Formatter::write_str(__formatter, "struct DeNamedMap")
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
                     let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
+                        _serde::__private::Some(__value) => __value,
-                        _serde::export::None => {
+                        _serde::__private::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 0usize,
                                 &"struct DeNamedMap with 3 elements",
                             ));
@@ -185,14 +193,14 @@ const _: () = {
                     };
                     let __field1 = match match _serde::de::SeqAccess::next_element::<B>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
+                        _serde::__private::Some(__value) => __value,
-                        _serde::export::None => {
+                        _serde::__private::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 1usize,
                                 &"struct DeNamedMap with 3 elements",
                             ));
@@ -200,20 +208,20 @@ const _: () = {
                     };
                     let __field2 = match match _serde::de::SeqAccess::next_element::<C>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
+                        _serde::__private::Some(__value) => __value,
-                        _serde::export::None => {
+                        _serde::__private::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 2usize,
                                 &"struct DeNamedMap with 3 elements",
                             ));
                         }
                     };
-                    _serde::export::Ok(DeNamedMap {
+                    _serde::__private::Ok(DeNamedMap {
                         a: __field0,
                         b: __field1,
                         c: __field2,
@@ -223,63 +231,63 @@ const _: () = {
                 fn visit_map<__A>(
                     self,
                     mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::MapAccess<'de>,
                 {
-                    let mut __field0: _serde::export::Option<A> = _serde::export::None;
+                    let mut __field0: _serde::__private::Option<A> = _serde::__private::None;
-                    let mut __field1: _serde::export::Option<B> = _serde::export::None;
+                    let mut __field1: _serde::__private::Option<B> = _serde::__private::None;
-                    let mut __field2: _serde::export::Option<C> = _serde::export::None;
+                    let mut __field2: _serde::__private::Option<C> = _serde::__private::None;
-                    while let _serde::export::Some(__key) =
+                    while let _serde::__private::Some(__key) =
                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
+                            _serde::__private::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
+                            _serde::__private::Err(__err) => {
-                                return _serde::export::Err(__err);
+                                return _serde::__private::Err(__err);
                             }
                         }
                     {
                         match __key {
                             __Field::__field0 => {
-                                if _serde::export::Option::is_some(&__field0) {
+                                if _serde::__private::Option::is_some(&__field0) {
-                                    return _serde::export::Err(
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field("a"),
                                     );
                                 }
-                                __field0 = _serde::export::Some(
+                                __field0 = _serde::__private::Some(
                                     match _serde::de::MapAccess::next_value::<A>(&mut __map) {
-                                        _serde::export::Ok(__val) => __val,
+                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
+                                        _serde::__private::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                            return _serde::__private::Err(__err);
                                         }
                                     },
                                 );
                             }
                             __Field::__field1 => {
-                                if _serde::export::Option::is_some(&__field1) {
+                                if _serde::__private::Option::is_some(&__field1) {
-                                    return _serde::export::Err(
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field("b"),
                                     );
                                 }
-                                __field1 = _serde::export::Some(
+                                __field1 = _serde::__private::Some(
                                     match _serde::de::MapAccess::next_value::<B>(&mut __map) {
-                                        _serde::export::Ok(__val) => __val,
+                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
+                                        _serde::__private::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                            return _serde::__private::Err(__err);
                                         }
                                     },
                                 );
                             }
                             __Field::__field2 => {
-                                if _serde::export::Option::is_some(&__field2) {
+                                if _serde::__private::Option::is_some(&__field2) {
-                                    return _serde::export::Err(
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field("c"),
                                     );
                                 }
-                                __field2 = _serde::export::Some(
+                                __field2 = _serde::__private::Some(
                                     match _serde::de::MapAccess::next_value::<C>(&mut __map) {
-                                        _serde::export::Ok(__val) => __val,
+                                        _serde::__private::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
+                                        _serde::__private::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                            return _serde::__private::Err(__err);
                                         }
                                     },
                                 );
@@ -289,42 +297,48 @@ const _: () = {
                                     _serde::de::IgnoredAny,
                                 >(&mut __map)
                                 {
-                                    _serde::export::Ok(__val) => __val,
+                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
+                                    _serde::__private::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                             }
                         }
                     }
                     let __field0 = match __field0 {
-                        _serde::export::Some(__field0) => __field0,
+                        _serde::__private::Some(__field0) => __field0,
-                        _serde::export::None => match _serde::private::de::missing_field("a") {
+                        _serde::__private::None => {
-                            _serde::export::Ok(__val) => __val,
+                            match _serde::__private::de::missing_field("a") {
-                            _serde::export::Err(__err) => {
+                                _serde::__private::Ok(__val) => __val,
-                                return _serde::export::Err(__err);
+                                _serde::__private::Err(__err) => {
+                                    return _serde::__private::Err(__err);
+                                }
                             }
-                        },
+                        }
                     };
                     let __field1 = match __field1 {
-                        _serde::export::Some(__field1) => __field1,
+                        _serde::__private::Some(__field1) => __field1,
-                        _serde::export::None => match _serde::private::de::missing_field("b") {
+                        _serde::__private::None => {
-                            _serde::export::Ok(__val) => __val,
+                            match _serde::__private::de::missing_field("b") {
-                            _serde::export::Err(__err) => {
+                                _serde::__private::Ok(__val) => __val,
-                                return _serde::export::Err(__err);
+                                _serde::__private::Err(__err) => {
+                                    return _serde::__private::Err(__err);
+                                }
                             }
-                        },
+                        }
                     };
                     let __field2 = match __field2 {
-                        _serde::export::Some(__field2) => __field2,
+                        _serde::__private::Some(__field2) => __field2,
-                        _serde::export::None => match _serde::private::de::missing_field("c") {
+                        _serde::__private::None => {
-                            _serde::export::Ok(__val) => __val,
+                            match _serde::__private::de::missing_field("c") {
-                            _serde::export::Err(__err) => {
+                                _serde::__private::Ok(__val) => __val,
-                                return _serde::export::Err(__err);
+                                _serde::__private::Err(__err) => {
+                                    return _serde::__private::Err(__err);
+                                }
                             }
-                        },
+                        }
                     };
-                    _serde::export::Ok(DeNamedMap {
+                    _serde::__private::Ok(DeNamedMap {
                         a: __field0,
                         b: __field1,
                         c: __field2,
@@ -337,15 +351,15 @@ const _: () = {
                 "DeNamedMap",
                 FIELDS,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<DeNamedMap<A, B, C>>,
+                    marker: _serde::__private::PhantomData::<DeNamedMap<A, B, C>>,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
         fn deserialize_in_place<__D>(
             __deserializer: __D,
             __place: &mut Self,
-        ) -> _serde::export::Result<(), __D::Error>
+        ) -> _serde::__private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -361,53 +375,58 @@ const _: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
+                        0u64 => _serde::__private::Ok(__Field::__field0),
-                        1u64 => _serde::export::Ok(__Field::__field1),
+                        1u64 => _serde::__private::Ok(__Field::__field1),
-                        2u64 => _serde::export::Ok(__Field::__field2),
+                        2u64 => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        _ => _serde::__private::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<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "a" => _serde::export::Ok(__Field::__field0),
+                        "a" => _serde::__private::Ok(__Field::__field0),
-                        "b" => _serde::export::Ok(__Field::__field1),
+                        "b" => _serde::__private::Ok(__Field::__field1),
-                        "c" => _serde::export::Ok(__Field::__field2),
+                        "c" => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"a" => _serde::export::Ok(__Field::__field0),
+                        b"a" => _serde::__private::Ok(__Field::__field0),
-                        b"b" => _serde::export::Ok(__Field::__field1),
+                        b"b" => _serde::__private::Ok(__Field::__field1),
-                        b"c" => _serde::export::Ok(__Field::__field2),
+                        b"c" => _serde::__private::Ok(__Field::__field2),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -421,7 +440,7 @@ const _: () = {
                 C: _serde::Deserialize<'de>,
             {
                 place: &'place mut DeNamedMap<A, B, C>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, A: 'place, B: 'place, C: 'place> _serde::de::Visitor<'de>
                 for __Visitor<'de, 'place, A, B, C>
@@ -433,129 +452,129 @@ const _: () = {
                 type Value = ();
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct DeNamedMap")
+                    _serde::__private::Formatter::write_str(__formatter, "struct DeNamedMap")
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.a),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.a),
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             0usize,
                             &"struct DeNamedMap with 3 elements",
                         ));
                     }
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.b),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.b),
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             1usize,
                             &"struct DeNamedMap with 3 elements",
                         ));
                     }
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.c),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.c),
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             2usize,
                             &"struct DeNamedMap with 3 elements",
                         ));
                     }
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
                 #[inline]
                 fn visit_map<__A>(
                     self,
                     mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 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) =
+                    while let _serde::__private::Some(__key) =
                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
+                            _serde::__private::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
+                            _serde::__private::Err(__err) => {
-                                return _serde::export::Err(__err);
+                                return _serde::__private::Err(__err);
                             }
                         }
                     {
                         match __key {
                             __Field::__field0 => {
                                 if __field0 {
-                                    return _serde::export::Err(
+                                    return _serde::__private::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::__private::de::InPlaceSeed(&mut self.place.a),
                                 ) {
-                                    _serde::export::Ok(__val) => __val,
+                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
+                                    _serde::__private::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                                 __field0 = true;
                             }
                             __Field::__field1 => {
                                 if __field1 {
-                                    return _serde::export::Err(
+                                    return _serde::__private::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::__private::de::InPlaceSeed(&mut self.place.b),
                                 ) {
-                                    _serde::export::Ok(__val) => __val,
+                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
+                                    _serde::__private::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                                 __field1 = true;
                             }
                             __Field::__field2 => {
                                 if __field2 {
-                                    return _serde::export::Err(
+                                    return _serde::__private::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::__private::de::InPlaceSeed(&mut self.place.c),
                                 ) {
-                                    _serde::export::Ok(__val) => __val,
+                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
+                                    _serde::__private::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                                 __field2 = true;
@@ -565,39 +584,39 @@ const _: () = {
                                     _serde::de::IgnoredAny,
                                 >(&mut __map)
                                 {
-                                    _serde::export::Ok(__val) => __val,
+                                    _serde::__private::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
+                                    _serde::__private::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                             }
                         }
                     }
                     if !__field0 {
-                        self.place.a = match _serde::private::de::missing_field("a") {
+                        self.place.a = match _serde::__private::de::missing_field("a") {
-                            _serde::export::Ok(__val) => __val,
+                            _serde::__private::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
+                            _serde::__private::Err(__err) => {
-                                return _serde::export::Err(__err);
+                                return _serde::__private::Err(__err);
                             }
                         };
                     };
                     if !__field1 {
-                        self.place.b = match _serde::private::de::missing_field("b") {
+                        self.place.b = match _serde::__private::de::missing_field("b") {
-                            _serde::export::Ok(__val) => __val,
+                            _serde::__private::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
+                            _serde::__private::Err(__err) => {
-                                return _serde::export::Err(__err);
+                                return _serde::__private::Err(__err);
                             }
                         };
                     };
                     if !__field2 {
-                        self.place.c = match _serde::private::de::missing_field("c") {
+                        self.place.c = match _serde::__private::de::missing_field("c") {
-                            _serde::export::Ok(__val) => __val,
+                            _serde::__private::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
+                            _serde::__private::Err(__err) => {
-                                return _serde::export::Err(__err);
+                                return _serde::__private::Err(__err);
                             }
                         };
                     };
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
             }
             const FIELDS: &'static [&'static str] = &["a", "b", "c"];
@@ -607,7 +626,7 @@ const _: () = {
                 FIELDS,
                 __Visitor {
                     place: __place,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/named_tuple.expanded.rs

@@ -12,7 +12,10 @@ const _: () = {
         B: _serde::Serialize,
         C: _serde::Serialize,
     {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -21,27 +24,27 @@ const _: () = {
                 "SerNamedTuple",
                 0 + 1 + 1 + 1,
             ) {
-                _serde::export::Ok(__val) => __val,
+                _serde::__private::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
+                _serde::__private::Err(__err) => {
-                    return _serde::export::Err(__err);
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.0) {
-                _serde::export::Ok(__val) => __val,
+                _serde::__private::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
+                _serde::__private::Err(__err) => {
-                    return _serde::export::Err(__err);
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.1) {
-                _serde::export::Ok(__val) => __val,
+                _serde::__private::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
+                _serde::__private::Err(__err) => {
-                    return _serde::export::Err(__err);
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.2) {
-                _serde::export::Ok(__val) => __val,
+                _serde::__private::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
+                _serde::__private::Err(__err) => {
-                    return _serde::export::Err(__err);
+                    return _serde::__private::Err(__err);
                 }
             };
             _serde::ser::SerializeTupleStruct::end(__serde_state)
@@ -61,7 +64,7 @@ const _: () = {
         B: _serde::Deserialize<'de>,
         C: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -71,8 +74,8 @@ const _: () = {
                 B: _serde::Deserialize<'de>,
                 C: _serde::Deserialize<'de>,
             {
-                marker: _serde::export::PhantomData<DeNamedTuple<A, B, C>>,
+                marker: _serde::__private::PhantomData<DeNamedTuple<A, B, C>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C>
             where
@@ -83,28 +86,31 @@ const _: () = {
                 type Value = DeNamedTuple<A, B, C>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "tuple struct DeNamedTuple")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "tuple struct DeNamedTuple",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
                     let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
+                        _serde::__private::Some(__value) => __value,
-                        _serde::export::None => {
+                        _serde::__private::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 0usize,
                                 &"tuple struct DeNamedTuple with 3 elements",
                             ));
@@ -112,14 +118,14 @@ const _: () = {
                     };
                     let __field1 = match match _serde::de::SeqAccess::next_element::<B>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
+                        _serde::__private::Some(__value) => __value,
-                        _serde::export::None => {
+                        _serde::__private::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 1usize,
                                 &"tuple struct DeNamedTuple with 3 elements",
                             ));
@@ -127,20 +133,20 @@ const _: () = {
                     };
                     let __field2 = match match _serde::de::SeqAccess::next_element::<C>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
+                        _serde::__private::Some(__value) => __value,
-                        _serde::export::None => {
+                        _serde::__private::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 2usize,
                                 &"tuple struct DeNamedTuple with 3 elements",
                             ));
                         }
                     };
-                    _serde::export::Ok(DeNamedTuple(__field0, __field1, __field2))
+                    _serde::__private::Ok(DeNamedTuple(__field0, __field1, __field2))
                 }
             }
             _serde::Deserializer::deserialize_tuple_struct(
@@ -148,15 +154,15 @@ const _: () = {
                 "DeNamedTuple",
                 3usize,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<DeNamedTuple<A, B, C>>,
+                    marker: _serde::__private::PhantomData::<DeNamedTuple<A, B, C>>,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
         fn deserialize_in_place<__D>(
             __deserializer: __D,
             __place: &mut Self,
-        ) -> _serde::export::Result<(), __D::Error>
+        ) -> _serde::__private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -167,7 +173,7 @@ const _: () = {
                 C: _serde::Deserialize<'de>,
             {
                 place: &'place mut DeNamedTuple<A, B, C>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, A: 'place, B: 'place, C: 'place> _serde::de::Visitor<'de>
                 for __Visitor<'de, 'place, A, B, C>
@@ -179,61 +185,64 @@ const _: () = {
                 type Value = ();
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "tuple struct DeNamedTuple")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "tuple struct DeNamedTuple",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.0),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.0),
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::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(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.1),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.1),
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::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(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.2),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.2),
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             2usize,
                             &"tuple struct DeNamedTuple with 3 elements",
                         ));
                     }
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
             }
             _serde::Deserializer::deserialize_tuple_struct(
@@ -242,7 +251,7 @@ const _: () = {
                 3usize,
                 __Visitor {
                     place: __place,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/named_unit.expanded.rs

@@ -7,7 +7,10 @@ const _: () = {
     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>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -22,7 +25,7 @@ const _: () = {
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de> _serde::Deserialize<'de> for NamedUnit {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -31,16 +34,16 @@ const _: () = {
                 type Value = NamedUnit;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "unit struct NamedUnit")
+                    _serde::__private::Formatter::write_str(__formatter, "unit struct NamedUnit")
                 }
                 #[inline]
-                fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E>
+                fn visit_unit<__E>(self) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
-                    _serde::export::Ok(NamedUnit)
+                    _serde::__private::Ok(NamedUnit)
                 }
             }
             _serde::Deserializer::deserialize_unit_struct(__deserializer, "NamedUnit", __Visitor)

test_suite/tests/expand/ser_enum.expanded.rs

@@ -23,7 +23,10 @@ const _: () = {
         C: _serde::Serialize,
         D: _serde::Serialize,
     {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -42,45 +45,45 @@ const _: () = {
                         "Seq",
                         0 + 1 + 1 + 1 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field0,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field2,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field3,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
@@ -98,9 +101,9 @@ const _: () = {
                         "Map",
                         0 + 1 + 1 + 1 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -108,9 +111,9 @@ const _: () = {
                         "a",
                         a,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -118,9 +121,9 @@ const _: () = {
                         "b",
                         b,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -128,9 +131,9 @@ const _: () = {
                         "c",
                         c,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -138,9 +141,9 @@ const _: () = {
                         "d",
                         d,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)
@@ -159,45 +162,45 @@ const _: () = {
                         "_Seq2",
                         0 + 1 + 1 + 1 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field0,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field2,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field3,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
@@ -215,9 +218,9 @@ const _: () = {
                         "_Map2",
                         0 + 1 + 1 + 1 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -225,9 +228,9 @@ const _: () = {
                         "a",
                         a,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -235,9 +238,9 @@ const _: () = {
                         "b",
                         b,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -245,9 +248,9 @@ const _: () = {
                         "c",
                         c,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -255,9 +258,9 @@ const _: () = {
                         "d",
                         d,
                     ) {
-                        _serde::export::Ok(__val) => __val,
+                        _serde::__private::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
+                        _serde::__private::Err(__err) => {
-                            return _serde::export::Err(__err);
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)

test_suite/tests/expand/void.expanded.rs

@@ -7,7 +7,10 @@ const _: () = {
     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>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -22,7 +25,7 @@ const _: () = {
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de> _serde::Deserialize<'de> for Void {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -33,27 +36,30 @@ const _: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "variant identifier")
+                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        _ => _serde::__private::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<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        _ => _serde::export::Err(_serde::de::Error::unknown_variant(
+                        _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
                             __value, VARIANTS,
                         )),
                     }
@@ -61,14 +67,14 @@ const _: () = {
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
                         _ => {
-                            let __value = &_serde::export::from_utf8_lossy(__value);
+                            let __value = &_serde::__private::from_utf8_lossy(__value);
-                            _serde::export::Err(_serde::de::Error::unknown_variant(
+                            _serde::__private::Err(_serde::de::Error::unknown_variant(
                                 __value, VARIANTS,
                             ))
                         }
@@ -77,7 +83,9 @@ const _: () = {
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -85,25 +93,25 @@ const _: () = {
                 }
             }
             struct __Visitor<'de> {
-                marker: _serde::export::PhantomData<Void>,
+                marker: _serde::__private::PhantomData<Void>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                 type Value = Void;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
+                    __formatter: &mut _serde::__private::Formatter,
-                ) -> _serde::export::fmt::Result {
+                ) -> _serde::__private::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "enum Void")
+                    _serde::__private::Formatter::write_str(__formatter, "enum Void")
                 }
                 fn visit_enum<__A>(
                     self,
                     __data: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::EnumAccess<'de>,
                 {
-                    _serde::export::Result::map(
+                    _serde::__private::Result::map(
                         _serde::de::EnumAccess::variant::<__Field>(__data),
                         |(__impossible, _)| match __impossible {},
                     )
@@ -115,8 +123,8 @@ const _: () = {
                 "Void",
                 VARIANTS,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<Void>,
+                    marker: _serde::__private::PhantomData::<Void>,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/test_annotations.rs

@@ -1,4 +1,8 @@
-#![allow(clippy::cast_lossless, clippy::trivially_copy_pass_by_ref)]
+#![allow(
+    clippy::cast_lossless,
+    clippy::from_over_into,
+    clippy::trivially_copy_pass_by_ref
+)]
 
 use serde::de::{self, MapAccess, Unexpected, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};