From 2a2891d54b9c0bf32eb3d90debb331436eeaefec Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Wed, 24 Aug 2016 00:10:23 -0400
Subject: [PATCH 1/3] Expose forward_to_deserialize macro

---
 serde/src/de/mod.rs   |  65 -------------
 serde/src/de/value.rs | 207 +++++++++---------------------------------
 serde/src/lib.rs      |   3 +
 serde/src/macros.rs   | 132 +++++++++++++++++++++++++++
 4 files changed, 180 insertions(+), 227 deletions(-)
 create mode 100644 serde/src/macros.rs

diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs
index 571c73b7..210b36b0 100644
--- a/serde/src/de/mod.rs
+++ b/serde/src/de/mod.rs
@@ -11,71 +11,6 @@ use collections::{String, Vec};
 use core::fmt;
 
 ///////////////////////////////////////////////////////////////////////////////
-/// Macro helper to not have to re-implement all the defaulted methods.
-/// Every given method ignores all arguments and forwards to `deserialize`.
-/// Note that `deserialize_enum` simply returns an `Error::invalid_type`.
-macro_rules! de_forward_to_deserialize {
-    ($($func:ident),*) => {
-        $(de_forward_to_deserialize!{func: $func})*
-    };
-    (func: deserialize_unit_struct) => {
-        de_forward_to_deserialize!{named: deserialize_unit_struct}
-    };
-    (func: deserialize_newtype_struct) => {
-        de_forward_to_deserialize!{named: deserialize_newtype_struct}
-    };
-    (func: deserialize_tuple) => {
-        de_forward_to_deserialize!{tup_fn: deserialize_tuple}
-    };
-    (func: deserialize_seq_fixed_size) => {
-        de_forward_to_deserialize!{tup_fn: deserialize_seq_fixed_size}
-    };
-    (func: deserialize_tuple_struct) => {
-        #[inline]
-        fn deserialize_tuple_struct<__V>(&mut self, _: &str, _: usize, visitor: __V) -> Result<__V::Value, Self::Error>
-            where __V: $crate::de::Visitor {
-            self.deserialize(visitor)
-        }
-    };
-    (func: deserialize_struct) => {
-        #[inline]
-        fn deserialize_struct<__V>(&mut self, _: &str, _: &[&str], visitor: __V) -> Result<__V::Value, Self::Error>
-            where __V: $crate::de::Visitor {
-            self.deserialize(visitor)
-        }
-    };
-    (func: deserialize_enum) => {
-        #[inline]
-        fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _: __V) -> Result<__V::Value, Self::Error>
-            where __V: $crate::de::EnumVisitor {
-            Err($crate::de::Error::invalid_type($crate::de::Type::Enum))
-        }
-    };
-    (named: $func:ident) => {
-        #[inline]
-        fn $func<__V>(&mut self, _: &str, visitor: __V) -> Result<__V::Value, Self::Error>
-            where __V: $crate::de::Visitor {
-            self.deserialize(visitor)
-        }
-    };
-    (tup_fn: $func: ident) => {
-        #[inline]
-        fn $func<__V>(&mut self, _: usize, visitor: __V) -> Result<__V::Value, Self::Error>
-            where __V: $crate::de::Visitor {
-            self.deserialize(visitor)
-        }
-    };
-    (func: $func:ident) => {
-        #[inline]
-        fn $func<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-            where __V: $crate::de::Visitor {
-            self.deserialize(visitor)
-        }
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// modules come after macros
 
 pub mod impls;
 pub mod value;
diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs
index bf3e0631..6f9e7d4b 100644
--- a/serde/src/de/value.rs
+++ b/serde/src/de/value.rs
@@ -178,20 +178,10 @@ impl<E> de::Deserializer for UnitDeserializer<E>
 {
     type Error = E;
 
-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
     }
 
     fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
@@ -229,21 +219,11 @@ macro_rules! primitive_deserializer {
         {
             type Error = E;
 
-            de_forward_to_deserialize!{
-                deserialize_bool,
-                deserialize_f64, deserialize_f32,
-                deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-                deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-                deserialize_char, deserialize_str, deserialize_string,
-                deserialize_ignored_any,
-                deserialize_bytes,
-                deserialize_unit_struct, deserialize_unit,
-                deserialize_seq, deserialize_seq_fixed_size,
-                deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-                deserialize_tuple,
-                deserialize_enum,
-                deserialize_struct, deserialize_tuple_struct,
-                deserialize_option
+            forward_to_deserialize! {
+                bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str
+                string unit option seq seq_fixed_size bytes map unit_struct
+                newtype_struct tuple_struct struct struct_field tuple enum
+                ignored_any
             }
 
             fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
@@ -311,20 +291,10 @@ impl<'a, E> de::Deserializer for StrDeserializer<'a, E>
         visitor.visit(self)
     }
 
-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple ignored_any
     }
 }
 
@@ -408,20 +378,10 @@ impl<E> de::Deserializer for StringDeserializer<E>
         visitor.visit(self)
     }
 
-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple ignored_any
     }
 }
 
@@ -507,20 +467,10 @@ impl<'a, E> de::Deserializer for CowStrDeserializer<'a, E>
         visitor.visit(self)
     }
 
-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple ignored_any
     }
 }
 
@@ -599,21 +549,10 @@ impl<I, T, E> de::Deserializer for SeqDeserializer<I, E>
         visitor.visit_seq(self)
     }
 
-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
     }
 }
 
@@ -722,21 +661,10 @@ impl<V_, E> de::Deserializer for SeqVisitorDeserializer<V_, E>
         visitor.visit_seq(&mut self.visitor)
     }
 
-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
     }
 }
 
@@ -797,21 +725,10 @@ impl<I, K, V, E> de::Deserializer for MapDeserializer<I, K, V, E>
         visitor.visit_map(self)
     }
 
-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
     }
 }
 
@@ -928,21 +845,10 @@ impl<V_, E> de::Deserializer for MapVisitorDeserializer<V_, E>
         visitor.visit_map(&mut self.visitor)
     }
 
-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
     }
 }
 
@@ -975,25 +881,13 @@ impl<'a, E> de::Deserializer for BytesDeserializer<'a, E>
         }
     }
 
-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
     }
 }
 
-
 ///////////////////////////////////////////////////////////////////////////////
 
 #[cfg(any(feature = "std", feature = "collections"))]
@@ -1026,20 +920,9 @@ impl<E> de::Deserializer for ByteBufDeserializer<E>
         }
     }
 
-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
     }
 }
diff --git a/serde/src/lib.rs b/serde/src/lib.rs
index 54dcc120..78a0531e 100644
--- a/serde/src/lib.rs
+++ b/serde/src/lib.rs
@@ -45,6 +45,9 @@ macro_rules! format {
     ($s:expr, $($rest:tt)*) => ($s)
 }
 
+#[macro_use]
+mod macros;
+
 pub mod bytes;
 pub mod de;
 #[cfg(feature = "std")]
diff --git a/serde/src/macros.rs b/serde/src/macros.rs
new file mode 100644
index 00000000..a997a148
--- /dev/null
+++ b/serde/src/macros.rs
@@ -0,0 +1,132 @@
+/// Helper to forward `Deserializer` methods to `Deserializer::deserialize`.
+/// Every given method ignores all arguments and forwards to `deserialize`.
+/// Note that `deserialize_enum` simply returns an `Error::invalid_type`; a
+/// better approach is tracked in [serde-rs/serde#521][1].
+///
+/// ```rust,ignore
+/// impl Deserializer for MyDeserializer {
+///     fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+///         where V: Visitor
+///     {
+///         /* ... */
+///     }
+///
+///     forward_to_deserialize! {
+///         bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+///         unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+///         tuple_struct struct struct_field tuple enum ignored_any
+///     }
+/// }
+/// ```
+///
+/// [1]: https://github.com/serde-rs/serde/issues/521
+#[macro_export]
+macro_rules! forward_to_deserialize {
+    (@func bool) => {
+        forward_to_deserialize!{@forward deserialize_bool()}
+    };
+    (@func usize) => {
+        forward_to_deserialize!{@forward deserialize_usize()}
+    };
+    (@func u8) => {
+        forward_to_deserialize!{@forward deserialize_u8()}
+    };
+    (@func u16) => {
+        forward_to_deserialize!{@forward deserialize_u16()}
+    };
+    (@func u32) => {
+        forward_to_deserialize!{@forward deserialize_u32()}
+    };
+    (@func u64) => {
+        forward_to_deserialize!{@forward deserialize_u64()}
+    };
+    (@func isize) => {
+        forward_to_deserialize!{@forward deserialize_isize()}
+    };
+    (@func i8) => {
+        forward_to_deserialize!{@forward deserialize_i8()}
+    };
+    (@func i16) => {
+        forward_to_deserialize!{@forward deserialize_i16()}
+    };
+    (@func i32) => {
+        forward_to_deserialize!{@forward deserialize_i32()}
+    };
+    (@func i64) => {
+        forward_to_deserialize!{@forward deserialize_i64()}
+    };
+    (@func f32) => {
+        forward_to_deserialize!{@forward deserialize_f32()}
+    };
+    (@func f64) => {
+        forward_to_deserialize!{@forward deserialize_f64()}
+    };
+    (@func char) => {
+        forward_to_deserialize!{@forward deserialize_char()}
+    };
+    (@func str) => {
+        forward_to_deserialize!{@forward deserialize_str()}
+    };
+    (@func string) => {
+        forward_to_deserialize!{@forward deserialize_string()}
+    };
+    (@func unit) => {
+        forward_to_deserialize!{@forward deserialize_unit()}
+    };
+    (@func option) => {
+        forward_to_deserialize!{@forward deserialize_option()}
+    };
+    (@func seq) => {
+        forward_to_deserialize!{@forward deserialize_seq()}
+    };
+    (@func seq_fixed_size) => {
+        forward_to_deserialize!{@forward deserialize_seq_fixed_size(usize)}
+    };
+    (@func bytes) => {
+        forward_to_deserialize!{@forward deserialize_bytes()}
+    };
+    (@func map) => {
+        forward_to_deserialize!{@forward deserialize_map()}
+    };
+    (@func unit_struct) => {
+        forward_to_deserialize!{@forward deserialize_unit_struct(&'static str)}
+    };
+    (@func newtype_struct) => {
+        forward_to_deserialize!{@forward deserialize_newtype_struct(&'static str)}
+    };
+    (@func tuple_struct) => {
+        forward_to_deserialize!{@forward deserialize_tuple_struct(&'static str, usize)}
+    };
+    (@func struct) => {
+        forward_to_deserialize!{@forward deserialize_struct(&'static str, &'static [&'static str])}
+    };
+    (@func struct_field) => {
+        forward_to_deserialize!{@forward deserialize_struct_field()}
+    };
+    (@func tuple) => {
+        forward_to_deserialize!{@forward deserialize_tuple(usize)}
+    };
+    (@func enum) => {
+        #[inline]
+        fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _: __V) -> ::std::result::Result<__V::Value, Self::Error>
+            where __V: $crate::de::EnumVisitor
+        {
+            Err($crate::de::Error::invalid_type($crate::de::Type::Enum))
+        }
+    };
+    (@func ignored_any) => {
+        forward_to_deserialize!{@forward deserialize_ignored_any()}
+    };
+    (@forward $func:ident($($arg:ty),*)) => {
+        #[inline]
+        fn $func<__V>(&mut self, $(_: $arg,)* visitor: __V) -> ::std::result::Result<__V::Value, Self::Error>
+            where __V: $crate::de::Visitor
+        {
+            self.deserialize(visitor)
+        }
+    };
+
+    ($($func:ident)*) => {
+        $(forward_to_deserialize!{@func $func})*
+    };
+}

From d36f28971c3a345bf01af34942f9139a9a208c36 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Sun, 28 Aug 2016 23:55:11 -0700
Subject: [PATCH 2/3] Support no_std in forward_to_deserialize macro

---
 serde/src/macros.rs | 257 ++++++++++++++++++++++++++------------------
 1 file changed, 152 insertions(+), 105 deletions(-)

diff --git a/serde/src/macros.rs b/serde/src/macros.rs
index a997a148..6064c87e 100644
--- a/serde/src/macros.rs
+++ b/serde/src/macros.rs
@@ -1,3 +1,154 @@
+#[cfg(feature = "std")]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! forward_to_deserialize_method {
+    ($func:ident($($arg:ty),*)) => {
+        #[inline]
+        fn $func<__V>(&mut self, $(_: $arg,)* visitor: __V) -> ::std::result::Result<__V::Value, Self::Error>
+            where __V: $crate::de::Visitor
+        {
+            self.deserialize(visitor)
+        }
+    };
+}
+
+#[cfg(not(feature = "std"))]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! forward_to_deserialize_method {
+    ($func:ident($($arg:ty),*)) => {
+        #[inline]
+        fn $func<__V>(&mut self, $(_: $arg,)* visitor: __V) -> ::core::result::Result<__V::Value, Self::Error>
+            where __V: $crate::de::Visitor
+        {
+            self.deserialize(visitor)
+        }
+    };
+}
+
+#[cfg(feature = "std")]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! forward_to_deserialize_enum {
+    () => {
+        #[inline]
+        fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _: __V) -> ::std::result::Result<__V::Value, Self::Error>
+            where __V: $crate::de::EnumVisitor
+        {
+            Err($crate::de::Error::invalid_type($crate::de::Type::Enum))
+        }
+    };
+}
+
+#[cfg(not(feature = "std"))]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! forward_to_deserialize_enum {
+    () => {
+        #[inline]
+        fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _: __V) -> ::core::result::Result<__V::Value, Self::Error>
+            where __V: $crate::de::EnumVisitor
+        {
+            Err($crate::de::Error::invalid_type($crate::de::Type::Enum))
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! forward_to_deserialize_helper {
+    (bool) => {
+        forward_to_deserialize_method!{deserialize_bool()}
+    };
+    (usize) => {
+        forward_to_deserialize_method!{deserialize_usize()}
+    };
+    (u8) => {
+        forward_to_deserialize_method!{deserialize_u8()}
+    };
+    (u16) => {
+        forward_to_deserialize_method!{deserialize_u16()}
+    };
+    (u32) => {
+        forward_to_deserialize_method!{deserialize_u32()}
+    };
+    (u64) => {
+        forward_to_deserialize_method!{deserialize_u64()}
+    };
+    (isize) => {
+        forward_to_deserialize_method!{deserialize_isize()}
+    };
+    (i8) => {
+        forward_to_deserialize_method!{deserialize_i8()}
+    };
+    (i16) => {
+        forward_to_deserialize_method!{deserialize_i16()}
+    };
+    (i32) => {
+        forward_to_deserialize_method!{deserialize_i32()}
+    };
+    (i64) => {
+        forward_to_deserialize_method!{deserialize_i64()}
+    };
+    (f32) => {
+        forward_to_deserialize_method!{deserialize_f32()}
+    };
+    (f64) => {
+        forward_to_deserialize_method!{deserialize_f64()}
+    };
+    (char) => {
+        forward_to_deserialize_method!{deserialize_char()}
+    };
+    (str) => {
+        forward_to_deserialize_method!{deserialize_str()}
+    };
+    (string) => {
+        forward_to_deserialize_method!{deserialize_string()}
+    };
+    (unit) => {
+        forward_to_deserialize_method!{deserialize_unit()}
+    };
+    (option) => {
+        forward_to_deserialize_method!{deserialize_option()}
+    };
+    (seq) => {
+        forward_to_deserialize_method!{deserialize_seq()}
+    };
+    (seq_fixed_size) => {
+        forward_to_deserialize_method!{deserialize_seq_fixed_size(usize)}
+    };
+    (bytes) => {
+        forward_to_deserialize_method!{deserialize_bytes()}
+    };
+    (map) => {
+        forward_to_deserialize_method!{deserialize_map()}
+    };
+    (unit_struct) => {
+        forward_to_deserialize_method!{deserialize_unit_struct(&'static str)}
+    };
+    (newtype_struct) => {
+        forward_to_deserialize_method!{deserialize_newtype_struct(&'static str)}
+    };
+    (tuple_struct) => {
+        forward_to_deserialize_method!{deserialize_tuple_struct(&'static str, usize)}
+    };
+    (struct) => {
+        forward_to_deserialize_method!{deserialize_struct(&'static str, &'static [&'static str])}
+    };
+    (struct_field) => {
+        forward_to_deserialize_method!{deserialize_struct_field()}
+    };
+    (tuple) => {
+        forward_to_deserialize_method!{deserialize_tuple(usize)}
+    };
+    (ignored_any) => {
+        forward_to_deserialize_method!{deserialize_ignored_any()}
+    };
+    (enum) => {
+        forward_to_deserialize_enum!();
+    };
+}
+
 /// Helper to forward `Deserializer` methods to `Deserializer::deserialize`.
 /// Every given method ignores all arguments and forwards to `deserialize`.
 /// Note that `deserialize_enum` simply returns an `Error::invalid_type`; a
@@ -22,111 +173,7 @@
 /// [1]: https://github.com/serde-rs/serde/issues/521
 #[macro_export]
 macro_rules! forward_to_deserialize {
-    (@func bool) => {
-        forward_to_deserialize!{@forward deserialize_bool()}
-    };
-    (@func usize) => {
-        forward_to_deserialize!{@forward deserialize_usize()}
-    };
-    (@func u8) => {
-        forward_to_deserialize!{@forward deserialize_u8()}
-    };
-    (@func u16) => {
-        forward_to_deserialize!{@forward deserialize_u16()}
-    };
-    (@func u32) => {
-        forward_to_deserialize!{@forward deserialize_u32()}
-    };
-    (@func u64) => {
-        forward_to_deserialize!{@forward deserialize_u64()}
-    };
-    (@func isize) => {
-        forward_to_deserialize!{@forward deserialize_isize()}
-    };
-    (@func i8) => {
-        forward_to_deserialize!{@forward deserialize_i8()}
-    };
-    (@func i16) => {
-        forward_to_deserialize!{@forward deserialize_i16()}
-    };
-    (@func i32) => {
-        forward_to_deserialize!{@forward deserialize_i32()}
-    };
-    (@func i64) => {
-        forward_to_deserialize!{@forward deserialize_i64()}
-    };
-    (@func f32) => {
-        forward_to_deserialize!{@forward deserialize_f32()}
-    };
-    (@func f64) => {
-        forward_to_deserialize!{@forward deserialize_f64()}
-    };
-    (@func char) => {
-        forward_to_deserialize!{@forward deserialize_char()}
-    };
-    (@func str) => {
-        forward_to_deserialize!{@forward deserialize_str()}
-    };
-    (@func string) => {
-        forward_to_deserialize!{@forward deserialize_string()}
-    };
-    (@func unit) => {
-        forward_to_deserialize!{@forward deserialize_unit()}
-    };
-    (@func option) => {
-        forward_to_deserialize!{@forward deserialize_option()}
-    };
-    (@func seq) => {
-        forward_to_deserialize!{@forward deserialize_seq()}
-    };
-    (@func seq_fixed_size) => {
-        forward_to_deserialize!{@forward deserialize_seq_fixed_size(usize)}
-    };
-    (@func bytes) => {
-        forward_to_deserialize!{@forward deserialize_bytes()}
-    };
-    (@func map) => {
-        forward_to_deserialize!{@forward deserialize_map()}
-    };
-    (@func unit_struct) => {
-        forward_to_deserialize!{@forward deserialize_unit_struct(&'static str)}
-    };
-    (@func newtype_struct) => {
-        forward_to_deserialize!{@forward deserialize_newtype_struct(&'static str)}
-    };
-    (@func tuple_struct) => {
-        forward_to_deserialize!{@forward deserialize_tuple_struct(&'static str, usize)}
-    };
-    (@func struct) => {
-        forward_to_deserialize!{@forward deserialize_struct(&'static str, &'static [&'static str])}
-    };
-    (@func struct_field) => {
-        forward_to_deserialize!{@forward deserialize_struct_field()}
-    };
-    (@func tuple) => {
-        forward_to_deserialize!{@forward deserialize_tuple(usize)}
-    };
-    (@func enum) => {
-        #[inline]
-        fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _: __V) -> ::std::result::Result<__V::Value, Self::Error>
-            where __V: $crate::de::EnumVisitor
-        {
-            Err($crate::de::Error::invalid_type($crate::de::Type::Enum))
-        }
-    };
-    (@func ignored_any) => {
-        forward_to_deserialize!{@forward deserialize_ignored_any()}
-    };
-    (@forward $func:ident($($arg:ty),*)) => {
-        #[inline]
-        fn $func<__V>(&mut self, $(_: $arg,)* visitor: __V) -> ::std::result::Result<__V::Value, Self::Error>
-            where __V: $crate::de::Visitor
-        {
-            self.deserialize(visitor)
-        }
-    };
-
     ($($func:ident)*) => {
-        $(forward_to_deserialize!{@func $func})*
+        $(forward_to_deserialize_helper!{$func})*
     };
 }

From 35be61d85f0a18aec8ecaa3f398aa76ace1132f7 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Mon, 5 Sep 2016 08:02:35 -0700
Subject: [PATCH 3/3] Resolve merge conflict

---
 serde/src/de/value.rs | 58 ++++++-------------------------------------
 1 file changed, 8 insertions(+), 50 deletions(-)

diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs
index 67ad278d..00b07107 100644
--- a/serde/src/de/value.rs
+++ b/serde/src/de/value.rs
@@ -734,28 +734,6 @@ impl<I, K, V, E> de::Deserializer for MapDeserializer<I, K, V, E>
         visitor.visit_map(self)
     }
 
-<<<<<<< HEAD
-    forward_to_deserialize! {
-        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
-        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
-        tuple_struct struct struct_field tuple enum ignored_any
-||||||| merged common ancestors
-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
-=======
     fn deserialize_seq<V_>(&mut self, mut visitor: V_) -> Result<V_::Value, Self::Error>
         where V_: de::Visitor,
     {
@@ -772,21 +750,10 @@ impl<I, K, V, E> de::Deserializer for MapDeserializer<I, K, V, E>
         }
     }
 
-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
->>>>>>> origin/master
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option bytes map unit_struct newtype_struct tuple_struct struct
+        struct_field tuple enum ignored_any
     }
 }
 
@@ -879,19 +846,10 @@ impl<A, B, E> de::Deserializer for PairDeserializer<A, B, E>
 {
     type Error = E;
 
-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit, deserialize_option,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option bytes map unit_struct newtype_struct tuple_struct struct
+        struct_field tuple enum ignored_any
     }
 
     fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>