diff --git a/serde/build.rs b/serde/build.rs
index 9d0d3a978..1c195f983 100644
--- a/serde/build.rs
+++ b/serde/build.rs
@@ -1,13 +1,29 @@
 use std::env;
+use std::fs;
+use std::path::PathBuf;
 use std::process::Command;
 use std::str;
 
+const PRIVATE: &str = "\
+#[doc(hidden)]
+pub mod __private$$ {
+    #[doc(hidden)]
+    pub use crate::private::*;
+}
+use serde_core::__private$$ as serde_core_private;
+";
+
 // The rustc-cfg strings below are *not* public API. Please let us know by
 // opening a GitHub issue if your build environment requires some way to enable
 // these cfgs other than by executing our build script.
 fn main() {
     println!("cargo:rerun-if-changed=build.rs");
 
+    let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    let patch_version = env::var("CARGO_PKG_VERSION_PATCH").unwrap();
+    let module = PRIVATE.replace("$$", &patch_version);
+    fs::write(out_dir.join("private.rs"), module).unwrap();
+
     let minor = match rustc_minor_version() {
         Some(minor) => minor,
         None => return,
diff --git a/serde/src/lib.rs b/serde/src/lib.rs
index b8898438f..64f36f961 100644
--- a/serde/src/lib.rs
+++ b/serde/src/lib.rs
@@ -239,8 +239,9 @@ mod integer128;
 
 // Used by generated code and doc tests. Not public API.
 #[doc(hidden)]
-#[path = "private/mod.rs"]
-pub mod __private;
+mod private;
+
+include!(concat!(env!("OUT_DIR"), "/private.rs"));
 
 // Re-export #[derive(Serialize, Deserialize)].
 //
diff --git a/serde/src/private/de.rs b/serde/src/private/de.rs
index 924d2d791..6f657f50e 100644
--- a/serde/src/private/de.rs
+++ b/serde/src/private/de.rs
@@ -17,7 +17,7 @@ pub use self::content::{
     UntaggedUnitVisitor,
 };
 
-pub use serde_core::__private::InPlaceSeed;
+pub use crate::serde_core_private::InPlaceSeed;
 
 /// If the missing field is of type `Option<T>` then treat is as `None`,
 /// otherwise it is an error.
@@ -216,8 +216,8 @@ mod content {
         self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, Expected, IgnoredAny,
         MapAccess, SeqAccess, Unexpected, Visitor,
     };
-    use serde_core::__private::size_hint;
-    pub use serde_core::__private::Content;
+    use crate::serde_core_private::size_hint;
+    pub use crate::serde_core_private::Content;
 
     pub fn content_as_str<'a, 'de>(content: &'a Content<'de>) -> Option<&'a str> {
         match *content {
diff --git a/serde/src/private/mod.rs b/serde/src/private/mod.rs
index 0098f16b1..20bfa4eb8 100644
--- a/serde/src/private/mod.rs
+++ b/serde/src/private/mod.rs
@@ -12,7 +12,7 @@ pub use crate::lib::option::Option::{self, None, Some};
 pub use crate::lib::ptr;
 pub use crate::lib::result::Result::{self, Err, Ok};
 
-pub use serde_core::__private::string::from_utf8_lossy;
+pub use crate::serde_core_private::string::from_utf8_lossy;
 
 #[cfg(any(feature = "alloc", feature = "std"))]
 pub use crate::lib::{ToString, Vec};
diff --git a/serde_core/build.rs b/serde_core/build.rs
index fe9fd15c1..0f0c88e87 100644
--- a/serde_core/build.rs
+++ b/serde_core/build.rs
@@ -1,13 +1,28 @@
 use std::env;
+use std::fs;
+use std::path::PathBuf;
 use std::process::Command;
 use std::str;
 
+const PRIVATE: &str = "\
+#[doc(hidden)]
+pub mod __private$$ {
+    #[doc(hidden)]
+    pub use crate::private::*;
+}
+";
+
 // The rustc-cfg strings below are *not* public API. Please let us know by
 // opening a GitHub issue if your build environment requires some way to enable
 // these cfgs other than by executing our build script.
 fn main() {
     println!("cargo:rerun-if-changed=build.rs");
 
+    let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
+    let patch_version = env::var("CARGO_PKG_VERSION_PATCH").unwrap();
+    let module = PRIVATE.replace("$$", &patch_version);
+    fs::write(out_dir.join("private.rs"), module).unwrap();
+
     let minor = match rustc_minor_version() {
         Some(minor) => minor,
         None => return,
diff --git a/serde_core/src/lib.rs b/serde_core/src/lib.rs
index aefc808c0..a3b022aac 100644
--- a/serde_core/src/lib.rs
+++ b/serde_core/src/lib.rs
@@ -252,9 +252,18 @@ pub use crate::ser::{Serialize, Serializer};
 
 // Used by generated code. Not public API.
 #[doc(hidden)]
-#[path = "private/mod.rs"]
-pub mod __private;
-use self::__private as private;
+mod private;
+
+// Used by declarative macro generated code. Not public API.
+#[doc(hidden)]
+pub mod __private {
+    #[doc(hidden)]
+    pub use crate::private::doc;
+    #[doc(hidden)]
+    pub use core::result::Result;
+}
+
+include!(concat!(env!("OUT_DIR"), "/private.rs"));
 
 #[cfg(all(not(feature = "std"), no_core_error))]
 mod std_error;
diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs
index 13f604623..3bac6bd70 100644
--- a/serde_derive/src/de.rs
+++ b/serde_derive/src/de.rs
@@ -2,7 +2,7 @@ use crate::fragment::{Expr, Fragment, Match, Stmts};
 use crate::internals::ast::{Container, Data, Field, Style, Variant};
 use crate::internals::name::Name;
 use crate::internals::{attr, replace_receiver, ungroup, Ctxt, Derive};
-use crate::{bound, dummy, pretend, this};
+use crate::{bound, dummy, pretend, private, this};
 use proc_macro2::{Literal, Span, TokenStream};
 use quote::{quote, quote_spanned, ToTokens};
 use std::collections::BTreeSet;
@@ -15,7 +15,7 @@ pub fn expand_derive_deserialize(input: &mut syn::DeriveInput) -> syn::Result<To
     replace_receiver(input);
 
     let ctxt = Ctxt::new();
-    let cont = match Container::from_ast(&ctxt, input, Derive::Deserialize) {
+    let cont = match Container::from_ast(&ctxt, input, Derive::Deserialize, &private.ident()) {
         Some(cont) => cont,
         None => return Err(ctxt.check().unwrap_err()),
     };
@@ -35,7 +35,7 @@ pub fn expand_derive_deserialize(input: &mut syn::DeriveInput) -> syn::Result<To
         quote! {
             #[automatically_derived]
             impl #de_impl_generics #ident #ty_generics #where_clause {
-                #vis fn deserialize<__D>(__deserializer: __D) -> #serde::__private::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>,
                 {
@@ -50,7 +50,7 @@ pub fn expand_derive_deserialize(input: &mut syn::DeriveInput) -> syn::Result<To
         quote! {
             #[automatically_derived]
             impl #de_impl_generics #serde::Deserialize<#delife> for #ident #ty_generics #where_clause {
-                fn deserialize<__D>(__deserializer: __D) -> #serde::__private::Result<Self, __D::Error>
+                fn deserialize<__D>(__deserializer: __D) -> #serde::#private::Result<Self, __D::Error>
                 where
                     __D: #serde::Deserializer<#delife>,
                 {
@@ -174,7 +174,7 @@ fn build_generics(cont: &Container, borrowed: &BorrowedLifetimes) -> syn::Generi
                 attr::Default::Default => bound::with_self_bound(
                     cont,
                     &generics,
-                    &parse_quote!(_serde::__private::Default),
+                    &parse_quote!(_serde::#private::Default),
                 ),
                 attr::Default::None | attr::Default::Path(_) => generics,
             };
@@ -191,7 +191,7 @@ fn build_generics(cont: &Container, borrowed: &BorrowedLifetimes) -> syn::Generi
                 cont,
                 &generics,
                 requires_default,
-                &parse_quote!(_serde::__private::Default),
+                &parse_quote!(_serde::#private::Default),
             )
         }
     }
@@ -333,7 +333,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::__private::Result<(), __D::Error>
+        fn deserialize_in_place<__D>(__deserializer: __D, __place: &mut Self) -> _serde::#private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<#delife>,
         {
@@ -372,20 +372,20 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
             quote!(#member: __transparent)
         } else {
             let value = match field.attrs.default() {
-                attr::Default::Default => quote!(_serde::__private::Default::default()),
+                attr::Default::Default => quote!(_serde::#private::Default::default()),
                 // If #path returns wrong type, error will be reported here (^^^^^).
                 // We attach span of the path to the function so it will be reported
                 // on the #[serde(default = "...")]
                 //                          ^^^^^
                 attr::Default::Path(path) => quote_spanned!(path.span()=> #path()),
-                attr::Default::None => quote!(_serde::__private::PhantomData),
+                attr::Default::None => quote!(_serde::#private::PhantomData),
             };
             quote!(#member: #value)
         }
     });
 
     quote_block! {
-        _serde::__private::Result::map(
+        _serde::#private::Result::map(
             #path(__deserializer),
             |__transparent| #this_value { #(#assign),* })
     }
@@ -393,17 +393,17 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
 
 fn deserialize_from(type_from: &syn::Type) -> Fragment {
     quote_block! {
-        _serde::__private::Result::map(
+        _serde::#private::Result::map(
             <#type_from as _serde::Deserialize>::deserialize(__deserializer),
-            _serde::__private::From::from)
+            _serde::#private::From::from)
     }
 }
 
 fn deserialize_try_from(type_try_from: &syn::Type) -> Fragment {
     quote_block! {
-        _serde::__private::Result::and_then(
+        _serde::#private::Result::and_then(
             <#type_try_from as _serde::Deserialize>::deserialize(__deserializer),
-            |v| _serde::__private::TryFrom::try_from(v).map_err(_serde::de::Error::custom))
+            |v| _serde::#private::TryFrom::try_from(v).map_err(_serde::de::Error::custom))
     }
 }
 
@@ -421,24 +421,24 @@ fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fra
     quote_block! {
         #[doc(hidden)]
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
+            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
+            lifetime: _serde::#private::PhantomData<&#delife ()>,
         }
 
         #[automatically_derived]
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
             type Value = #this_type #ty_generics;
 
-            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::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::__private::Result<Self::Value, __E>
+            fn visit_unit<__E>(self) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::Ok(#this_value)
+                _serde::#private::Ok(#this_value)
             }
         }
 
@@ -446,8 +446,8 @@ fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fra
             __deserializer,
             #type_name,
             __Visitor {
-                marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
-                lifetime: _serde::__private::PhantomData,
+                marker: _serde::#private::PhantomData::<#this_type #ty_generics>,
+                lifetime: _serde::#private::PhantomData,
             },
         )
     }
@@ -523,8 +523,8 @@ fn deserialize_tuple(
 
     let visitor_expr = quote! {
         __Visitor {
-            marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
-            lifetime: _serde::__private::PhantomData,
+            marker: _serde::#private::PhantomData::<#this_type #ty_generics>,
+            lifetime: _serde::#private::PhantomData,
         }
     };
     let dispatch = match form {
@@ -557,22 +557,22 @@ fn deserialize_tuple(
     quote_block! {
         #[doc(hidden)]
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
+            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
+            lifetime: _serde::#private::PhantomData<&#delife ()>,
         }
 
         #[automatically_derived]
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
             type Value = #this_type #ty_generics;
 
-            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::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::__private::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>,
             {
@@ -617,7 +617,7 @@ fn deserialize_tuple_in_place(
 
         Some(quote! {
             #[inline]
-            fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::__private::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>,
             {
@@ -633,7 +633,7 @@ fn deserialize_tuple_in_place(
     let visitor_expr = quote! {
         __Visitor {
             place: __place,
-            lifetime: _serde::__private::PhantomData,
+            lifetime: _serde::#private::PhantomData,
         }
     };
 
@@ -658,21 +658,21 @@ fn deserialize_tuple_in_place(
         #[doc(hidden)]
         struct __Visitor #in_place_impl_generics #where_clause {
             place: &#place_life mut #this_type #ty_generics,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
+            lifetime: _serde::#private::PhantomData<&#delife ()>,
         }
 
         #[automatically_derived]
         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::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::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::__private::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>,
             {
@@ -725,7 +725,7 @@ fn deserialize_seq(
                     let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
                     quote!({
                         #wrapper
-                        _serde::__private::Option::map(
+                        _serde::#private::Option::map(
                             _serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)?,
                             |__wrap| __wrap.value)
                     })
@@ -734,8 +734,8 @@ fn deserialize_seq(
             let value_if_none = expr_is_missing_seq(None, index_in_seq, field, cattrs, expecting);
             let assign = quote! {
                 let #var = match #visit {
-                    _serde::__private::Some(__value) => __value,
-                    _serde::__private::None => #value_if_none,
+                    _serde::#private::Some(__value) => __value,
+                    _serde::#private::None => #value_if_none,
                 };
             };
             index_in_seq += 1;
@@ -758,13 +758,13 @@ fn deserialize_seq(
         let this_type = &params.this_type;
         let (_, ty_generics, _) = params.generics.split_for_impl();
         result = quote! {
-            _serde::__private::Into::<#this_type #ty_generics>::into(#result)
+            _serde::#private::Into::<#this_type #ty_generics>::into(#result)
         };
     }
 
     let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
-            let __default: Self::Value = _serde::__private::Default::default();
+            let __default: Self::Value = _serde::#private::Default::default();
         )),
         // If #path returns wrong type, error will be reported here (^^^^^).
         // We attach span of the path to the function so it will be reported
@@ -783,7 +783,7 @@ fn deserialize_seq(
     quote_block! {
         #let_default
         #(#let_values)*
-        _serde::__private::Ok(#result)
+        _serde::#private::Ok(#result)
     }
 }
 
@@ -819,8 +819,8 @@ fn deserialize_seq_in_place(
             let write = match field.attrs.deserialize_with() {
                 None => {
                     quote! {
-                        if let _serde::__private::None = _serde::de::SeqAccess::next_element_seed(&mut __seq,
-                            _serde::__private::de::InPlaceSeed(&mut self.place.#member))?
+                        if let _serde::#private::None = _serde::de::SeqAccess::next_element_seed(&mut __seq,
+                            _serde::#private::de::InPlaceSeed(&mut self.place.#member))?
                         {
                             #value_if_none;
                         }
@@ -831,10 +831,10 @@ fn deserialize_seq_in_place(
                     quote!({
                         #wrapper
                         match _serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)? {
-                            _serde::__private::Some(__wrap) => {
+                            _serde::#private::Some(__wrap) => {
                                 self.place.#member = __wrap.value;
                             }
-                            _serde::__private::None => {
+                            _serde::#private::None => {
                                 #value_if_none;
                             }
                         }
@@ -850,7 +850,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_type #ty_generics = _serde::__private::Default::default();
+            let __default: #this_type #ty_generics = _serde::#private::Default::default();
         )),
         // If #path returns wrong type, error will be reported here (^^^^^).
         // We attach span of the path to the function so it will be reported
@@ -869,7 +869,7 @@ fn deserialize_seq_in_place(
     quote_block! {
         #let_default
         #(#write_values)*
-        _serde::__private::Ok(())
+        _serde::#private::Ok(())
     }
 }
 
@@ -906,18 +906,18 @@ fn deserialize_newtype_struct(
         let this_type = &params.this_type;
         let (_, ty_generics, _) = params.generics.split_for_impl();
         result = quote! {
-            _serde::__private::Into::<#this_type #ty_generics>::into(#result)
+            _serde::#private::Into::<#this_type #ty_generics>::into(#result)
         };
     }
 
     quote! {
         #[inline]
-        fn visit_newtype_struct<__E>(self, #deserializer_var: __E) -> _serde::__private::Result<Self::Value, __E::Error>
+        fn visit_newtype_struct<__E>(self, #deserializer_var: __E) -> _serde::#private::Result<Self::Value, __E::Error>
         where
             __E: _serde::Deserializer<#delife>,
         {
             let __field0: #field_ty = #value;
-            _serde::__private::Ok(#result)
+            _serde::#private::Ok(#result)
         }
     }
 }
@@ -1005,7 +1005,7 @@ fn deserialize_struct(
 
             Some(quote! {
                 #[inline]
-                fn visit_seq<__A>(self, #mut_seq: __A) -> _serde::__private::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>,
                 {
@@ -1028,7 +1028,7 @@ fn deserialize_struct(
             impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Visitor #de_ty_generics #where_clause {
                 type Value = #this_type #ty_generics;
 
-                fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
+                fn deserialize<__D>(self, __deserializer: __D) -> _serde::#private::Result<Self::Value, __D::Error>
                 where
                     __D: _serde::Deserializer<#delife>,
                 {
@@ -1052,8 +1052,8 @@ fn deserialize_struct(
 
     let visitor_expr = quote! {
         __Visitor {
-            marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
-            lifetime: _serde::__private::PhantomData,
+            marker: _serde::#private::PhantomData::<#this_type #ty_generics>,
+            lifetime: _serde::#private::PhantomData,
         }
     };
     let dispatch = match form {
@@ -1085,22 +1085,22 @@ fn deserialize_struct(
 
         #[doc(hidden)]
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
+            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
+            lifetime: _serde::#private::PhantomData<&#delife ()>,
         }
 
         #[automatically_derived]
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
             type Value = #this_type #ty_generics;
 
-            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::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::__private::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>,
             {
@@ -1168,19 +1168,19 @@ fn deserialize_struct_in_place(
         #[doc(hidden)]
         struct __Visitor #in_place_impl_generics #where_clause {
             place: &#place_life mut #this_type #ty_generics,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
+            lifetime: _serde::#private::PhantomData<&#delife ()>,
         }
 
         #[automatically_derived]
         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::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::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_seq<__A>(self, #mut_seq: __A) -> _serde::__private::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>,
             {
@@ -1188,7 +1188,7 @@ fn deserialize_struct_in_place(
             }
 
             #[inline]
-            fn visit_map<__A>(self, mut __map: __A) -> _serde::__private::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>,
             {
@@ -1201,7 +1201,7 @@ fn deserialize_struct_in_place(
 
         _serde::Deserializer::deserialize_struct(__deserializer, #type_name, FIELDS, __Visitor {
             place: __place,
-            lifetime: _serde::__private::PhantomData,
+            lifetime: _serde::#private::PhantomData,
         })
     })
 }
@@ -1250,7 +1250,7 @@ fn prepare_enum_variant_enum(variants: &[Variant]) -> (TokenStream, Stmts) {
         .find(|(_i, variant)| variant.attrs.other())
         .map(|(i, _variant)| {
             let ignore_variant = field_i(i);
-            quote!(_serde::__private::Ok(__Field::#ignore_variant))
+            quote!(_serde::#private::Ok(__Field::#ignore_variant))
         });
 
     let variants_stmt = {
@@ -1322,9 +1322,9 @@ fn deserialize_externally_tagged_enum(
         // all variants have `#[serde(skip_deserializing)]`.
         quote! {
             // FIXME: Once feature(exhaustive_patterns) is stable:
-            // let _serde::__private::Err(__err) = _serde::de::EnumAccess::variant::<__Field>(__data);
-            // _serde::__private::Err(__err)
-            _serde::__private::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 {})
         }
@@ -1341,19 +1341,19 @@ fn deserialize_externally_tagged_enum(
 
         #[doc(hidden)]
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
+            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
+            lifetime: _serde::#private::PhantomData<&#delife ()>,
         }
 
         #[automatically_derived]
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
             type Value = #this_type #ty_generics;
 
-            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::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::__private::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>,
             {
@@ -1368,8 +1368,8 @@ fn deserialize_externally_tagged_enum(
             #type_name,
             VARIANTS,
             __Visitor {
-                marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
-                lifetime: _serde::__private::PhantomData,
+                marker: _serde::#private::PhantomData::<#this_type #ty_generics>,
+                lifetime: _serde::#private::PhantomData,
             },
         )
     }
@@ -1413,8 +1413,8 @@ fn deserialize_internally_tagged_enum(
 
         let (__tag, __content) = _serde::Deserializer::deserialize_any(
             __deserializer,
-            _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting))?;
-        let __deserializer = _serde::__private::de::ContentDeserializer::<__D::Error>::new(__content);
+            _serde::#private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting))?;
+        let __deserializer = _serde::#private::de::ContentDeserializer::<__D::Error>::new(__content);
 
         match __tag {
             #(#variant_arms)*
@@ -1466,9 +1466,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! {
@@ -1479,15 +1479,15 @@ fn deserialize_adjacently_tagged_enum(
     };
 
     let variant_seed = quote! {
-        _serde::__private::de::AdjacentlyTaggedEnumVariantSeed::<__Field> {
+        _serde::#private::de::AdjacentlyTaggedEnumVariantSeed::<__Field> {
             enum_name: #rust_name,
             variants: VARIANTS,
-            fields_enum: _serde::__private::PhantomData
+            fields_enum: _serde::#private::PhantomData
         }
     };
 
     let mut missing_content = quote! {
-        _serde::__private::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
@@ -1500,11 +1500,11 @@ fn deserialize_adjacently_tagged_enum(
 
             let arm = match variant.style {
                 Style::Unit => quote! {
-                    _serde::__private::Ok(#this_value::#variant_ident)
+                    _serde::#private::Ok(#this_value::#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_value::#variant_ident)
                     }
@@ -1543,19 +1543,19 @@ fn deserialize_adjacently_tagged_enum(
         next_key
     } else {
         quote!({
-            let mut __rk : _serde::__private::Option<_serde::__private::de::TagOrContentField> = _serde::__private::None;
-            while let _serde::__private::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 => {
                         let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?;
                         continue;
                     },
-                    _serde::__private::de::TagContentOtherField::Tag => {
-                        __rk = _serde::__private::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::__private::Some(_serde::__private::de::TagOrContentField::Content);
+                    _serde::#private::de::TagContentOtherField::Content => {
+                        __rk = _serde::#private::Some(_serde::#private::de::TagOrContentField::Content);
                         break;
                     }
                 }
@@ -1570,13 +1570,13 @@ fn deserialize_adjacently_tagged_enum(
     // at this point immediately produce an error.
     let visit_remaining_keys = quote! {
         match #next_relevant_key {
-            _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
-                _serde::__private::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::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
-                _serde::__private::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::__private::None => _serde::__private::Ok(__ret),
+            _serde::#private::None => _serde::#private::Ok(__ret),
         }
     };
 
@@ -1603,15 +1603,15 @@ fn deserialize_adjacently_tagged_enum(
         #[doc(hidden)]
         struct __Seed #de_impl_generics #where_clause {
             field: __Field,
-            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
+            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
+            lifetime: _serde::#private::PhantomData<&#delife ()>,
         }
 
         #[automatically_derived]
         impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Seed #de_ty_generics #where_clause {
             type Value = #this_type #ty_generics;
 
-            fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
+            fn deserialize<__D>(self, __deserializer: __D) -> _serde::#private::Result<Self::Value, __D::Error>
             where
                 __D: _serde::Deserializer<#delife>,
             {
@@ -1623,103 +1623,103 @@ fn deserialize_adjacently_tagged_enum(
 
         #[doc(hidden)]
         struct __Visitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
+            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
+            lifetime: _serde::#private::PhantomData<&#delife ()>,
         }
 
         #[automatically_derived]
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
             type Value = #this_type #ty_generics;
 
-            fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-                _serde::__private::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::__private::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::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
+                    _serde::#private::Some(_serde::#private::de::TagOrContentField::Tag) => {
                         // Parse the tag.
                         let __field = #variant_from_map;
                         // Visit the second key.
                         match #next_relevant_key {
                             // Second key is a duplicate of the tag.
-                            _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
-                                _serde::__private::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::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
+                            _serde::#private::Some(_serde::#private::de::TagOrContentField::Content) => {
                                 let __ret = _serde::de::MapAccess::next_value_seed(&mut __map,
                                     __Seed {
                                         field: __field,
-                                        marker: _serde::__private::PhantomData,
-                                        lifetime: _serde::__private::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::__private::None => #missing_content
+                            _serde::#private::None => #missing_content
                         }
                     }
                     // First key is the content.
-                    _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
+                    _serde::#private::Some(_serde::#private::de::TagOrContentField::Content) => {
                         // Buffer up the content.
-                        let __content = _serde::de::MapAccess::next_value_seed(&mut __map, _serde::__private::de::ContentVisitor::new())?;
+                        let __content = _serde::de::MapAccess::next_value_seed(&mut __map, _serde::#private::de::ContentVisitor::new())?;
                         // Visit the second key.
                         match #next_relevant_key {
                             // Second key is the tag.
-                            _serde::__private::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::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
-                                _serde::__private::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::__private::None => {
-                                _serde::__private::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::__private::None => {
-                        _serde::__private::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::__private::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 _serde::de::SeqAccess::next_element(&mut __seq)? {
-                    _serde::__private::Some(__field) => {
+                    _serde::#private::Some(__field) => {
                         // Visit the second element - the content.
                         match _serde::de::SeqAccess::next_element_seed(
                             &mut __seq,
                             __Seed {
                                 field: __field,
-                                marker: _serde::__private::PhantomData,
-                                lifetime: _serde::__private::PhantomData,
+                                marker: _serde::#private::PhantomData,
+                                lifetime: _serde::#private::PhantomData,
                             },
                         )? {
-                            _serde::__private::Some(__ret) => _serde::__private::Ok(__ret),
+                            _serde::#private::Some(__ret) => _serde::#private::Ok(__ret),
                             // There is no second element.
-                            _serde::__private::None => {
-                                _serde::__private::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::__private::None => {
-                        _serde::__private::Err(_serde::de::Error::invalid_length(0, &self))
+                    _serde::#private::None => {
+                        _serde::#private::Err(_serde::de::Error::invalid_length(0, &self))
                     }
                 }
             }
@@ -1732,8 +1732,8 @@ fn deserialize_adjacently_tagged_enum(
             #type_name,
             FIELDS,
             __Visitor {
-                marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
-                lifetime: _serde::__private::PhantomData,
+                marker: _serde::#private::PhantomData::<#this_type #ty_generics>,
+                lifetime: _serde::#private::PhantomData,
             },
         )
     }
@@ -1782,25 +1782,26 @@ fn deserialize_untagged_enum_after(
     // need to provide the error type.
     let first_attempt = first_attempt.map(|expr| {
         quote! {
-            if let _serde::__private::Result::<_, __D::Error>::Ok(__ok) = (|| #expr)() {
-                return _serde::__private::Ok(__ok);
+            if let _serde::#private::Result::<_, __D::Error>::Ok(__ok) = (|| #expr)() {
+                return _serde::#private::Ok(__ok);
             }
         }
     });
 
+    let private2 = private;
     quote_block! {
-        let __content = _serde::de::DeserializeSeed::deserialize(_serde::__private::de::ContentVisitor::new(), __deserializer)?;
-        let __deserializer = _serde::__private::de::ContentRefDeserializer::<__D::Error>::new(&__content);
+        let __content = _serde::de::DeserializeSeed::deserialize(_serde::#private::de::ContentVisitor::new(), __deserializer)?;
+        let __deserializer = _serde::#private::de::ContentRefDeserializer::<__D::Error>::new(&__content);
 
         #first_attempt
 
         #(
-            if let _serde::__private::Ok(__ok) = #attempts {
-                return _serde::__private::Ok(__ok);
+            if let _serde::#private2::Ok(__ok) = #attempts {
+                return _serde::#private2::Ok(__ok);
             }
         )*
 
-        _serde::__private::Err(_serde::de::Error::custom(#fallthrough_msg))
+        _serde::#private::Err(_serde::de::Error::custom(#fallthrough_msg))
     }
 }
 
@@ -1813,7 +1814,7 @@ fn deserialize_externally_tagged_variant(
         let (wrapper, wrapper_ty, unwrap_fn) = wrap_deserialize_variant_with(params, variant, path);
         return quote_block! {
             #wrapper
-            _serde::__private::Result::map(
+            _serde::#private::Result::map(
                 _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant), #unwrap_fn)
         };
     }
@@ -1825,7 +1826,7 @@ fn deserialize_externally_tagged_variant(
             let this_value = &params.this_value;
             quote_block! {
                 _serde::de::VariantAccess::unit_variant(__variant)?;
-                _serde::__private::Ok(#this_value::#variant_ident)
+                _serde::#private::Ok(#this_value::#variant_ident)
             }
         }
         Style::Newtype => deserialize_externally_tagged_newtype_variant(
@@ -1873,8 +1874,8 @@ fn deserialize_internally_tagged_variant(
                 quote!((#default))
             });
             quote_block! {
-                _serde::Deserializer::deserialize_any(#deserializer, _serde::__private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name))?;
-                _serde::__private::Ok(#this_value::#variant_ident #default)
+                _serde::Deserializer::deserialize_any(#deserializer, _serde::#private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name))?;
+                _serde::#private::Ok(#this_value::#variant_ident #default)
             }
         }
         Style::Newtype => deserialize_untagged_newtype_variant(
@@ -1902,7 +1903,7 @@ fn deserialize_untagged_variant(
     if let Some(path) = variant.attrs.deserialize_with() {
         let unwrap_fn = unwrap_to_variant_closure(params, variant, false);
         return quote_block! {
-            _serde::__private::Result::map(#path(#deserializer), #unwrap_fn)
+            _serde::#private::Result::map(#path(#deserializer), #unwrap_fn)
         };
     }
 
@@ -1920,10 +1921,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::__private::Ok(()) => _serde::__private::Ok(#this_value::#variant_ident #default),
-                    _serde::__private::Err(__err) => _serde::__private::Err(__err),
+                    _serde::#private::Ok(()) => _serde::#private::Ok(#this_value::#variant_ident #default),
+                    _serde::#private::Err(__err) => _serde::#private::Err(__err),
                 }
             }
         }
@@ -1960,7 +1961,7 @@ fn deserialize_externally_tagged_newtype_variant(
         let default = Expr(expr_is_missing(field, cattrs));
         return quote_block! {
             _serde::de::VariantAccess::unit_variant(__variant)?;
-            _serde::__private::Ok(#this_value::#variant_ident(#default))
+            _serde::#private::Ok(#this_value::#variant_ident(#default))
         };
     }
 
@@ -1971,14 +1972,14 @@ fn deserialize_externally_tagged_newtype_variant(
             let func =
                 quote_spanned!(span=> _serde::de::VariantAccess::newtype_variant::<#field_ty>);
             quote_expr! {
-                _serde::__private::Result::map(#func(__variant), #this_value::#variant_ident)
+                _serde::#private::Result::map(#func(__variant), #this_value::#variant_ident)
             }
         }
         Some(path) => {
             let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
             quote_block! {
                 #wrapper
-                _serde::__private::Result::map(
+                _serde::#private::Result::map(
                     _serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant),
                     |__wrapper| #this_value::#variant_ident(__wrapper.value))
             }
@@ -1999,13 +2000,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::__private::Result::map(#func(#deserializer), #this_value::#variant_ident)
+                _serde::#private::Result::map(#func(#deserializer), #this_value::#variant_ident)
             }
         }
         Some(path) => {
             quote_block! {
-                let __value: _serde::__private::Result<#field_ty, _> = #path(#deserializer);
-                _serde::__private::Result::map(__value, #this_value::#variant_ident)
+                let __value: _serde::#private::Result<#field_ty, _> = #path(#deserializer);
+                _serde::#private::Result::map(__value, #this_value::#variant_ident)
             }
         }
     }
@@ -2066,7 +2067,7 @@ fn deserialize_generated_identifier(
         #[automatically_derived]
         impl<'de> _serde::Deserialize<'de> for __Field #lifetime {
             #[inline]
-            fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+            fn deserialize<__D>(__deserializer: __D) -> _serde::#private::Result<Self, __D::Error>
             where
                 __D: _serde::Deserializer<'de>,
             {
@@ -2084,14 +2085,14 @@ fn deserialize_field_identifier(
     has_flatten: bool,
 ) -> Stmts {
     let (ignore_variant, fallthrough) = if has_flatten {
-        let ignore_variant = quote!(__other(_serde::__private::de::Content<'de>),);
-        let fallthrough = quote!(_serde::__private::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 cattrs.deny_unknown_fields() {
         (None, None)
     } else {
         let ignore_variant = quote!(__ignore,);
-        let fallthrough = quote!(_serde::__private::Ok(__Field::__ignore));
+        let fallthrough = quote!(_serde::#private::Ok(__Field::__ignore));
         (Some(ignore_variant), Some(fallthrough))
     };
 
@@ -2127,15 +2128,15 @@ fn deserialize_custom_identifier(
             // last variant (checked in `check_identifier`), so all preceding
             // are ordinary variants.
             let ordinary = &variants[..variants.len() - 1];
-            let fallthrough = quote!(_serde::__private::Ok(#this_value::#last_ident));
+            let fallthrough = quote!(_serde::#private::Ok(#this_value::#last_ident));
             (ordinary, Some(fallthrough), None)
         } else if let Style::Newtype = last.style {
             let ordinary = &variants[..variants.len() - 1];
             let fallthrough = |value| {
                 quote! {
-                    _serde::__private::Result::map(
+                    _serde::#private::Result::map(
                         _serde::Deserialize::deserialize(
-                            _serde::__private::de::IdentifierDeserializer::from(#value)
+                            _serde::#private::de::IdentifierDeserializer::from(#value)
                         ),
                         #this_value::#last_ident)
                 }
@@ -2143,7 +2144,7 @@ fn deserialize_custom_identifier(
             (
                 ordinary,
                 Some(fallthrough(quote!(__value))),
-                Some(fallthrough(quote!(_serde::__private::de::Borrowed(
+                Some(fallthrough(quote!(_serde::#private::de::Borrowed(
                     __value
                 )))),
             )
@@ -2198,8 +2199,8 @@ fn deserialize_custom_identifier(
 
         #[doc(hidden)]
         struct __FieldVisitor #de_impl_generics #where_clause {
-            marker: _serde::__private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
+            marker: _serde::#private::PhantomData<#this_type #ty_generics>,
+            lifetime: _serde::#private::PhantomData<&#delife ()>,
         }
 
         #[automatically_derived]
@@ -2210,8 +2211,8 @@ fn deserialize_custom_identifier(
         }
 
         let __visitor = __FieldVisitor {
-            marker: _serde::__private::PhantomData::<#this_type #ty_generics>,
-            lifetime: _serde::__private::PhantomData,
+            marker: _serde::#private::PhantomData::<#this_type #ty_generics>,
+            lifetime: _serde::#private::PhantomData,
         };
         _serde::Deserializer::deserialize_identifier(__deserializer, __visitor)
     }
@@ -2229,10 +2230,11 @@ fn deserialize_identifier(
     let str_mapping = deserialized_fields.iter().map(|field| {
         let ident = &field.ident;
         let aliases = field.aliases;
+        let private2 = private;
         // `aliases` also contains a main name
         quote! {
             #(
-                #aliases => _serde::__private::Ok(#this_value::#ident),
+                #aliases => _serde::#private2::Ok(#this_value::#ident),
             )*
         }
     });
@@ -2243,9 +2245,10 @@ fn deserialize_identifier(
             .aliases
             .iter()
             .map(|alias| Literal::byte_string(alias.value.as_bytes()));
+        let private2 = private;
         quote! {
             #(
-                #aliases => _serde::__private::Ok(#this_value::#ident),
+                #aliases => _serde::#private2::Ok(#this_value::#ident),
             )*
         }
     });
@@ -2260,7 +2263,7 @@ fn deserialize_identifier(
         None
     } else {
         Some(quote! {
-            let __value = &_serde::__private::from_utf8_lossy(__value);
+            let __value = &_serde::#private::from_utf8_lossy(__value);
         })
     };
 
@@ -2272,16 +2275,16 @@ fn deserialize_identifier(
     ) = if collect_other_fields {
         (
             Some(quote! {
-                let __value = _serde::__private::de::Content::String(_serde::__private::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 {
@@ -2293,114 +2296,114 @@ fn deserialize_identifier(
         fallthrough
     } else if is_variant {
         fallthrough_arm_tokens = quote! {
-            _serde::__private::Err(_serde::de::Error::unknown_variant(__value, VARIANTS))
+            _serde::#private::Err(_serde::de::Error::unknown_variant(__value, VARIANTS))
         };
         &fallthrough_arm_tokens
     } else {
         fallthrough_arm_tokens = quote! {
-            _serde::__private::Err(_serde::de::Error::unknown_field(__value, FIELDS))
+            _serde::#private::Err(_serde::de::Error::unknown_field(__value, FIELDS))
         };
         &fallthrough_arm_tokens
     };
 
     let visit_other = if collect_other_fields {
         quote! {
-            fn visit_bool<__E>(self, __value: bool) -> _serde::__private::Result<Self::Value, __E>
+            fn visit_bool<__E>(self, __value: bool) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::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::__private::Result<Self::Value, __E>
+            fn visit_i8<__E>(self, __value: i8) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::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::__private::Result<Self::Value, __E>
+            fn visit_i16<__E>(self, __value: i16) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::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::__private::Result<Self::Value, __E>
+            fn visit_i32<__E>(self, __value: i32) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::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::__private::Result<Self::Value, __E>
+            fn visit_i64<__E>(self, __value: i64) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::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::__private::Result<Self::Value, __E>
+            fn visit_u8<__E>(self, __value: u8) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::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::__private::Result<Self::Value, __E>
+            fn visit_u16<__E>(self, __value: u16) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::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::__private::Result<Self::Value, __E>
+            fn visit_u32<__E>(self, __value: u32) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::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::__private::Result<Self::Value, __E>
+            fn visit_u64<__E>(self, __value: u64) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::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::__private::Result<Self::Value, __E>
+            fn visit_f32<__E>(self, __value: f32) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::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::__private::Result<Self::Value, __E>
+            fn visit_f64<__E>(self, __value: f64) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::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::__private::Result<Self::Value, __E>
+            fn visit_char<__E>(self, __value: char) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::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::__private::Result<Self::Value, __E>
+            fn visit_unit<__E>(self) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
-                _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::Unit))
+                _serde::#private::Ok(__Field::__other(_serde::#private::de::Content::Unit))
             }
         }
     } else {
         let u64_mapping = deserialized_fields.iter().enumerate().map(|(i, field)| {
             let i = i as u64;
             let ident = &field.ident;
-            quote!(#i => _serde::__private::Ok(#this_value::#ident))
+            quote!(#i => _serde::#private::Ok(#this_value::#ident))
         });
 
         let u64_fallthrough_arm_tokens;
@@ -2414,7 +2417,7 @@ fn deserialize_identifier(
                 deserialized_fields.len(),
             );
             u64_fallthrough_arm_tokens = quote! {
-                _serde::__private::Err(_serde::de::Error::invalid_value(
+                _serde::#private::Err(_serde::de::Error::invalid_value(
                     _serde::de::Unexpected::Unsigned(__value),
                     &#fallthrough_msg,
                 ))
@@ -2423,7 +2426,7 @@ fn deserialize_identifier(
         };
 
         quote! {
-            fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+            fn visit_u64<__E>(self, __value: u64) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
@@ -2440,7 +2443,7 @@ fn deserialize_identifier(
         let bytes_mapping = bytes_mapping.clone();
         let fallthrough_borrowed_arm = fallthrough_borrowed.as_ref().unwrap_or(fallthrough_arm);
         Some(quote! {
-            fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::__private::Result<Self::Value, __E>
+            fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
@@ -2453,7 +2456,7 @@ fn deserialize_identifier(
                 }
             }
 
-            fn visit_borrowed_bytes<__E>(self, __value: &'de [u8]) -> _serde::__private::Result<Self::Value, __E>
+            fn visit_borrowed_bytes<__E>(self, __value: &'de [u8]) -> _serde::#private::Result<Self::Value, __E>
             where
                 __E: _serde::de::Error,
             {
@@ -2472,13 +2475,13 @@ fn deserialize_identifier(
     };
 
     quote_block! {
-        fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
-            _serde::__private::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::__private::Result<Self::Value, __E>
+        fn visit_str<__E>(self, __value: &str) -> _serde::#private::Result<Self::Value, __E>
         where
             __E: _serde::de::Error,
         {
@@ -2491,7 +2494,7 @@ fn deserialize_identifier(
             }
         }
 
-        fn visit_bytes<__E>(self, __value: &[u8]) -> _serde::__private::Result<Self::Value, __E>
+        fn visit_bytes<__E>(self, __value: &[u8]) -> _serde::#private::Result<Self::Value, __E>
         where
             __E: _serde::de::Error,
         {
@@ -2530,16 +2533,16 @@ fn deserialize_map(
         .map(|(field, name)| {
             let field_ty = field.ty;
             quote! {
-                let mut #name: _serde::__private::Option<#field_ty> = _serde::__private::None;
+                let mut #name: _serde::#private::Option<#field_ty> = _serde::#private::None;
             }
         });
 
     // Collect contents for flatten fields into a buffer
     let let_collect = if has_flatten {
         Some(quote! {
-            let mut __collect = _serde::__private::Vec::<_serde::__private::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 {
@@ -2568,9 +2571,9 @@ fn deserialize_map(
                     quote!({
                         #wrapper
                         match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
-                            _serde::__private::Ok(__wrapper) => __wrapper.value,
-                            _serde::__private::Err(__err) => {
-                                return _serde::__private::Err(__err);
+                            _serde::#private::Ok(__wrapper) => __wrapper.value,
+                            _serde::#private::Err(__err) => {
+                                return _serde::#private::Err(__err);
                             }
                         }
                     })
@@ -2578,10 +2581,10 @@ fn deserialize_map(
             };
             quote! {
                 __Field::#name => {
-                    if _serde::__private::Option::is_some(&#name) {
-                        return _serde::__private::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::__private::Some(#visit);
+                    #name = _serde::#private::Some(#visit);
                 }
             }
         });
@@ -2590,9 +2593,9 @@ fn deserialize_map(
     let ignored_arm = if has_flatten {
         Some(quote! {
             __Field::__other(__name) => {
-                __collect.push(_serde::__private::Some((
+                __collect.push(_serde::#private::Some((
                     __name,
-                    _serde::de::MapAccess::next_value_seed(&mut __map, _serde::__private::de::ContentVisitor::new())?)));
+                    _serde::de::MapAccess::next_value_seed(&mut __map, _serde::#private::de::ContentVisitor::new())?)));
             }
         })
     } else if cattrs.deny_unknown_fields() {
@@ -2607,14 +2610,14 @@ fn deserialize_map(
     let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
         quote! {
             // FIXME: Once feature(exhaustive_patterns) is stable:
-            // let _serde::__private::None::<__Field> = _serde::de::MapAccess::next_key(&mut __map)?;
-            _serde::__private::Option::map(
+            // let _serde::#private::None::<__Field> = _serde::de::MapAccess::next_key(&mut __map)?;
+            _serde::#private::Option::map(
                 _serde::de::MapAccess::next_key::<__Field>(&mut __map)?,
                 |__impossible| match __impossible {});
         }
     } else {
         quote! {
-            while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
+            while let _serde::#private::Some(__key) = _serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                 match __key {
                     #(#value_arms)*
                     #ignored_arm
@@ -2631,8 +2634,8 @@ fn deserialize_map(
 
             quote! {
                 let #name = match #name {
-                    _serde::__private::Some(#name) => #name,
-                    _serde::__private::None => #missing_expr
+                    _serde::#private::Some(#name) => #name,
+                    _serde::#private::None => #missing_expr
                 };
             }
         });
@@ -2651,22 +2654,22 @@ fn deserialize_map(
             };
             quote! {
                 let #name: #field_ty = #func(
-                    _serde::__private::de::FlatMapDeserializer(
+                    _serde::#private::de::FlatMapDeserializer(
                         &mut __collect,
-                        _serde::__private::PhantomData))?;
+                        _serde::#private::PhantomData))?;
             }
         });
 
     let collected_deny_unknown_fields = if has_flatten && cattrs.deny_unknown_fields() {
         Some(quote! {
-            if let _serde::__private::Some(_serde::__private::Some((__key, _))) =
-                __collect.into_iter().filter(_serde::__private::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::__private::Some(__key) = _serde::__private::de::content_as_str(&__key) {
-                    return _serde::__private::Err(
+                if let _serde::#private::Some(__key) = _serde::#private::de::content_as_str(&__key) {
+                    return _serde::#private::Err(
                         _serde::de::Error::custom(format_args!("unknown field `{}`", &__key)));
                 } else {
-                    return _serde::__private::Err(
+                    return _serde::#private::Err(
                         _serde::de::Error::custom(format_args!("unexpected map key")));
                 }
             }
@@ -2687,7 +2690,7 @@ fn deserialize_map(
 
     let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
-            let __default: Self::Value = _serde::__private::Default::default();
+            let __default: Self::Value = _serde::#private::Default::default();
         )),
         // If #path returns wrong type, error will be reported here (^^^^^).
         // We attach span of the path to the function so it will be reported
@@ -2708,7 +2711,7 @@ fn deserialize_map(
         let this_type = &params.this_type;
         let (_, ty_generics, _) = params.generics.split_for_impl();
         result = quote! {
-            _serde::__private::Into::<#this_type #ty_generics>::into(#result)
+            _serde::#private::Into::<#this_type #ty_generics>::into(#result)
         };
     }
 
@@ -2727,7 +2730,7 @@ fn deserialize_map(
 
         #collected_deny_unknown_fields
 
-        _serde::__private::Ok(#result)
+        _serde::#private::Ok(#result)
     }
 }
 
@@ -2771,7 +2774,7 @@ fn deserialize_map_in_place(
             let visit = match field.attrs.deserialize_with() {
                 None => {
                     quote! {
-                        _serde::de::MapAccess::next_value_seed(&mut __map, _serde::__private::de::InPlaceSeed(&mut self.place.#member))?
+                        _serde::de::MapAccess::next_value_seed(&mut __map, _serde::#private::de::InPlaceSeed(&mut self.place.#member))?
                     }
                 }
                 Some(path) => {
@@ -2779,9 +2782,9 @@ fn deserialize_map_in_place(
                     quote!({
                         #wrapper
                         self.place.#member = match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
-                            _serde::__private::Ok(__wrapper) => __wrapper.value,
-                            _serde::__private::Err(__err) => {
-                                return _serde::__private::Err(__err);
+                            _serde::#private::Ok(__wrapper) => __wrapper.value,
+                            _serde::#private::Err(__err) => {
+                                return _serde::#private::Err(__err);
                             }
                         };
                     })
@@ -2790,7 +2793,7 @@ fn deserialize_map_in_place(
             quote! {
                 __Field::#name => {
                     if #name {
-                        return _serde::__private::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;
@@ -2812,14 +2815,14 @@ fn deserialize_map_in_place(
     let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
         quote! {
             // FIXME: Once feature(exhaustive_patterns) is stable:
-            // let _serde::__private::None::<__Field> = _serde::de::MapAccess::next_key(&mut __map)?;
-            _serde::__private::Option::map(
+            // let _serde::#private::None::<__Field> = _serde::de::MapAccess::next_key(&mut __map)?;
+            _serde::#private::Option::map(
                 _serde::de::MapAccess::next_key::<__Field>(&mut __map)?,
                 |__impossible| match __impossible {});
         }
     } else {
         quote! {
-            while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
+            while let _serde::#private::Some(__key) = _serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
                 match __key {
                     #(#value_arms_from)*
                     #ignored_arm
@@ -2861,7 +2864,7 @@ fn deserialize_map_in_place(
 
     let let_default = match cattrs.default() {
         attr::Default::Default => Some(quote!(
-            let __default: #this_type #ty_generics = _serde::__private::Default::default();
+            let __default: #this_type #ty_generics = _serde::#private::Default::default();
         )),
         // If #path returns wrong type, error will be reported here (^^^^^).
         // We attach span of the path to the function so it will be reported
@@ -2886,7 +2889,7 @@ fn deserialize_map_in_place(
 
         #(#check_flags)*
 
-        _serde::__private::Ok(())
+        _serde::#private::Ok(())
     }
 }
 
@@ -2918,20 +2921,20 @@ fn wrap_deserialize_with(
         #[doc(hidden)]
         struct __DeserializeWith #de_impl_generics #where_clause {
             value: #value_ty,
-            phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
-            lifetime: _serde::__private::PhantomData<&#delife ()>,
+            phantom: _serde::#private::PhantomData<#this_type #ty_generics>,
+            lifetime: _serde::#private::PhantomData<&#delife ()>,
         }
 
         #[automatically_derived]
         impl #de_impl_generics _serde::Deserialize<#delife> for __DeserializeWith #de_ty_generics #where_clause {
-            fn deserialize<__D>(#deserializer_var: __D) -> _serde::__private::Result<Self, __D::Error>
+            fn deserialize<__D>(#deserializer_var: __D) -> _serde::#private::Result<Self, __D::Error>
             where
                 __D: _serde::Deserializer<#delife>,
             {
-                _serde::__private::Ok(__DeserializeWith {
+                _serde::#private::Ok(__DeserializeWith {
                     value: #value,
-                    phantom: _serde::__private::PhantomData,
-                    lifetime: _serde::__private::PhantomData,
+                    phantom: _serde::#private::PhantomData,
+                    lifetime: _serde::#private::PhantomData,
                 })
             }
         }
@@ -3016,7 +3019,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::__private::Default::default);
+            let func = quote_spanned!(span=> _serde::#private::Default::default);
             return quote_expr!(#func());
         }
         attr::Default::Path(path) => {
@@ -3041,14 +3044,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! {
                 #func(#name)?
             }
         }
         Some(_) => {
             quote_expr! {
-                return _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#name))
+                return _serde::#private::Err(<__A::Error as _serde::de::Error>::missing_field(#name))
             }
         }
     }
@@ -3064,7 +3067,7 @@ fn expr_is_missing_seq(
     match field.attrs.default() {
         attr::Default::Default => {
             let span = field.original.span();
-            return quote_spanned!(span=> #assign_to _serde::__private::Default::default());
+            return quote_spanned!(span=> #assign_to _serde::#private::Default::default());
         }
         attr::Default::Path(path) => {
             // If #path returns wrong type, error will be reported here (^^^^^).
@@ -3082,7 +3085,7 @@ fn expr_is_missing_seq(
             quote!(#assign_to __default.#member)
         }
         attr::Default::None => quote!(
-            return _serde::__private::Err(_serde::de::Error::invalid_length(#index, &#expecting))
+            return _serde::#private::Err(_serde::de::Error::invalid_length(#index, &#expecting))
         ),
     }
 }
diff --git a/serde_derive/src/internals/ast.rs b/serde_derive/src/internals/ast.rs
index 3293823a7..5a760c657 100644
--- a/serde_derive/src/internals/ast.rs
+++ b/serde_derive/src/internals/ast.rs
@@ -1,6 +1,7 @@
 //! A Serde ast, parsed from the Syn ast and ready to generate Rust code.
 
 use crate::internals::{attr, check, Ctxt, Derive};
+use proc_macro2::Ident;
 use syn::punctuated::Punctuated;
 use syn::Token;
 
@@ -62,13 +63,17 @@ impl<'a> Container<'a> {
         cx: &Ctxt,
         item: &'a syn::DeriveInput,
         derive: Derive,
+        private: &Ident,
     ) -> Option<Container<'a>> {
         let attrs = attr::Container::from_ast(cx, item);
 
         let mut data = match &item.data {
-            syn::Data::Enum(data) => Data::Enum(enum_from_ast(cx, &data.variants, attrs.default())),
+            syn::Data::Enum(data) => {
+                Data::Enum(enum_from_ast(cx, &data.variants, attrs.default(), private))
+            }
             syn::Data::Struct(data) => {
-                let (style, fields) = struct_from_ast(cx, &data.fields, None, attrs.default());
+                let (style, fields) =
+                    struct_from_ast(cx, &data.fields, None, attrs.default(), private);
                 Data::Struct(style, fields)
             }
             syn::Data::Union(_) => {
@@ -129,13 +134,19 @@ fn enum_from_ast<'a>(
     cx: &Ctxt,
     variants: &'a Punctuated<syn::Variant, Token![,]>,
     container_default: &attr::Default,
+    private: &Ident,
 ) -> Vec<Variant<'a>> {
     let variants: Vec<Variant> = variants
         .iter()
         .map(|variant| {
             let attrs = attr::Variant::from_ast(cx, variant);
-            let (style, fields) =
-                struct_from_ast(cx, &variant.fields, Some(&attrs), container_default);
+            let (style, fields) = struct_from_ast(
+                cx,
+                &variant.fields,
+                Some(&attrs),
+                container_default,
+                private,
+            );
             Variant {
                 ident: variant.ident.clone(),
                 attrs,
@@ -165,19 +176,20 @@ fn struct_from_ast<'a>(
     fields: &'a syn::Fields,
     attrs: Option<&attr::Variant>,
     container_default: &attr::Default,
+    private: &Ident,
 ) -> (Style, Vec<Field<'a>>) {
     match fields {
         syn::Fields::Named(fields) => (
             Style::Struct,
-            fields_from_ast(cx, &fields.named, attrs, container_default),
+            fields_from_ast(cx, &fields.named, attrs, container_default, private),
         ),
         syn::Fields::Unnamed(fields) if fields.unnamed.len() == 1 => (
             Style::Newtype,
-            fields_from_ast(cx, &fields.unnamed, attrs, container_default),
+            fields_from_ast(cx, &fields.unnamed, attrs, container_default, private),
         ),
         syn::Fields::Unnamed(fields) => (
             Style::Tuple,
-            fields_from_ast(cx, &fields.unnamed, attrs, container_default),
+            fields_from_ast(cx, &fields.unnamed, attrs, container_default, private),
         ),
         syn::Fields::Unit => (Style::Unit, Vec::new()),
     }
@@ -188,6 +200,7 @@ fn fields_from_ast<'a>(
     fields: &'a Punctuated<syn::Field, Token![,]>,
     attrs: Option<&attr::Variant>,
     container_default: &attr::Default,
+    private: &Ident,
 ) -> Vec<Field<'a>> {
     fields
         .iter()
@@ -197,7 +210,7 @@ fn fields_from_ast<'a>(
                 Some(ident) => syn::Member::Named(ident.clone()),
                 None => syn::Member::Unnamed(i.into()),
             },
-            attrs: attr::Field::from_ast(cx, i, field, attrs, container_default),
+            attrs: attr::Field::from_ast(cx, i, field, attrs, container_default, private),
             ty: &field.ty,
             original: field,
         })
diff --git a/serde_derive/src/internals/attr.rs b/serde_derive/src/internals/attr.rs
index 6d846ed01..0f9a9ff9e 100644
--- a/serde_derive/src/internals/attr.rs
+++ b/serde_derive/src/internals/attr.rs
@@ -1024,6 +1024,7 @@ impl Field {
         field: &syn::Field,
         attrs: Option<&Variant>,
         container_default: &Default,
+        private: &Ident,
     ) -> Self {
         let mut ser_name = Attr::none(cx, RENAME);
         let mut de_name = Attr::none(cx, RENAME);
@@ -1217,7 +1218,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(private.clone().into());
                 path.segments.push(Ident::new("de", span).into());
                 path.segments
                     .push(Ident::new("borrow_cow_str", span).into());
@@ -1234,7 +1235,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(private.clone().into());
                 path.segments.push(Ident::new("de", span).into());
                 path.segments
                     .push(Ident::new("borrow_cow_bytes", span).into());
diff --git a/serde_derive/src/lib.rs b/serde_derive/src/lib.rs
index 921eab996..b0e1ad2f2 100644
--- a/serde_derive/src/lib.rs
+++ b/serde_derive/src/lib.rs
@@ -75,6 +75,8 @@ extern crate proc_macro;
 mod internals;
 
 use proc_macro::TokenStream;
+use proc_macro2::{Ident, Span};
+use quote::{ToTokens, TokenStreamExt as _};
 use syn::parse_macro_input;
 use syn::DeriveInput;
 
@@ -89,6 +91,24 @@ mod pretend;
 mod ser;
 mod this;
 
+#[allow(non_camel_case_types)]
+struct private;
+
+impl private {
+    fn ident(&self) -> Ident {
+        Ident::new(
+            concat!("__private", env!("CARGO_PKG_VERSION_PATCH")),
+            Span::call_site(),
+        )
+    }
+}
+
+impl ToTokens for private {
+    fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+        tokens.append(self.ident());
+    }
+}
+
 #[proc_macro_derive(Serialize, attributes(serde))]
 pub fn derive_serialize(input: TokenStream) -> TokenStream {
     let mut input = parse_macro_input!(input as DeriveInput);
diff --git a/serde_derive/src/pretend.rs b/serde_derive/src/pretend.rs
index 2c9e77936..cfa1a87d1 100644
--- a/serde_derive/src/pretend.rs
+++ b/serde_derive/src/pretend.rs
@@ -1,4 +1,5 @@
 use crate::internals::ast::{Container, Data, Field, Style, Variant};
+use crate::private;
 use proc_macro2::TokenStream;
 use quote::{format_ident, quote};
 
@@ -83,8 +84,8 @@ fn pretend_fields_used_struct(cont: &Container, fields: &[Field]) -> TokenStream
     let placeholders = (0usize..).map(|i| format_ident!("__v{}", i));
 
     quote! {
-        match _serde::__private::None::<&#type_ident #ty_generics> {
-            _serde::__private::Some(#type_ident { #(#members: #placeholders),* }) => {}
+        match _serde::#private::None::<&#type_ident #ty_generics> {
+            _serde::#private::Some(#type_ident { #(#members: #placeholders),* }) => {}
             _ => {}
         }
     }
@@ -96,11 +97,12 @@ fn pretend_fields_used_struct_packed(cont: &Container, fields: &[Field]) -> Toke
 
     let members = fields.iter().map(|field| &field.member).collect::<Vec<_>>();
 
+    let private2 = private;
     quote! {
-        match _serde::__private::None::<&#type_ident #ty_generics> {
-            _serde::__private::Some(__v @ #type_ident { #(#members: _),* }) => {
+        match _serde::#private::None::<&#type_ident #ty_generics> {
+            _serde::#private::Some(__v @ #type_ident { #(#members: _),* }) => {
                 #(
-                    let _ = _serde::__private::ptr::addr_of!(__v.#members);
+                    let _ = _serde::#private2::ptr::addr_of!(__v.#members);
                 )*
             }
             _ => {}
@@ -125,10 +127,11 @@ fn pretend_fields_used_enum(cont: &Container, variants: &[Variant]) -> TokenStre
         })
         .collect::<Vec<_>>();
 
+    let private2 = private;
     quote! {
-        match _serde::__private::None::<&#type_ident #ty_generics> {
+        match _serde::#private::None::<&#type_ident #ty_generics> {
             #(
-                _serde::__private::Some(#patterns) => {}
+                _serde::#private2::Some(#patterns) => {}
             )*
             _ => {}
         }
@@ -172,8 +175,8 @@ fn pretend_variants_used(cont: &Container) -> TokenStream {
         };
 
         quote! {
-            match _serde::__private::None {
-                _serde::__private::Some((#(#placeholders,)*)) => {
+            match _serde::#private::None {
+                _serde::#private::Some((#(#placeholders,)*)) => {
                     let _ = #type_ident::#variant_ident #turbofish #pat;
                 }
                 _ => {}
diff --git a/serde_derive/src/ser.rs b/serde_derive/src/ser.rs
index 02c027c36..778c8ceb3 100644
--- a/serde_derive/src/ser.rs
+++ b/serde_derive/src/ser.rs
@@ -2,7 +2,7 @@ use crate::fragment::{Fragment, Match, Stmts};
 use crate::internals::ast::{Container, Data, Field, Style, Variant};
 use crate::internals::name::Name;
 use crate::internals::{attr, replace_receiver, Ctxt, Derive};
-use crate::{bound, dummy, pretend, this};
+use crate::{bound, dummy, pretend, private, this};
 use proc_macro2::{Span, TokenStream};
 use quote::{quote, quote_spanned};
 use syn::spanned::Spanned;
@@ -12,7 +12,7 @@ pub fn expand_derive_serialize(input: &mut syn::DeriveInput) -> syn::Result<Toke
     replace_receiver(input);
 
     let ctxt = Ctxt::new();
-    let cont = match Container::from_ast(&ctxt, input, Derive::Serialize) {
+    let cont = match Container::from_ast(&ctxt, input, Derive::Serialize, &private.ident()) {
         Some(cont) => cont,
         None => return Err(ctxt.check().unwrap_err()),
     };
@@ -31,7 +31,7 @@ pub fn expand_derive_serialize(input: &mut syn::DeriveInput) -> syn::Result<Toke
         quote! {
             #[automatically_derived]
             impl #impl_generics #ident #ty_generics #where_clause {
-                #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> #serde::__private::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,
                 {
@@ -44,7 +44,7 @@ pub fn expand_derive_serialize(input: &mut syn::DeriveInput) -> syn::Result<Toke
         quote! {
             #[automatically_derived]
             impl #impl_generics #serde::Serialize for #ident #ty_generics #where_clause {
-                fn serialize<__S>(&self, __serializer: __S) -> #serde::__private::Result<__S::Ok, __S::Error>
+                fn serialize<__S>(&self, __serializer: __S) -> #serde::#private::Result<__S::Ok, __S::Error>
                 where
                     __S: #serde::Serializer,
                 {
@@ -212,7 +212,7 @@ fn serialize_into(params: &Parameters, type_into: &syn::Type) -> Fragment {
     let self_var = &params.self_var;
     quote_block! {
         _serde::Serialize::serialize(
-            &_serde::__private::Into::<#type_into>::into(_serde::__private::Clone::clone(#self_var)),
+            &_serde::#private::Into::<#type_into>::into(_serde::#private::Clone::clone(#self_var)),
             __serializer)
     }
 }
@@ -382,7 +382,7 @@ fn serialize_struct_as_map(
     let let_mut = mut_if(serialized_fields.peek().is_some() || tag_field_exists);
 
     quote_block! {
-        let #let_mut __serde_state = _serde::Serializer::serialize_map(__serializer, _serde::__private::None)?;
+        let #let_mut __serde_state = _serde::Serializer::serialize_map(__serializer, _serde::#private::None)?;
         #tag_field
         #(#serialize_fields)*
         _serde::ser::SerializeMap::end(__serde_state)
@@ -404,7 +404,7 @@ fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Cont
 
     if cattrs.remote().is_some() && cattrs.non_exhaustive() {
         arms.push(quote! {
-            ref unrecognized => _serde::__private::Err(_serde::ser::Error::custom(_serde::__private::ser::CannotSerializeVariant(unrecognized))),
+            ref unrecognized => _serde::#private::Err(_serde::ser::Error::custom(_serde::#private::ser::CannotSerializeVariant(unrecognized))),
         });
     }
 
@@ -431,7 +431,7 @@ fn serialize_variant(
             variant_ident
         );
         let skipped_err = quote! {
-            _serde::__private::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!(),
@@ -585,7 +585,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,
@@ -614,7 +614,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,
@@ -648,7 +648,7 @@ fn serialize_adjacently_tagged_variant(
     let type_name = cattrs.name().serialize_name();
     let variant_name = variant.attrs.name().serialize_name();
     let serialize_variant = quote! {
-        &_serde::__private::ser::AdjacentlyTaggedEnumVariant {
+        &_serde::#private::ser::AdjacentlyTaggedEnumVariant {
             enum_name: #type_name,
             variant_index: #variant_index,
             variant_name: #variant_name,
@@ -731,12 +731,12 @@ fn serialize_adjacently_tagged_variant(
         #[doc(hidden)]
         struct __AdjacentlyTagged #wrapper_generics #where_clause {
             data: (#(&'__a #fields_ty,)*),
-            phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
+            phantom: _serde::#private::PhantomData<#this_type #ty_generics>,
         }
 
         #[automatically_derived]
         impl #wrapper_impl_generics _serde::Serialize for __AdjacentlyTagged #wrapper_ty_generics #where_clause {
-            fn serialize<__S>(&self, __serializer: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
+            fn serialize<__S>(&self, __serializer: __S) -> _serde::#private::Result<__S::Ok, __S::Error>
             where
                 __S: _serde::Serializer,
             {
@@ -754,7 +754,7 @@ fn serialize_adjacently_tagged_variant(
         _serde::ser::SerializeStruct::serialize_field(
             &mut __struct, #content, &__AdjacentlyTagged {
                 data: (#(#fields_ident,)*),
-                phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
+                phantom: _serde::#private::PhantomData::<#this_type #ty_generics>,
             })?;
         _serde::ser::SerializeStruct::end(__struct)
     }
@@ -996,19 +996,19 @@ fn serialize_struct_variant_with_flatten(
                 #[doc(hidden)]
                 struct __EnumFlatten #wrapper_generics #where_clause {
                     data: (#(&'__a #fields_ty,)*),
-                    phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
+                    phantom: _serde::#private::PhantomData<#this_type #ty_generics>,
                 }
 
                 #[automatically_derived]
                 impl #wrapper_impl_generics _serde::Serialize for __EnumFlatten #wrapper_ty_generics #where_clause {
-                    fn serialize<__S>(&self, __serializer: __S) -> _serde::__private::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 = _serde::Serializer::serialize_map(
                             __serializer,
-                            _serde::__private::None)?;
+                            _serde::#private::None)?;
                         #(#serialize_fields)*
                         _serde::ser::SerializeMap::end(__serde_state)
                     }
@@ -1021,7 +1021,7 @@ fn serialize_struct_variant_with_flatten(
                     #variant_name,
                     &__EnumFlatten {
                         data: (#(#members,)*),
-                        phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
+                        phantom: _serde::#private::PhantomData::<#this_type #ty_generics>,
                     })
             }
         }
@@ -1029,7 +1029,7 @@ fn serialize_struct_variant_with_flatten(
             quote_block! {
                 let #let_mut __serde_state = _serde::Serializer::serialize_map(
                     __serializer,
-                    _serde::__private::None)?;
+                    _serde::#private::None)?;
                 _serde::ser::SerializeMap::serialize_entry(
                     &mut __serde_state,
                     #tag,
@@ -1043,7 +1043,7 @@ fn serialize_struct_variant_with_flatten(
             quote_block! {
                 let #let_mut __serde_state = _serde::Serializer::serialize_map(
                     __serializer,
-                    _serde::__private::None)?;
+                    _serde::#private::None)?;
                 #(#serialize_fields)*
                 _serde::ser::SerializeMap::end(__serde_state)
             }
@@ -1132,7 +1132,7 @@ fn serialize_struct_visitor(
             let ser = if field.attrs.flatten() {
                 let func = quote_spanned!(span=> _serde::Serialize::serialize);
                 quote! {
-                    #func(&#field_expr, _serde::__private::ser::FlatMapSerializer(&mut __serde_state))?;
+                    #func(&#field_expr, _serde::#private::ser::FlatMapSerializer(&mut __serde_state))?;
                 }
             } else {
                 let func = struct_trait.serialize_field(span);
@@ -1239,12 +1239,12 @@ fn wrap_serialize_with(
         #[doc(hidden)]
         struct __SerializeWith #wrapper_impl_generics #where_clause {
             values: (#(&'__a #field_tys, )*),
-            phantom: _serde::__private::PhantomData<#this_type #ty_generics>,
+            phantom: _serde::#private::PhantomData<#this_type #ty_generics>,
         }
 
         #[automatically_derived]
         impl #wrapper_impl_generics _serde::Serialize for __SerializeWith #wrapper_ty_generics #where_clause {
-            fn serialize<__S>(&#self_var, #serializer_var: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
+            fn serialize<__S>(&#self_var, #serializer_var: __S) -> _serde::#private::Result<__S::Ok, __S::Error>
             where
                 __S: _serde::Serializer,
             {
@@ -1254,7 +1254,7 @@ fn wrap_serialize_with(
 
         __SerializeWith {
             values: (#(#field_exprs, )*),
-            phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
+            phantom: _serde::#private::PhantomData::<#this_type #ty_generics>,
         }
     })
 }
@@ -1290,11 +1290,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");