Allow using IgnoredAny as a visitor

serde/src/de/ignored_any.rs

@@ -7,15 +7,7 @@ use de::{Deserialize, Deserializer, Visitor, SeqVisitor, MapVisitor, Error};
 #[derive(Copy, Clone, Debug, Default)]
 pub struct IgnoredAny;
 
-impl<'de> Deserialize<'de> for IgnoredAny {
+impl<'de> Visitor<'de> for IgnoredAny {
-    #[inline]
-    fn deserialize<D>(deserializer: D) -> Result<IgnoredAny, D::Error>
-    where
-        D: Deserializer<'de>,
-    {
-        struct IgnoredAnyVisitor;
-
-        impl<'de> Visitor<'de> for IgnoredAnyVisitor {
     type Value = IgnoredAny;
 
     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@@ -23,40 +15,45 @@ impl<'de> Deserialize<'de> for IgnoredAny {
     }
 
     #[inline]
-            fn visit_bool<E>(self, _: bool) -> Result<IgnoredAny, E> {
+    fn visit_bool<E>(self, x: bool) -> Result<Self::Value, E> {
+        let _ = x;
         Ok(IgnoredAny)
     }
 
     #[inline]
-            fn visit_i64<E>(self, _: i64) -> Result<IgnoredAny, E> {
+    fn visit_i64<E>(self, x: i64) -> Result<Self::Value, E> {
+        let _ = x;
         Ok(IgnoredAny)
     }
 
     #[inline]
-            fn visit_u64<E>(self, _: u64) -> Result<IgnoredAny, E> {
+    fn visit_u64<E>(self, x: u64) -> Result<Self::Value, E> {
+        let _ = x;
         Ok(IgnoredAny)
     }
 
     #[inline]
-            fn visit_f64<E>(self, _: f64) -> Result<IgnoredAny, E> {
+    fn visit_f64<E>(self, x: f64) -> Result<Self::Value, E> {
+        let _ = x;
         Ok(IgnoredAny)
     }
 
     #[inline]
-            fn visit_str<E>(self, _: &str) -> Result<IgnoredAny, E>
+    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
     where
         E: Error,
     {
+        let _ = s;
         Ok(IgnoredAny)
     }
 
     #[inline]
-            fn visit_none<E>(self) -> Result<IgnoredAny, E> {
+    fn visit_none<E>(self) -> Result<Self::Value, E> {
         Ok(IgnoredAny)
     }
 
     #[inline]
-            fn visit_some<D>(self, deserializer: D) -> Result<IgnoredAny, D::Error>
+    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
     where
         D: Deserializer<'de>,
     {
@@ -64,7 +61,7 @@ impl<'de> Deserialize<'de> for IgnoredAny {
     }
 
     #[inline]
-            fn visit_newtype_struct<D>(self, deserializer: D) -> Result<IgnoredAny, D::Error>
+    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
     where
         D: Deserializer<'de>,
     {
@@ -72,41 +69,48 @@ impl<'de> Deserialize<'de> for IgnoredAny {
     }
 
     #[inline]
-            fn visit_unit<E>(self) -> Result<IgnoredAny, E> {
+    fn visit_unit<E>(self) -> Result<Self::Value, E> {
         Ok(IgnoredAny)
     }
 
     #[inline]
-            fn visit_seq<V>(self, mut visitor: V) -> Result<IgnoredAny, V::Error>
+    fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
     where
         V: SeqVisitor<'de>,
     {
-                while let Some(_) = try!(visitor.visit::<IgnoredAny>()) {
+        while let Some(IgnoredAny) = try!(visitor.visit()) {
             // Gobble
         }
         Ok(IgnoredAny)
     }
 
     #[inline]
-            fn visit_map<V>(self, mut visitor: V) -> Result<IgnoredAny, V::Error>
+    fn visit_map<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
     where
         V: MapVisitor<'de>,
     {
-                while let Some((_, _)) = try!(visitor.visit::<IgnoredAny, IgnoredAny>()) {
+        while let Some((IgnoredAny, IgnoredAny)) = try!(visitor.visit()) {
             // Gobble
         }
         Ok(IgnoredAny)
     }
 
     #[inline]
-            fn visit_bytes<E>(self, _: &[u8]) -> Result<IgnoredAny, E>
+    fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
     where
         E: Error,
     {
+        let _ = bytes;
         Ok(IgnoredAny)
     }
-        }
+}
 
-        deserializer.deserialize_ignored_any(IgnoredAnyVisitor)
+impl<'de> Deserialize<'de> for IgnoredAny {
+    #[inline]
+    fn deserialize<D>(deserializer: D) -> Result<IgnoredAny, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_ignored_any(IgnoredAny)
     }
 }