Upgrade rust/crates/serde_derive to 1.0.119 am: 4b879a4bf4 am: 4dee72d9fd

Original change: https://android-review.googlesource.com/c/platform/external/rust/crates/serde_derive/+/1547279

MUST ONLY BE SUBMITTED BY AUTOMERGER

Change-Id: Idf52c763b937ce61c861f6f0ad59a1905e2818e5

11 files changed, 303 insertions, 298 deletions

diff --git a/.cargo_vcs_info.json b/.cargo_vcs_info.json
index 8e3161d..f5c327c 100644
--- a/.cargo_vcs_info.json
+++ b/.cargo_vcs_info.json
@@ -1,5 +1,5 @@
 {
   "git": {
-    "sha1": "fc3f104c4a08a85b403c468348347240db6cc992"
+    "sha1": "4c89cf89fdb84970c8d4e09b5f29507dc88c5547"
   }
 }
diff --git a/Android.bp b/Android.bp
index 417079c..efcafa3 100644
--- a/Android.bp
+++ b/Android.bp
@@ -18,6 +18,6 @@ rust_proc_macro {
 
 // dependent_library ["feature_list"]
 //   proc-macro2-1.0.24 "default,proc-macro"
-//   quote-1.0.7 "default,proc-macro"
-//   syn-1.0.51 "clone-impls,default,derive,parsing,printing,proc-macro,quote,visit"
+//   quote-1.0.8 "default,proc-macro"
+//   syn-1.0.58 "clone-impls,default,derive,parsing,printing,proc-macro,quote,visit"
 //   unicode-xid-0.2.1 "default"
diff --git a/Cargo.toml b/Cargo.toml
index 6868925..ce5c56d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -12,7 +12,7 @@
 
 [package]
 name = "serde_derive"
-version = "1.0.117"
+version = "1.0.119"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
@@ -35,7 +35,7 @@ version = "1.0"
 version = "1.0"
 
 [dependencies.syn]
-version = "1.0.33"
+version = "1.0.58"
 features = ["visit"]
 [dev-dependencies.serde]
 version = "1.0"
diff --git a/Cargo.toml.orig b/Cargo.toml.orig
index 4dfdd92..2b47a60 100644
--- a/Cargo.toml.orig
+++ b/Cargo.toml.orig
@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.117" # 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" }
diff --git a/METADATA b/METADATA
index e2e7e84..8f22450 100644
--- a/METADATA
+++ b/METADATA
@@ -7,13 +7,13 @@ third_party {
   }
   url {
     type: ARCHIVE
-    value: "https://static.crates.io/crates/serde_derive/serde_derive-1.0.117.crate"
+    value: "https://static.crates.io/crates/serde_derive/serde_derive-1.0.119.crate"
   }
-  version: "1.0.117"
+  version: "1.0.119"
   license_type: NOTICE
   last_upgrade_date {
-    year: 2020
-    month: 11
-    day: 24
+    year: 2021
+    month: 1
+    day: 11
   }
 }
diff --git a/src/de.rs b/src/de.rs
index 1f5733a..10033e4 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -12,6 +12,7 @@ use internals::{attr, ungroup, Ctxt, Derive};
 use pretend;
 
 use std::collections::BTreeSet;
+use std::ptr;
 
 pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream, Vec<syn::Error>> {
     let ctxt = Ctxt::new();
@@ -34,7 +35,7 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream
         let used = pretend::pretend_used(&cont);
         quote! {
             impl #de_impl_generics #ident #ty_generics #where_clause {
-                #vis fn deserialize<__D>(__deserializer: __D) -> #serde::export::Result<#remote #ty_generics, __D::Error>
+                #vis fn deserialize<__D>(__deserializer: __D) -> #serde::__private::Result<#remote #ty_generics, __D::Error>
                 where
                     __D: #serde::Deserializer<#delife>,
                 {
@@ -49,7 +50,7 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream
         quote! {
             #[automatically_derived]
             impl #de_impl_generics #serde::Deserialize<#delife> for #ident #ty_generics #where_clause {
-                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<#delife>,
                 {
@@ -164,9 +165,11 @@ fn build_generics(cont: &Container, borrowed: &BorrowedLifetimes) -> syn::Generi
         Some(predicates) => bound::with_where_predicates(&generics, predicates),
         None => {
             let generics = match *cont.attrs.default() {
-                attr::Default::Default => {
-                    bound::with_self_bound(cont, &generics, &parse_quote!(_serde::export::Default))
-                }
+                attr::Default::Default => bound::with_self_bound(
+                    cont,
+                    &generics,
+                    &parse_quote!(_serde::__private::Default),
+                ),
                 attr::Default::None | attr::Default::Path(_) => generics,
             };
 
@@ -182,7 +185,7 @@ fn build_generics(cont: &Container, borrowed: &BorrowedLifetimes) -> syn::Generi
                 cont,
                 &generics,
                 requires_default,
-                &parse_quote!(_serde::export::Default),
+                &parse_quote!(_serde::__private::Default),
             )
         }
     }
@@ -324,7 +327,7 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St
     let stmts = Stmts(code);
 
     let fn_deserialize_in_place = quote_block! {
-        fn deserialize_in_place<__D>(__deserializer: __D, __place: &mut Self) -> _serde::export::Result<(), __D::Error>
+        fn deserialize_in_place<__D>(__deserializer: __D, __place: &mut Self) -> _serde::__private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<#delife>,
         {
@@ -359,20 +362,20 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
 
     let assign = fields.iter().map(|field| {
         let member = &field.member;
-        if field as *const Field == transparent_field as *const Field {
+        if ptr::eq(field, transparent_field) {
             quote!(#member: __transparent)
         } else {
             let value = match field.attrs.default() {
-                attr::Default::Default => quote!(_serde::export::Default::default()),
+                attr::Default::Default => quote!(_serde::__private::Default::default()),
                 attr::Default::Path(path) => quote!(#path()),
-                attr::Default::None => quote!(_serde::export::PhantomData),
+                attr::Default::None => quote!(_serde::__private::PhantomData),
             };
             quote!(#member: #value)
         }
     });
 
     quote_block! {
-        _serde::export::Result::map(
+        _serde::__private::Result::map(
             #path(__deserializer),
             |__transparent| #this { #(#assign),* })
     }
@@ -380,17 +383,17 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
 
 fn deserialize_from(type_from: &syn::Type) -> Fragment {
     quote_block! {
-        _serde::export::Result::map(
+        _serde::__private::Result::map(
             <#type_from as _serde::Deserialize>::deserialize(__deserializer),
-            _serde::export::From::from)
+            _serde::__private::From::from)
     }
 }
 
 fn deserialize_try_from(type_try_from: &syn::Type) -> Fragment {
     quote_block! {
-        _serde::export::Result::and_then(
+        _serde::__private::Result::and_then(
             <#type_try_from as _serde::Deserialize>::deserialize(__deserializer),
-            |v| _serde::export::TryFrom::try_from(v).map_err(_serde::de::Error::custom))
+            |v| _serde::__private::TryFrom::try_from(v).map_err(_serde::de::Error::custom))
     }
 }
 
@@ -406,16 +409,16 @@ fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fra
         impl<'de> _serde::de::Visitor<'de> for __Visitor {
             type Value = #this;
 
-            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(__formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+                _serde::__private::Formatter::write_str(__formatter, #expecting)
             }
 
             #[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(#this)
+                _serde::__private::Ok(#this)
             }
         }
 
@@ -471,8 +474,8 @@ fn deserialize_tuple(
 
     let visitor_expr = quote! {
         __Visitor {
-            marker: _serde::export::PhantomData::<#this #ty_generics>,
-            lifetime: _serde::export::PhantomData,
+            marker: _serde::__private::PhantomData::<#this #ty_generics>,
+            lifetime: _serde::__private::PhantomData,
         }
     };
     let dispatch = if let Some(deserializer) = deserializer {
@@ -496,21 +499,21 @@ fn deserialize_tuple(
 
     quote_block! {
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::export::PhantomData<#this #ty_generics>,
-            lifetime: _serde::export::PhantomData<&#delife ()>,
+            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
             type Value = #this #ty_generics;
 
-            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(__formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+                _serde::__private::Formatter::write_str(__formatter, #expecting)
             }
 
             #visit_newtype_struct
 
             #[inline]
-            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
+            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::__private::Result<Self::Value, __A::Error>
             where
                 __A: _serde::de::SeqAccess<#delife>,
             {
@@ -556,7 +559,7 @@ fn deserialize_tuple_in_place(
     let visitor_expr = quote! {
         __Visitor {
             place: __place,
-            lifetime: _serde::export::PhantomData,
+            lifetime: _serde::__private::PhantomData,
         }
     };
 
@@ -586,20 +589,20 @@ fn deserialize_tuple_in_place(
     quote_block! {
         struct __Visitor #in_place_impl_generics #where_clause {
             place: &#place_life mut #this #ty_generics,
-            lifetime: _serde::export::PhantomData<&#delife ()>,
+            lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #in_place_impl_generics _serde::de::Visitor<#delife> for __Visitor #in_place_ty_generics #where_clause {
             type Value = ();
 
-            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(__formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+                _serde::__private::Formatter::write_str(__formatter, #expecting)
             }
 
             #visit_newtype_struct
 
             #[inline]
-            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
+            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::__private::Result<Self::Value, __A::Error>
             where
                 __A: _serde::de::SeqAccess<#delife>,
             {
@@ -651,23 +654,23 @@ fn deserialize_seq(
                     let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
                     quote!({
                         #wrapper
-                        _serde::export::Option::map(
+                        _serde::__private::Option::map(
                             try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)),
                             |__wrap| __wrap.value)
                     })
                 }
             };
             let value_if_none = match field.attrs.default() {
-                attr::Default::Default => quote!(_serde::export::Default::default()),
+                attr::Default::Default => quote!(_serde::__private::Default::default()),
                 attr::Default::Path(path) => quote!(#path()),
                 attr::Default::None => quote!(
-                    return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
+                    return _serde::__private::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
                 ),
             };
             let assign = quote! {
                 let #var = match #visit {
-                    _serde::export::Some(__value) => __value,
-                    _serde::export::None => {
+                    _serde::__private::Some(__value) => __value,
+                    _serde::__private::None => {
                         #value_if_none
                     }
                 };
@@ -691,13 +694,13 @@ fn deserialize_seq(
     if params.has_getter {
         let this = &params.this;
         result = quote! {
-            _serde::export::Into::<#this>::into(#result)
+            _serde::__private::Into::<#this>::into(#result)
         };
     }
 
     let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
-            let __default: Self::Value = _serde::export::Default::default();
+            let __default: Self::Value = _serde::__private::Default::default();
         )),
         attr::Default::Path(path) => Some(quote!(
             let __default: Self::Value = #path();
@@ -712,7 +715,7 @@ fn deserialize_seq(
     quote_block! {
         #let_default
         #(#let_values)*
-        _serde::export::Ok(#result)
+        _serde::__private::Ok(#result)
     }
 }
 
@@ -745,20 +748,20 @@ fn deserialize_seq_in_place(
         } else {
             let value_if_none = match field.attrs.default() {
                 attr::Default::Default => quote!(
-                    self.place.#member = _serde::export::Default::default();
+                    self.place.#member = _serde::__private::Default::default();
                 ),
                 attr::Default::Path(path) => quote!(
                     self.place.#member = #path();
                 ),
                 attr::Default::None => quote!(
-                    return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
+                    return _serde::__private::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
                 ),
             };
             let write = match field.attrs.deserialize_with() {
                 None => {
                     quote! {
-                        if let _serde::export::None = try!(_serde::de::SeqAccess::next_element_seed(&mut __seq,
-                            _serde::private::de::InPlaceSeed(&mut self.place.#member)))
+                        if let _serde::__private::None = try!(_serde::de::SeqAccess::next_element_seed(&mut __seq,
+                            _serde::__private::de::InPlaceSeed(&mut self.place.#member)))
                         {
                             #value_if_none
                         }
@@ -769,10 +772,10 @@ fn deserialize_seq_in_place(
                     quote!({
                         #wrapper
                         match try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)) {
-                            _serde::export::Some(__wrap) => {
+                            _serde::__private::Some(__wrap) => {
                                 self.place.#member = __wrap.value;
                             }
-                            _serde::export::None => {
+                            _serde::__private::None => {
                                 #value_if_none
                             }
                         }
@@ -788,7 +791,7 @@ fn deserialize_seq_in_place(
     let (_, ty_generics, _) = params.generics.split_for_impl();
     let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
-            let __default: #this #ty_generics  = _serde::export::Default::default();
+            let __default: #this #ty_generics  = _serde::__private::Default::default();
         )),
         attr::Default::Path(path) => Some(quote!(
             let __default: #this #ty_generics  = #path();
@@ -803,7 +806,7 @@ fn deserialize_seq_in_place(
     quote_block! {
         #let_default
         #(#write_values)*
-        _serde::export::Ok(())
+        _serde::__private::Ok(())
     }
 }
 
@@ -834,18 +837,18 @@ fn deserialize_newtype_struct(
     if params.has_getter {
         let this = &params.this;
         result = quote! {
-            _serde::export::Into::<#this>::into(#result)
+            _serde::__private::Into::<#this>::into(#result)
         };
     }
 
     quote! {
         #[inline]
-        fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::export::Result<Self::Value, __E::Error>
+        fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::__private::Result<Self::Value, __E::Error>
         where
             __E: _serde::Deserializer<#delife>,
         {
             let __field0: #field_ty = #value;
-            _serde::export::Ok(#result)
+            _serde::__private::Ok(#result)
         }
     }
 }
@@ -860,7 +863,7 @@ fn deserialize_newtype_struct_in_place(params: &Parameters, field: &Field) -> To
 
     quote! {
         #[inline]
-        fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::export::Result<Self::Value, __E::Error>
+        fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::__private::Result<Self::Value, __E::Error>
         where
             __E: _serde::Deserializer<#delife>,
         {
@@ -923,8 +926,8 @@ fn deserialize_struct(
 
     let visitor_expr = quote! {
         __Visitor {
-            marker: _serde::export::PhantomData::<#this #ty_generics>,
-            lifetime: _serde::export::PhantomData,
+            marker: _serde::__private::PhantomData::<#this #ty_generics>,
+            lifetime: _serde::__private::PhantomData,
         }
     };
     let dispatch = if let Some(deserializer) = deserializer {
@@ -962,7 +965,7 @@ fn deserialize_struct(
     let visit_seq = match *untagged {
         Untagged::No if !cattrs.has_flatten() => Some(quote! {
             #[inline]
-            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
+            fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::__private::Result<Self::Value, __A::Error>
             where
                 __A: _serde::de::SeqAccess<#delife>,
             {
@@ -977,7 +980,7 @@ fn deserialize_struct(
             impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Visitor #de_ty_generics #where_clause {
                 type Value = #this #ty_generics;
 
-                fn deserialize<__D>(self, __deserializer: __D) -> _serde::export::Result<Self::Value, __D::Error>
+                fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -993,21 +996,21 @@ fn deserialize_struct(
         #field_visitor
 
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::export::PhantomData<#this #ty_generics>,
-            lifetime: _serde::export::PhantomData<&#delife ()>,
+            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
             type Value = #this #ty_generics;
 
-            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(__formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+                _serde::__private::Formatter::write_str(__formatter, #expecting)
             }
 
             #visit_seq
 
             #[inline]
-            fn visit_map<__A>(self, mut __map: __A) -> _serde::export::Result<Self::Value, __A::Error>
+            fn visit_map<__A>(self, mut __map: __A) -> _serde::__private::Result<Self::Value, __A::Error>
             where
                 __A: _serde::de::MapAccess<#delife>,
             {
@@ -1061,7 +1064,7 @@ fn deserialize_struct_in_place(
     let visitor_expr = quote! {
         __Visitor {
             place: __place,
-            lifetime: _serde::export::PhantomData,
+            lifetime: _serde::__private::PhantomData,
         }
     };
     let dispatch = if let Some(deserializer) = deserializer {
@@ -1088,7 +1091,7 @@ fn deserialize_struct_in_place(
 
     let visit_seq = quote! {
         #[inline]
-        fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
+        fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::__private::Result<Self::Value, __A::Error>
         where
             __A: _serde::de::SeqAccess<#delife>,
         {
@@ -1105,20 +1108,20 @@ fn deserialize_struct_in_place(
 
         struct __Visitor #in_place_impl_generics #where_clause {
             place: &#place_life mut #this #ty_generics,
-            lifetime: _serde::export::PhantomData<&#delife ()>,
+            lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #in_place_impl_generics _serde::de::Visitor<#delife> for __Visitor #in_place_ty_generics #where_clause {
             type Value = ();
 
-            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(__formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+                _serde::__private::Formatter::write_str(__formatter, #expecting)
             }
 
             #visit_seq
 
             #[inline]
-            fn visit_map<__A>(self, mut __map: __A) -> _serde::export::Result<Self::Value, __A::Error>
+            fn visit_map<__A>(self, mut __map: __A) -> _serde::__private::Result<Self::Value, __A::Error>
             where
                 __A: _serde::de::MapAccess<#delife>,
             {
@@ -1228,9 +1231,9 @@ fn deserialize_externally_tagged_enum(
         // all variants have `#[serde(skip_deserializing)]`.
         quote! {
             // FIXME: Once we drop support for Rust 1.15:
-            // let _serde::export::Err(__err) = _serde::de::EnumAccess::variant::<__Field>(__data);
-            // _serde::export::Err(__err)
-            _serde::export::Result::map(
+            // let _serde::__private::Err(__err) = _serde::de::EnumAccess::variant::<__Field>(__data);
+            // _serde::__private::Err(__err)
+            _serde::__private::Result::map(
                 _serde::de::EnumAccess::variant::<__Field>(__data),
                 |(__impossible, _)| match __impossible {})
         }
@@ -1246,18 +1249,18 @@ fn deserialize_externally_tagged_enum(
         #variant_visitor
 
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::export::PhantomData<#this #ty_generics>,
-            lifetime: _serde::export::PhantomData<&#delife ()>,
+            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
             type Value = #this #ty_generics;
 
-            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(__formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+                _serde::__private::Formatter::write_str(__formatter, #expecting)
             }
 
-            fn visit_enum<__A>(self, __data: __A) -> _serde::export::Result<Self::Value, __A::Error>
+            fn visit_enum<__A>(self, __data: __A) -> _serde::__private::Result<Self::Value, __A::Error>
             where
                 __A: _serde::de::EnumAccess<#delife>,
             {
@@ -1272,8 +1275,8 @@ fn deserialize_externally_tagged_enum(
             #type_name,
             VARIANTS,
             __Visitor {
-                marker: _serde::export::PhantomData::<#this #ty_generics>,
-                lifetime: _serde::export::PhantomData,
+                marker: _serde::__private::PhantomData::<#this #ty_generics>,
+                lifetime: _serde::__private::PhantomData,
             },
         )
     }
@@ -1300,7 +1303,7 @@ fn deserialize_internally_tagged_enum(
                 variant,
                 cattrs,
                 quote! {
-                    _serde::private::de::ContentDeserializer::<__D::Error>::new(__tagged.content)
+                    _serde::__private::de::ContentDeserializer::<__D::Error>::new(__tagged.content)
                 },
             ));
 
@@ -1316,7 +1319,7 @@ fn deserialize_internally_tagged_enum(
 
         let __tagged = try!(_serde::Deserializer::deserialize_any(
             __deserializer,
-            _serde::private::de::TaggedContentVisitor::<__Field>::new(#tag)));
+            _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag)));
 
         match __tagged.tag {
             #(#variant_arms)*
@@ -1365,9 +1368,9 @@ fn deserialize_adjacently_tagged_enum(
     // If unknown fields are allowed, we pick the visitor that can step over
     // those. Otherwise we pick the visitor that fails on unknown keys.
     let field_visitor_ty = if deny_unknown_fields {
-        quote! { _serde::private::de::TagOrContentFieldVisitor }
+        quote! { _serde::__private::de::TagOrContentFieldVisitor }
     } else {
-        quote! { _serde::private::de::TagContentOtherFieldVisitor }
+        quote! { _serde::__private::de::TagContentOtherFieldVisitor }
     };
 
     let tag_or_content = quote! {
@@ -1378,7 +1381,7 @@ fn deserialize_adjacently_tagged_enum(
     };
 
     let mut missing_content = quote! {
-        _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#content))
+        _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#content))
     };
     let mut missing_content_fallthrough = quote!();
     let missing_content_arms = variants
@@ -1391,11 +1394,11 @@ fn deserialize_adjacently_tagged_enum(
 
             let arm = match variant.style {
                 Style::Unit => quote! {
-                    _serde::export::Ok(#this::#variant_ident)
+                    _serde::__private::Ok(#this::#variant_ident)
                 },
                 Style::Newtype if variant.attrs.deserialize_with().is_none() => {
                     let span = variant.original.span();
-                    let func = quote_spanned!(span=> _serde::private::de::missing_field);
+                    let func = quote_spanned!(span=> _serde::__private::de::missing_field);
                     quote! {
                         #func(#content).map(#this::#variant_ident)
                     }
@@ -1430,19 +1433,19 @@ fn deserialize_adjacently_tagged_enum(
         next_key
     } else {
         quote!({
-            let mut __rk : _serde::export::Option<_serde::private::de::TagOrContentField> = _serde::export::None;
-            while let _serde::export::Some(__k) = #next_key {
+            let mut __rk : _serde::__private::Option<_serde::__private::de::TagOrContentField> = _serde::__private::None;
+            while let _serde::__private::Some(__k) = #next_key {
                 match __k {
-                    _serde::private::de::TagContentOtherField::Other => {
+                    _serde::__private::de::TagContentOtherField::Other => {
                         try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map));
                         continue;
                     },
-                    _serde::private::de::TagContentOtherField::Tag => {
-                        __rk = _serde::export::Some(_serde::private::de::TagOrContentField::Tag);
+                    _serde::__private::de::TagContentOtherField::Tag => {
+                        __rk = _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag);
                         break;
                     }
-                    _serde::private::de::TagContentOtherField::Content => {
-                        __rk = _serde::export::Some(_serde::private::de::TagOrContentField::Content);
+                    _serde::__private::de::TagContentOtherField::Content => {
+                        __rk = _serde::__private::Some(_serde::__private::de::TagOrContentField::Content);
                         break;
                     }
                 }
@@ -1457,13 +1460,13 @@ fn deserialize_adjacently_tagged_enum(
     // at this point immediately produce an error.
     let visit_remaining_keys = quote! {
         match #next_relevant_key {
-            _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
-                _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
+            _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
+                _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
             }
-            _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
-                _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
+            _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
+                _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
             }
-            _serde::export::None => _serde::export::Ok(__ret),
+            _serde::__private::None => _serde::__private::Ok(__ret),
         }
     };
 
@@ -1489,14 +1492,14 @@ fn deserialize_adjacently_tagged_enum(
 
         struct __Seed #de_impl_generics #where_clause {
             field: __Field,
-            marker: _serde::export::PhantomData<#this #ty_generics>,
-            lifetime: _serde::export::PhantomData<&#delife ()>,
+            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Seed #de_ty_generics #where_clause {
             type Value = #this #ty_generics;
 
-            fn deserialize<__D>(self, __deserializer: __D) -> _serde::export::Result<Self::Value, __D::Error>
+            fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
             where
                 __D: _serde::Deserializer<#delife>,
             {
@@ -1507,102 +1510,102 @@ fn deserialize_adjacently_tagged_enum(
         }
 
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::export::PhantomData<#this #ty_generics>,
-            lifetime: _serde::export::PhantomData<&#delife ()>,
+            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
             type Value = #this #ty_generics;
 
-            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(__formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+                _serde::__private::Formatter::write_str(__formatter, #expecting)
             }
 
-            fn visit_map<__A>(self, mut __map: __A) -> _serde::export::Result<Self::Value, __A::Error>
+            fn visit_map<__A>(self, mut __map: __A) -> _serde::__private::Result<Self::Value, __A::Error>
             where
                 __A: _serde::de::MapAccess<#delife>,
             {
                 // Visit the first relevant key.
                 match #next_relevant_key {
                     // First key is the tag.
-                    _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
+                    _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
                         // Parse the tag.
                         let __field = try!(_serde::de::MapAccess::next_value(&mut __map));
                         // Visit the second key.
                         match #next_relevant_key {
                             // Second key is a duplicate of the tag.
-                            _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
-                                _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
+                            _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
+                                _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
                             }
                             // Second key is the content.
-                            _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
+                            _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
                                 let __ret = try!(_serde::de::MapAccess::next_value_seed(&mut __map,
                                     __Seed {
                                         field: __field,
-                                        marker: _serde::export::PhantomData,
-                                        lifetime: _serde::export::PhantomData,
+                                        marker: _serde::__private::PhantomData,
+                                        lifetime: _serde::__private::PhantomData,
                                     }));
                                 // Visit remaining keys, looking for duplicates.
                                 #visit_remaining_keys
                             }
                             // There is no second key; might be okay if the we have a unit variant.
-                            _serde::export::None => #missing_content
+                            _serde::__private::None => #missing_content
                         }
                     }
                     // First key is the content.
-                    _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
+                    _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
                         // Buffer up the content.
-                        let __content = try!(_serde::de::MapAccess::next_value::<_serde::private::de::Content>(&mut __map));
+                        let __content = try!(_serde::de::MapAccess::next_value::<_serde::__private::de::Content>(&mut __map));
                         // Visit the second key.
                         match #next_relevant_key {
                             // Second key is the tag.
-                            _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
-                                let __deserializer = _serde::private::de::ContentDeserializer::<__A::Error>::new(__content);
+                            _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
+                                let __deserializer = _serde::__private::de::ContentDeserializer::<__A::Error>::new(__content);
                                 #finish_content_then_tag
                             }
                             // Second key is a duplicate of the content.
-                            _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
-                                _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
+                            _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
+                                _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
                             }
                             // There is no second key.
-                            _serde::export::None => {
-                                _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
+                            _serde::__private::None => {
+                                _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
                             }
                         }
                     }
                     // There is no first key.
-                    _serde::export::None => {
-                        _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
+                    _serde::__private::None => {
+                        _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
                     }
                 }
             }
 
-            fn visit_seq<__A>(self, mut __seq: __A) -> _serde::export::Result<Self::Value, __A::Error>
+            fn visit_seq<__A>(self, mut __seq: __A) -> _serde::__private::Result<Self::Value, __A::Error>
             where
                 __A: _serde::de::SeqAccess<#delife>,
             {
                 // Visit the first element - the tag.
                 match try!(_serde::de::SeqAccess::next_element(&mut __seq)) {
-                    _serde::export::Some(__field) => {
+                    _serde::__private::Some(__field) => {
                         // Visit the second element - the content.
                         match try!(_serde::de::SeqAccess::next_element_seed(
                             &mut __seq,
                             __Seed {
                                 field: __field,
-                                marker: _serde::export::PhantomData,
-                                lifetime: _serde::export::PhantomData,
+                                marker: _serde::__private::PhantomData,
+                                lifetime: _serde::__private::PhantomData,
                             },
                         )) {
-                            _serde::export::Some(__ret) => _serde::export::Ok(__ret),
+                            _serde::__private::Some(__ret) => _serde::__private::Ok(__ret),
                             // There is no second element.
-                            _serde::export::None => {
-                                _serde::export::Err(_serde::de::Error::invalid_length(1, &self))
+                            _serde::__private::None => {
+                                _serde::__private::Err(_serde::de::Error::invalid_length(1, &self))
                             }
                         }
                     }
                     // There is no first element.
-                    _serde::export::None => {
-                        _serde::export::Err(_serde::de::Error::invalid_length(0, &self))
+                    _serde::__private::None => {
+                        _serde::__private::Err(_serde::de::Error::invalid_length(0, &self))
                     }
                 }
             }
@@ -1614,8 +1617,8 @@ fn deserialize_adjacently_tagged_enum(
             #type_name,
             FIELDS,
             __Visitor {
-                marker: _serde::export::PhantomData::<#this #ty_generics>,
-                lifetime: _serde::export::PhantomData,
+                marker: _serde::__private::PhantomData::<#this #ty_generics>,
+                lifetime: _serde::__private::PhantomData,
             },
         )
     }
@@ -1634,7 +1637,9 @@ fn deserialize_untagged_enum(
                 params,
                 variant,
                 cattrs,
-                quote!(_serde::private::de::ContentRefDeserializer::<__D::Error>::new(&__content)),
+                quote!(
+                    _serde::__private::de::ContentRefDeserializer::<__D::Error>::new(&__content)
+                ),
             ))
         });
 
@@ -1650,15 +1655,15 @@ fn deserialize_untagged_enum(
     );
 
     quote_block! {
-        let __content = try!(<_serde::private::de::Content as _serde::Deserialize>::deserialize(__deserializer));
+        let __content = try!(<_serde::__private::de::Content as _serde::Deserialize>::deserialize(__deserializer));
 
         #(
-            if let _serde::export::Ok(__ok) = #attempts {
-                return _serde::export::Ok(__ok);
+            if let _serde::__private::Ok(__ok) = #attempts {
+                return _serde::__private::Ok(__ok);
             }
         )*
 
-        _serde::export::Err(_serde::de::Error::custom(#fallthrough_msg))
+        _serde::__private::Err(_serde::de::Error::custom(#fallthrough_msg))
     }
 }
 
@@ -1671,7 +1676,7 @@ fn deserialize_externally_tagged_variant(
         let (wrapper, wrapper_ty, unwrap_fn) = wrap_deserialize_variant_with(params, variant, path);
         return quote_block! {
             #wrapper
-            _serde::export::Result::map(
+            _serde::__private::Result::map(
                 _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant), #unwrap_fn)
         };
     }
@@ -1683,7 +1688,7 @@ fn deserialize_externally_tagged_variant(
             let this = &params.this;
             quote_block! {
                 try!(_serde::de::VariantAccess::unit_variant(__variant));
-                _serde::export::Ok(#this::#variant_ident)
+                _serde::__private::Ok(#this::#variant_ident)
             }
         }
         Style::Newtype => deserialize_externally_tagged_newtype_variant(
@@ -1728,8 +1733,8 @@ fn deserialize_internally_tagged_variant(
                 quote!((#default))
             });
             quote_block! {
-                try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name)));
-                _serde::export::Ok(#this::#variant_ident #default)
+                try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::__private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name)));
+                _serde::__private::Ok(#this::#variant_ident #default)
             }
         }
         Style::Newtype => deserialize_untagged_newtype_variant(
@@ -1760,7 +1765,7 @@ fn deserialize_untagged_variant(
         let (wrapper, wrapper_ty, unwrap_fn) = wrap_deserialize_variant_with(params, variant, path);
         return quote_block! {
             #wrapper
-            _serde::export::Result::map(
+            _serde::__private::Result::map(
                 <#wrapper_ty as _serde::Deserialize>::deserialize(#deserializer), #unwrap_fn)
         };
     }
@@ -1779,10 +1784,10 @@ fn deserialize_untagged_variant(
             quote_expr! {
                 match _serde::Deserializer::deserialize_any(
                     #deserializer,
-                    _serde::private::de::UntaggedUnitVisitor::new(#type_name, #variant_name)
+                    _serde::__private::de::UntaggedUnitVisitor::new(#type_name, #variant_name)
                 ) {
-                    _serde::export::Ok(()) => _serde::export::Ok(#this::#variant_ident #default),
-                    _serde::export::Err(__err) => _serde::export::Err(__err),
+                    _serde::__private::Ok(()) => _serde::__private::Ok(#this::#variant_ident #default),
+                    _serde::__private::Err(__err) => _serde::__private::Err(__err),
                 }
             }
         }
@@ -1823,7 +1828,7 @@ fn deserialize_externally_tagged_newtype_variant(
         let default = Expr(expr_is_missing(field, cattrs));
         return quote_block! {
             try!(_serde::de::VariantAccess::unit_variant(__variant));
-            _serde::export::Ok(#this::#variant_ident(#default))
+            _serde::__private::Ok(#this::#variant_ident(#default))
         };
     }
 
@@ -1834,14 +1839,14 @@ fn deserialize_externally_tagged_newtype_variant(
             let func =
                 quote_spanned!(span=> _serde::de::VariantAccess::newtype_variant::<#field_ty>);
             quote_expr! {
-                _serde::export::Result::map(#func(__variant), #this::#variant_ident)
+                _serde::__private::Result::map(#func(__variant), #this::#variant_ident)
             }
         }
         Some(path) => {
             let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
             quote_block! {
                 #wrapper
-                _serde::export::Result::map(
+                _serde::__private::Result::map(
                     _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant),
                     |__wrapper| #this::#variant_ident(__wrapper.value))
             }
@@ -1862,13 +1867,13 @@ fn deserialize_untagged_newtype_variant(
             let span = field.original.span();
             let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
             quote_expr! {
-                _serde::export::Result::map(#func(#deserializer), #this::#variant_ident)
+                _serde::__private::Result::map(#func(#deserializer), #this::#variant_ident)
             }
         }
         Some(path) => {
             quote_block! {
-                let __value: _serde::export::Result<#field_ty, _> = #path(#deserializer);
-                _serde::export::Result::map(__value, #this::#variant_ident)
+                let __value: _serde::__private::Result<#field_ty, _> = #path(#deserializer);
+                _serde::__private::Result::map(__value, #this::#variant_ident)
             }
         }
     }
@@ -1884,18 +1889,18 @@ fn deserialize_generated_identifier(
     let field_idents: &Vec<_> = &fields.iter().map(|(_, ident, _)| ident).collect();
 
     let (ignore_variant, fallthrough) = if !is_variant && cattrs.has_flatten() {
-        let ignore_variant = quote!(__other(_serde::private::de::Content<'de>),);
-        let fallthrough = quote!(_serde::export::Ok(__Field::__other(__value)));
+        let ignore_variant = quote!(__other(_serde::__private::de::Content<'de>),);
+        let fallthrough = quote!(_serde::__private::Ok(__Field::__other(__value)));
         (Some(ignore_variant), Some(fallthrough))
     } else if let Some(other_idx) = other_idx {
         let ignore_variant = fields[other_idx].1.clone();
-        let fallthrough = quote!(_serde::export::Ok(__Field::#ignore_variant));
+        let fallthrough = quote!(_serde::__private::Ok(__Field::#ignore_variant));
         (None, Some(fallthrough))
     } else if is_variant || cattrs.deny_unknown_fields() {
         (None, None)
     } else {
         let ignore_variant = quote!(__ignore,);
-        let fallthrough = quote!(_serde::export::Ok(__Field::__ignore));
+        let fallthrough = quote!(_serde::__private::Ok(__Field::__ignore));
         (Some(ignore_variant), Some(fallthrough))
     };
 
@@ -1930,7 +1935,7 @@ fn deserialize_generated_identifier(
 
         impl<'de> _serde::Deserialize<'de> for __Field #lifetime {
             #[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>,
             {
@@ -1958,13 +1963,13 @@ fn deserialize_custom_identifier(
         let last_ident = &last.ident;
         if last.attrs.other() {
             let ordinary = &variants[..variants.len() - 1];
-            let fallthrough = quote!(_serde::export::Ok(#this::#last_ident));
+            let fallthrough = quote!(_serde::__private::Ok(#this::#last_ident));
             (ordinary, Some(fallthrough))
         } else if let Style::Newtype = last.style {
             let ordinary = &variants[..variants.len() - 1];
-            let deserializer = quote!(_serde::private::de::IdentifierDeserializer::from(__value));
+            let deserializer = quote!(_serde::__private::de::IdentifierDeserializer::from(__value));
             let fallthrough = quote! {
-                _serde::export::Result::map(
+                _serde::__private::Result::map(
                     _serde::Deserialize::deserialize(#deserializer),
                     #this::#last_ident)
             };
@@ -2018,8 +2023,8 @@ fn deserialize_custom_identifier(
         #names_const
 
         struct __FieldVisitor #de_impl_generics #where_clause {
-            marker: _serde::export::PhantomData<#this #ty_generics>,
-            lifetime: _serde::export::PhantomData<&#delife ()>,
+            marker: _serde::__private::PhantomData<#this #ty_generics>,
+            lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::de::Visitor<#delife> for __FieldVisitor #de_ty_generics #where_clause {
@@ -2029,8 +2034,8 @@ fn deserialize_custom_identifier(
         }
 
         let __visitor = __FieldVisitor {
-            marker: _serde::export::PhantomData::<#this #ty_generics>,
-            lifetime: _serde::export::PhantomData,
+            marker: _serde::__private::PhantomData::<#this #ty_generics>,
+            lifetime: _serde::__private::PhantomData,
         };
         _serde::Deserializer::deserialize_identifier(__deserializer, __visitor)
     }
@@ -2078,7 +2083,7 @@ fn deserialize_identifier(
         None
     } else {
         Some(quote! {
-            let __value = &_serde::export::from_utf8_lossy(__value);
+            let __value = &_serde::__private::from_utf8_lossy(__value);
         })
     };
 
@@ -2090,16 +2095,16 @@ fn deserialize_identifier(
     ) = if collect_other_fields {
         (
             Some(quote! {
-                let __value = _serde::private::de::Content::String(_serde::export::ToString::to_string(__value));
+                let __value = _serde::__private::de::Content::String(_serde::__private::ToString::to_string(__value));
             }),
             Some(quote! {
-                let __value = _serde::private::de::Content::Str(__value);
+                let __value = _serde::__private::de::Content::Str(__value);
             }),
             Some(quote! {
-                let __value = _serde::private::de::Content::ByteBuf(__value.to_vec());
+                let __value = _serde::__private::de::Content::ByteBuf(__value.to_vec());
             }),
             Some(quote! {
-                let __value = _serde::private::de::Content::Bytes(__value);
+                let __value = _serde::__private::de::Content::Bytes(__value);
             }),
         )
     } else {
@@ -2110,11 +2115,11 @@ fn deserialize_identifier(
         fallthrough
     } else if is_variant {
         quote! {
-            _serde::export::Err(_serde::de::Error::unknown_variant(__value, VARIANTS))
+            _serde::__private::Err(_serde::de::Error::unknown_variant(__value, VARIANTS))
         }
     } else {
         quote! {
-            _serde::export::Err(_serde::de::Error::unknown_field(__value, FIELDS))
+            _serde::__private::Err(_serde::de::Error::unknown_field(__value, FIELDS))
         }
     };
 
@@ -2122,104 +2127,104 @@ fn deserialize_identifier(
     let fallthrough_msg = format!("{} index 0 <= i < {}", index_expecting, fields.len());
     let visit_other = if collect_other_fields {
         quote! {
-            fn visit_bool<__E>(self, __value: bool) -> _serde::export::Result<Self::Value, __E>
+            fn visit_bool<__E>(self, __value: bool) -> _serde::__private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::export::Ok(__Field::__other(_serde::private::de::Content::Bool(__value)))
+                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::Bool(__value)))
             }
 
-            fn visit_i8<__E>(self, __value: i8) -> _serde::export::Result<Self::Value, __E>
+            fn visit_i8<__E>(self, __value: i8) -> _serde::__private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::export::Ok(__Field::__other(_serde::private::de::Content::I8(__value)))
+                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::I8(__value)))
             }
 
-            fn visit_i16<__E>(self, __value: i16) -> _serde::export::Result<Self::Value, __E>
+            fn visit_i16<__E>(self, __value: i16) -> _serde::__private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::export::Ok(__Field::__other(_serde::private::de::Content::I16(__value)))
+                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::I16(__value)))
             }
 
-            fn visit_i32<__E>(self, __value: i32) -> _serde::export::Result<Self::Value, __E>
+            fn visit_i32<__E>(self, __value: i32) -> _serde::__private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::export::Ok(__Field::__other(_serde::private::de::Content::I32(__value)))
+                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::I32(__value)))
             }
 
-            fn visit_i64<__E>(self, __value: i64) -> _serde::export::Result<Self::Value, __E>
+            fn visit_i64<__E>(self, __value: i64) -> _serde::__private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::export::Ok(__Field::__other(_serde::private::de::Content::I64(__value)))
+                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::I64(__value)))
             }
 
-            fn visit_u8<__E>(self, __value: u8) -> _serde::export::Result<Self::Value, __E>
+            fn visit_u8<__E>(self, __value: u8) -> _serde::__private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::export::Ok(__Field::__other(_serde::private::de::Content::U8(__value)))
+                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::U8(__value)))
             }
 
-            fn visit_u16<__E>(self, __value: u16) -> _serde::export::Result<Self::Value, __E>
+            fn visit_u16<__E>(self, __value: u16) -> _serde::__private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::export::Ok(__Field::__other(_serde::private::de::Content::U16(__value)))
+                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::U16(__value)))
             }
 
-            fn visit_u32<__E>(self, __value: u32) -> _serde::export::Result<Self::Value, __E>
+            fn visit_u32<__E>(self, __value: u32) -> _serde::__private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::export::Ok(__Field::__other(_serde::private::de::Content::U32(__value)))
+                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::U32(__value)))
             }
 
-            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,
             {
-                _serde::export::Ok(__Field::__other(_serde::private::de::Content::U64(__value)))
+                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::U64(__value)))
             }
 
-            fn visit_f32<__E>(self, __value: f32) -> _serde::export::Result<Self::Value, __E>
+            fn visit_f32<__E>(self, __value: f32) -> _serde::__private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::export::Ok(__Field::__other(_serde::private::de::Content::F32(__value)))
+                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::F32(__value)))
             }
 
-            fn visit_f64<__E>(self, __value: f64) -> _serde::export::Result<Self::Value, __E>
+            fn visit_f64<__E>(self, __value: f64) -> _serde::__private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::export::Ok(__Field::__other(_serde::private::de::Content::F64(__value)))
+                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::F64(__value)))
             }
 
-            fn visit_char<__E>(self, __value: char) -> _serde::export::Result<Self::Value, __E>
+            fn visit_char<__E>(self, __value: char) -> _serde::__private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::export::Ok(__Field::__other(_serde::private::de::Content::Char(__value)))
+                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::Char(__value)))
             }
 
-            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(__Field::__other(_serde::private::de::Content::Unit))
+                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::Unit))
             }
 
-            fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::export::Result<Self::Value, __E>
+            fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::__private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
                 match __value {
                     #(
-                        #field_borrowed_strs => _serde::export::Ok(#constructors),
+                        #field_borrowed_strs => _serde::__private::Ok(#constructors),
                     )*
                     _ => {
                         #value_as_borrowed_str_content
@@ -2228,13 +2233,13 @@ fn deserialize_identifier(
                 }
             }
 
-            fn visit_borrowed_bytes<__E>(self, __value: &'de [u8]) -> _serde::export::Result<Self::Value, __E>
+            fn visit_borrowed_bytes<__E>(self, __value: &'de [u8]) -> _serde::__private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
                 match __value {
                     #(
-                        #field_borrowed_bytes => _serde::export::Ok(#constructors),
+                        #field_borrowed_bytes => _serde::__private::Ok(#constructors),
                     )*
                     _ => {
                         #bytes_to_str
@@ -2246,15 +2251,15 @@ fn deserialize_identifier(
         }
     } else {
         quote! {
-            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 {
                     #(
-                        #variant_indices => _serde::export::Ok(#main_constructors),
+                        #variant_indices => _serde::__private::Ok(#main_constructors),
                     )*
-                    _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                    _ => _serde::__private::Err(_serde::de::Error::invalid_value(
                         _serde::de::Unexpected::Unsigned(__value),
                         &#fallthrough_msg,
                     ))
@@ -2264,19 +2269,19 @@ fn deserialize_identifier(
     };
 
     quote_block! {
-        fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-            _serde::export::Formatter::write_str(__formatter, #expecting)
+        fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+            _serde::__private::Formatter::write_str(__formatter, #expecting)
         }
 
         #visit_other
 
-        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 {
                 #(
-                    #field_strs => _serde::export::Ok(#constructors),
+                    #field_strs => _serde::__private::Ok(#constructors),
                 )*
                 _ => {
                     #value_as_str_content
@@ -2285,13 +2290,13 @@ fn deserialize_identifier(
             }
         }
 
-        fn visit_bytes<__E>(self, __value: &[u8]) -> _serde::export::Result<Self::Value, __E>
+        fn visit_bytes<__E>(self, __value: &[u8]) -> _serde::__private::Result<Self::Value, __E>
         where
             __E: _serde::de::Error,
         {
             match __value {
                 #(
-                    #field_bytes => _serde::export::Ok(#constructors),
+                    #field_bytes => _serde::__private::Ok(#constructors),
                 )*
                 _ => {
                     #bytes_to_str
@@ -2384,16 +2389,16 @@ fn deserialize_map(
         .map(|(field, name)| {
             let field_ty = field.ty;
             quote! {
-                let mut #name: _serde::export::Option<#field_ty> = _serde::export::None;
+                let mut #name: _serde::__private::Option<#field_ty> = _serde::__private::None;
             }
         });
 
     // Collect contents for flatten fields into a buffer
     let let_collect = if cattrs.has_flatten() {
         Some(quote! {
-            let mut __collect = _serde::export::Vec::<_serde::export::Option<(
-                _serde::private::de::Content,
-                _serde::private::de::Content
+            let mut __collect = _serde::__private::Vec::<_serde::__private::Option<(
+                _serde::__private::de::Content,
+                _serde::__private::de::Content
             )>>::new();
         })
     } else {
@@ -2422,9 +2427,9 @@ fn deserialize_map(
                     quote!({
                         #wrapper
                         match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
-                            _serde::export::Ok(__wrapper) => __wrapper.value,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                            _serde::__private::Ok(__wrapper) => __wrapper.value,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
                             }
                         }
                     })
@@ -2432,10 +2437,10 @@ fn deserialize_map(
             };
             quote! {
                 __Field::#name => {
-                    if _serde::export::Option::is_some(&#name) {
-                        return _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
+                    if _serde::__private::Option::is_some(&#name) {
+                        return _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
                     }
-                    #name = _serde::export::Some(#visit);
+                    #name = _serde::__private::Some(#visit);
                 }
             }
         });
@@ -2444,7 +2449,7 @@ fn deserialize_map(
     let ignored_arm = if cattrs.has_flatten() {
         Some(quote! {
             __Field::__other(__name) => {
-                __collect.push(_serde::export::Some((
+                __collect.push(_serde::__private::Some((
                     __name,
                     try!(_serde::de::MapAccess::next_value(&mut __map)))));
             }
@@ -2461,14 +2466,14 @@ fn deserialize_map(
     let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
         quote! {
             // FIXME: Once we drop support for Rust 1.15:
-            // let _serde::export::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
-            _serde::export::Option::map(
+            // let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
+            _serde::__private::Option::map(
                 try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
                 |__impossible| match __impossible {});
         }
     } else {
         quote! {
-            while let _serde::export::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
+            while let _serde::__private::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
                 match __key {
                     #(#value_arms)*
                     #ignored_arm
@@ -2485,8 +2490,8 @@ fn deserialize_map(
 
             quote! {
                 let #name = match #name {
-                    _serde::export::Some(#name) => #name,
-                    _serde::export::None => #missing_expr
+                    _serde::__private::Some(#name) => #name,
+                    _serde::__private::None => #missing_expr
                 };
             }
         });
@@ -2505,22 +2510,22 @@ fn deserialize_map(
             };
             quote! {
                 let #name: #field_ty = try!(#func(
-                    _serde::private::de::FlatMapDeserializer(
+                    _serde::__private::de::FlatMapDeserializer(
                         &mut __collect,
-                        _serde::export::PhantomData)));
+                        _serde::__private::PhantomData)));
             }
         });
 
     let collected_deny_unknown_fields = if cattrs.has_flatten() && cattrs.deny_unknown_fields() {
         Some(quote! {
-            if let _serde::export::Some(_serde::export::Some((__key, _))) =
-                __collect.into_iter().filter(_serde::export::Option::is_some).next()
+            if let _serde::__private::Some(_serde::__private::Some((__key, _))) =
+                __collect.into_iter().filter(_serde::__private::Option::is_some).next()
             {
-                if let _serde::export::Some(__key) = __key.as_str() {
-                    return _serde::export::Err(
+                if let _serde::__private::Some(__key) = __key.as_str() {
+                    return _serde::__private::Err(
                         _serde::de::Error::custom(format_args!("unknown field `{}`", &__key)));
                 } else {
-                    return _serde::export::Err(
+                    return _serde::__private::Err(
                         _serde::de::Error::custom(format_args!("unexpected map key")));
                 }
             }
@@ -2541,7 +2546,7 @@ fn deserialize_map(
 
     let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
-            let __default: Self::Value = _serde::export::Default::default();
+            let __default: Self::Value = _serde::__private::Default::default();
         )),
         attr::Default::Path(path) => Some(quote!(
             let __default: Self::Value = #path();
@@ -2557,7 +2562,7 @@ fn deserialize_map(
     if params.has_getter {
         let this = &params.this;
         result = quote! {
-            _serde::export::Into::<#this>::into(#result)
+            _serde::__private::Into::<#this>::into(#result)
         };
     }
 
@@ -2576,7 +2581,7 @@ fn deserialize_map(
 
         #collected_deny_unknown_fields
 
-        _serde::export::Ok(#result)
+        _serde::__private::Ok(#result)
     }
 }
 
@@ -2652,7 +2657,7 @@ fn deserialize_map_in_place(
             let visit = match field.attrs.deserialize_with() {
                 None => {
                     quote! {
-                        try!(_serde::de::MapAccess::next_value_seed(&mut __map, _serde::private::de::InPlaceSeed(&mut self.place.#member)))
+                        try!(_serde::de::MapAccess::next_value_seed(&mut __map, _serde::__private::de::InPlaceSeed(&mut self.place.#member)))
                     }
                 }
                 Some(path) => {
@@ -2660,9 +2665,9 @@ fn deserialize_map_in_place(
                     quote!({
                         #wrapper
                         self.place.#member = match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
-                            _serde::export::Ok(__wrapper) => __wrapper.value,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                            _serde::__private::Ok(__wrapper) => __wrapper.value,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
                             }
                         };
                     })
@@ -2671,7 +2676,7 @@ fn deserialize_map_in_place(
             quote! {
                 __Field::#name => {
                     if #name {
-                        return _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
+                        return _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
                     }
                     #visit;
                     #name = true;
@@ -2693,14 +2698,14 @@ fn deserialize_map_in_place(
     let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
         quote! {
             // FIXME: Once we drop support for Rust 1.15:
-            // let _serde::export::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
-            _serde::export::Option::map(
+            // let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
+            _serde::__private::Option::map(
                 try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
                 |__impossible| match __impossible {});
         }
     } else {
         quote! {
-            while let _serde::export::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
+            while let _serde::__private::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
                 match __key {
                     #(#value_arms_from)*
                     #ignored_arm
@@ -2742,7 +2747,7 @@ fn deserialize_map_in_place(
 
     let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
-            let __default: #this #ty_generics = _serde::export::Default::default();
+            let __default: #this #ty_generics = _serde::__private::Default::default();
         )),
         attr::Default::Path(path) => Some(quote!(
             let __default: #this #ty_generics = #path();
@@ -2763,7 +2768,7 @@ fn deserialize_map_in_place(
 
         #(#check_flags)*
 
-        _serde::export::Ok(())
+        _serde::__private::Ok(())
     }
 }
 
@@ -2786,19 +2791,19 @@ fn wrap_deserialize_with(
     let wrapper = quote! {
         struct __DeserializeWith #de_impl_generics #where_clause {
             value: #value_ty,
-            phantom: _serde::export::PhantomData<#this #ty_generics>,
-            lifetime: _serde::export::PhantomData<&#delife ()>,
+            phantom: _serde::__private::PhantomData<#this #ty_generics>,
+            lifetime: _serde::__private::PhantomData<&#delife ()>,
         }
 
         impl #de_impl_generics _serde::Deserialize<#delife> for __DeserializeWith #de_ty_generics #where_clause {
-            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<#delife>,
             {
-                _serde::export::Ok(__DeserializeWith {
+                _serde::__private::Ok(__DeserializeWith {
                     value: try!(#deserialize_with(__deserializer)),
-                    phantom: _serde::export::PhantomData,
-                    lifetime: _serde::export::PhantomData,
+                    phantom: _serde::__private::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 })
             }
         }
@@ -2866,7 +2871,7 @@ fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
     match field.attrs.default() {
         attr::Default::Default => {
             let span = field.original.span();
-            let func = quote_spanned!(span=> _serde::export::Default::default);
+            let func = quote_spanned!(span=> _serde::__private::Default::default);
             return quote_expr!(#func());
         }
         attr::Default::Path(path) => {
@@ -2887,14 +2892,14 @@ fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
     match field.attrs.deserialize_with() {
         None => {
             let span = field.original.span();
-            let func = quote_spanned!(span=> _serde::private::de::missing_field);
+            let func = quote_spanned!(span=> _serde::__private::de::missing_field);
             quote_expr! {
                 try!(#func(#name))
             }
         }
         Some(_) => {
             quote_expr! {
-                return _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#name))
+                return _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#name))
             }
         }
     }
diff --git a/src/internals/attr.rs b/src/internals/attr.rs
index e6f72df..766910c 100644
--- a/src/internals/attr.rs
+++ b/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());
diff --git a/src/lib.rs b/src/lib.rs
index 1711340..30e3d5b 100644
--- a/src/lib.rs
+++ b/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.117")]
+#![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
diff --git a/src/pretend.rs b/src/pretend.rs
index 7233c23..955ce3d 100644
--- a/src/pretend.rs
+++ b/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 {
-                _serde::export::Some((#(#placeholders,)*)) => {
+            match _serde::__private::None {
+                _serde::__private::Some((#(#placeholders,)*)) => {
                     let _ = #type_ident::#variant_ident #turbofish #pat;
                 }
                 _ => {}
diff --git a/src/ser.rs b/src/ser.rs
index f29d738..91154dc 100644
--- a/src/ser.rs
+++ b/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");
diff --git a/src/try.rs b/src/try.rs
index 48829b6..48cceeb 100644
--- a/src/try.rs
+++ b/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::export::Err(__err) => {
-                        return _serde::export::Err(__err);
+                    _serde::__private::Ok(__val) => __val,
+                    _serde::__private::Err(__err) => {
+                        return _serde::__private::Err(__err);
                     }
                 }
             }