Rename visit_enum_simple to visit_newtype_variant

serde/src/ser/impls.rs

@@ -632,10 +632,10 @@ impl<T, E> Serialize for Result<T, E> where T: Serialize, E: Serialize {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer {
         match *self {
             Result::Ok(ref value) => {
-                serializer.visit_enum_simple("Result", 0, "Ok", value)
+                serializer.visit_newtype_variant("Result", 0, "Ok", value)
             }
             Result::Err(ref value) => {
-                serializer.visit_enum_simple("Result", 1, "Err", value)
+                serializer.visit_newtype_variant("Result", 1, "Err", value)
             }
         }
     }

serde/src/ser/mod.rs

@@ -125,12 +125,15 @@ pub trait Serializer {
         self.visit_unit()
     }
 
+    /// The `visit_newtype_variant` allows a variant with a single item to be more efficiently
+    /// serialized than a variant with multiple items. By default it just serializes the value as a
+    /// tuple variant sequence.
     #[inline]
-    fn visit_enum_simple<T>(&mut self,
-                            name: &'static str,
-                            variant_index: usize,
-                            variant: &'static str,
-                            value: T) -> Result<(), Self::Error>
+    fn visit_newtype_variant<T>(&mut self,
+                                name: &'static str,
+                                variant_index: usize,
+                                variant: &'static str,
+                                value: T) -> Result<(), Self::Error>
         where T: Serialize,
     {
         self.visit_tuple_variant(

serde_codegen/src/ser.rs

@@ -306,7 +306,7 @@ fn serialize_variant(
                 .build();
             quote_arm!(cx,
                 $pat => {
-                    ::serde::ser::Serializer::visit_enum_simple(
+                    ::serde::ser::Serializer::visit_newtype_variant(
                         serializer,
                         $type_name,
                         $variant_index,

serde_json/src/ser.rs

@@ -172,12 +172,11 @@ impl<W, F> ser::Serializer for Serializer<W, F>
     }
 
     #[inline]
-    fn visit_enum_simple<T>(&mut self,
-                            _name: &str,
-                            _variant_index: usize,
-                            variant: &str,
-                            value: T,
-                            ) -> io::Result<()>
+    fn visit_newtype_variant<T>(&mut self,
+                                _name: &str,
+                                _variant_index: usize,
+                                variant: &str,
+                                value: T) -> io::Result<()>
         where T: ser::Serialize,
     {
         try!(self.formatter.open(&mut self.writer, b'{'));

serde_json/src/value.rs

@@ -472,12 +472,11 @@ impl ser::Serializer for Serializer {
     }
 
     #[inline]
-    fn visit_enum_simple<T>(&mut self,
-                            _name: &str,
-                            _variant_index: usize,
-                            variant: &str,
-                            value: T,
-                            ) -> Result<(), ()>
+    fn visit_newtype_variant<T>(&mut self,
+                                _name: &str,
+                                _variant_index: usize,
+                                variant: &str,
+                                value: T) -> Result<(), ()>
         where T: ser::Serialize,
     {
         let mut values = BTreeMap::new();

serde_tests/tests/test_ser.rs

@@ -27,7 +27,7 @@ pub enum Token<'a> {
     UnitStruct(&'a str),
     EnumUnit(&'a str, &'a str),
 
-    EnumSimple(&'a str, &'a str),
+    EnumNewtype(&'a str, &'a str),
 
     SeqStart(Option<usize>),
     TupleStructStart(&'a str, Option<usize>),
@@ -82,15 +82,14 @@ impl<'a> Serializer for AssertSerializer<'a> {
         Ok(())
     }
 
-    fn visit_enum_simple<T>(&mut self,
-                            name: &str,
-                            _variant_index: usize,
-                            variant: &str,
-                            value: T,
-                            ) -> Result<(), ()>
+    fn visit_newtype_variant<T>(&mut self,
+                                name: &str,
+                                _variant_index: usize,
+                                variant: &str,
+                                value: T) -> Result<(), ()>
         where T: Serialize,
     {
-        assert_eq!(self.iter.next(), Some(Token::EnumSimple(name, variant)));
+        assert_eq!(self.iter.next(), Some(Token::EnumNewtype(name, variant)));
         value.serialize(self)
     }
 
@@ -397,11 +396,11 @@ declare_tests! {
     }
     test_result {
         Ok::<i32, i32>(0) => vec![
-            Token::EnumSimple("Result", "Ok"),
+            Token::EnumNewtype("Result", "Ok"),
             Token::I32(0),
         ],
         Err::<i32, i32>(1) => vec![
-            Token::EnumSimple("Result", "Err"),
+            Token::EnumNewtype("Result", "Err"),
             Token::I32(1),
         ],
     }
@@ -565,7 +564,7 @@ declare_tests! {
     }
     test_enum {
         Enum::Unit => vec![Token::EnumUnit("Enum", "Unit")],
-        Enum::One(42) => vec![Token::EnumSimple("Enum", "One"), Token::I32(42)],
+        Enum::One(42) => vec![Token::EnumNewtype("Enum", "One"), Token::I32(42)],
         Enum::Seq(1, 2) => vec![
             Token::EnumSeqStart("Enum", "Seq", Some(2)),
                 Token::SeqSep,