Minor cleanup

serde/src/de/mod.rs

@@ -580,7 +580,9 @@ pub trait VariantVisitor {
     }
 
     /// `visit_simple` is called when deserializing a variant with a single value.
-    fn visit_simple<T: Deserialize>(&mut self) -> Result<T, Self::Error> {
+    fn visit_simple<T>(&mut self) -> Result<T, Self::Error>
+        where T: Deserialize,
+    {
         Err(Error::syntax_error())
     }
 
@@ -616,7 +618,9 @@ impl<'a, T> VariantVisitor for &'a mut T where T: VariantVisitor {
         (**self).visit_unit()
     }
 
-    fn visit_simple<D: Deserialize>(&mut self) -> Result<D, T::Error> {
+    fn visit_simple<D>(&mut self) -> Result<D, T::Error>
+        where D: Deserialize,
+    {
         (**self).visit_simple()
     }
 

serde/src/ser/impls.rs

@@ -126,8 +126,8 @@ impl<T, Iter> SeqVisitor for SeqIteratorVisitor<Iter>
     {
         match self.iter.next() {
             Some(value) => {
-                let value = try!(serializer.visit_seq_elt(value));
+                try!(serializer.visit_seq_elt(value));
-                Ok(Some(value))
+                Ok(Some(()))
             }
             None => Ok(None),
         }

serde/src/ser/mod.rs

@@ -129,8 +129,7 @@ pub trait Serializer {
     fn visit_enum_simple<T>(&mut self,
                             _name: &str,
                             _variant: &str,
-                            _value: T,
+                            _value: T) -> Result<(), Self::Error>
-                            ) -> Result<(), Self::Error>
         where T: Serialize;
 
     fn visit_none(&mut self) -> Result<(), Self::Error>;

serde_codegen/src/de.rs

@@ -765,10 +765,10 @@ fn deserialize_field_visitor(
     let str_body = if formats.is_empty() {
         // No formats specific attributes, so no match on format required
         quote_expr!(cx,
-                    match value {
+            match value {
-                        $default_field_arms
+                $default_field_arms
-                        _ => { Err(::serde::de::Error::unknown_field_error(value)) }
+                _ => { Err(::serde::de::Error::unknown_field_error(value)) }
-                    })
+            })
     } else {
         let field_arms: Vec<_> = formats.iter()
             .map(|fmt| {

serde_json/src/value.rs

@@ -743,12 +743,12 @@ impl<'a> de::VariantVisitor for VariantDeserializer<'a> {
         de::Deserialize::deserialize(&mut Deserializer::new(self.variant.take().unwrap()))
     }
 
-    fn visit_unit(&mut self) -> Result<(), Error>
+    fn visit_unit(&mut self) -> Result<(), Error> {
-    {
         de::Deserialize::deserialize(&mut Deserializer::new(self.val.take().unwrap()))
     }
 
-    fn visit_simple<D: de::Deserialize>(&mut self) -> Result<D, Error>
+    fn visit_simple<T>(&mut self) -> Result<T, Error>
+        where T: de::Deserialize,
     {
         de::Deserialize::deserialize(&mut Deserializer::new(self.val.take().unwrap()))
     }

serde_tests/tests/test_bytes.rs

@@ -42,8 +42,7 @@ impl serde::Serializer for BytesSerializer {
     fn visit_enum_simple<T>(&mut self,
                             _name: &str,
                             _variant: &str,
-                            _value: T,
+                            _value: T) -> Result<(), Error>
-                            ) -> Result<(), Error>
     {
         Err(Error)
     }