Return IdentifierDeserializer to just one associated type

The BorrowedDeserializer was added in #1917, but only makes sense for
&str and &[u8], not for u64 which also needs to be have an
IdentifierDeserializer impl.

serde/src/private/de.rs

@@ -2541,26 +2541,21 @@ mod content {
 //    }
 pub trait IdentifierDeserializer<'de, E: Error> {
     type Deserializer: Deserializer<'de, Error = E>;
-    type BorrowedDeserializer: Deserializer<'de, Error = E>;
 
     fn from(self) -> Self::Deserializer;
-    fn borrowed(self) -> Self::BorrowedDeserializer;
 }
 
+pub struct Borrowed<'de, T: ?Sized>(pub &'de T);
+
 impl<'de, E> IdentifierDeserializer<'de, E> for u64
 where
     E: Error,
 {
     type Deserializer = <u64 as IntoDeserializer<'de, E>>::Deserializer;
-    type BorrowedDeserializer = <u64 as IntoDeserializer<'de, E>>::Deserializer;
 
     fn from(self) -> Self::Deserializer {
         self.into_deserializer()
     }
-
-    fn borrowed(self) -> Self::BorrowedDeserializer {
-        self.into_deserializer()
-    }
 }
 
 pub struct StrDeserializer<'a, E> {
@@ -2618,18 +2613,24 @@ where
     E: Error,
 {
     type Deserializer = StrDeserializer<'a, E>;
-    type BorrowedDeserializer = BorrowedStrDeserializer<'a, E>;
 
     fn from(self) -> Self::Deserializer {
         StrDeserializer {
             value: self,
             marker: PhantomData,
         }
     }
+}
+
+impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, str>
+where
+    E: Error,
+{
+    type Deserializer = BorrowedStrDeserializer<'de, E>;
 
-    fn borrowed(self) -> Self::BorrowedDeserializer {
+    fn from(self) -> Self::Deserializer {
         BorrowedStrDeserializer {
-            value: self,
+            value: self.0,
             marker: PhantomData,
         }
     }
@@ -2640,14 +2641,20 @@ where
     E: Error,
 {
     type Deserializer = BytesDeserializer<'a, E>;
-    type BorrowedDeserializer = BorrowedBytesDeserializer<'a, E>;
 
     fn from(self) -> Self::Deserializer {
         BytesDeserializer::new(self)
     }
+}
+
+impl<'de, E> IdentifierDeserializer<'de, E> for Borrowed<'de, [u8]>
+where
+    E: Error,
+{
+    type Deserializer = BorrowedBytesDeserializer<'de, E>;
 
-    fn borrowed(self) -> Self::BorrowedDeserializer {
-        BorrowedBytesDeserializer::new(self)
+    fn from(self) -> Self::Deserializer {
+        BorrowedBytesDeserializer::new(self.0)
     }
 }
 

serde_derive/src/de.rs

@@ -1992,18 +1992,21 @@ fn deserialize_custom_identifier(
             (ordinary, Some((fallthrough.clone(), fallthrough)))
         } else if let Style::Newtype = last.style {
             let ordinary = &variants[..variants.len() - 1];
-            let fallthrough = |method| {
+            let fallthrough = |value| {
                 quote! {
                     _serde::__private::Result::map(
                         _serde::Deserialize::deserialize(
-                            _serde::__private::de::IdentifierDeserializer::#method(__value)
+                            _serde::__private::de::IdentifierDeserializer::from(#value)
                         ),
                         #this::#last_ident)
                 }
             };
             (
                 ordinary,
-                Some((fallthrough(quote!(from)), fallthrough(quote!(borrowed)))),
+                Some((
+                    fallthrough(quote!(__value)),
+                    fallthrough(quote!(_serde::__private::de::Borrowed(__value))),
+                )),
             )
         } else {
             (variants, None)