Expose variant index to Serializer

serde/src/json/ser.rs

@@ -159,7 +159,10 @@ impl<W, F> ser::Serializer for Serializer<W, F>
     }
 
     #[inline]
-    fn visit_enum_unit(&mut self, _name: &str, variant: &str) -> io::Result<()> {
+    fn visit_enum_unit(&mut self,
+                       _name: &str,
+                       _variant_index: usize,
+                       variant: &str) -> io::Result<()> {
         try!(self.formatter.open(&mut self.writer, b'{'));
         try!(self.formatter.comma(&mut self.writer, true));
         try!(self.visit_str(variant));
@@ -190,7 +193,11 @@ impl<W, F> ser::Serializer for Serializer<W, F>
     }
 
     #[inline]
-    fn visit_enum_seq<V>(&mut self, _name: &str, variant: &str, visitor: V) -> io::Result<()>
+    fn visit_enum_seq<V>(&mut self,
+                         _name: &str,
+                         _variant_index: usize,
+                         variant: &str,
+                         visitor: V) -> io::Result<()>
         where V: ser::SeqVisitor,
     {
         try!(self.formatter.open(&mut self.writer, b'{'));
@@ -232,7 +239,11 @@ impl<W, F> ser::Serializer for Serializer<W, F>
     }
 
     #[inline]
-    fn visit_enum_map<V>(&mut self, _name: &str, variant: &str, visitor: V) -> io::Result<()>
+    fn visit_enum_map<V>(&mut self,
+                         _name: &str,
+                         _variant_index: usize,
+                         variant: &str,
+                         visitor: V) -> io::Result<()>
         where V: ser::MapVisitor,
     {
         try!(self.formatter.open(&mut self.writer, b'{'));

serde/src/json/value.rs

@@ -458,7 +458,10 @@ impl ser::Serializer for Serializer {
     }
 
     #[inline]
-    fn visit_enum_unit(&mut self, _name: &str, variant: &str) -> Result<(), ()> {
+    fn visit_enum_unit(&mut self,
+                       _name: &str,
+                       _variant_index: usize,
+                       variant: &str) -> Result<(), ()> {
         let mut values = BTreeMap::new();
         values.insert(variant.to_string(), Value::Array(vec![]));
 
@@ -489,7 +492,11 @@ impl ser::Serializer for Serializer {
     }
 
     #[inline]
-    fn visit_enum_seq<V>(&mut self, _name: &str, variant: &str, visitor: V) -> Result<(), ()>
+    fn visit_enum_seq<V>(&mut self,
+                         _name: &str,
+                         _variant_index: usize,
+                         variant: &str,
+                         visitor: V) -> Result<(), ()>
         where V: ser::SeqVisitor,
     {
         try!(self.visit_seq(visitor));
@@ -548,7 +555,11 @@ impl ser::Serializer for Serializer {
     }
 
     #[inline]
-    fn visit_enum_map<V>(&mut self, _name: &str, variant: &str, visitor: V) -> Result<(), ()>
+    fn visit_enum_map<V>(&mut self,
+                         _name: &str,
+                         _variant_index: usize,
+                         variant: &str,
+                         visitor: V) -> Result<(), ()>
         where V: ser::MapVisitor,
     {
         try!(self.visit_map(visitor));

serde/src/ser/impls.rs

@@ -650,7 +650,7 @@ impl<T, E> Serialize for Result<T, E> where T: Serialize, E: Serialize {
                     state: 0,
                     _structure_ty: data
                 };
-                serializer.visit_enum_seq("Result", "Ok", visitor)
+                serializer.visit_enum_seq("Result", 0, "Ok", visitor)
             }
             Result::Err(ref field0) => {
                 struct Visitor<'a, T, E> where T: Serialize + 'a, E: Serialize + 'a {
@@ -690,7 +690,7 @@ impl<T, E> Serialize for Result<T, E> where T: Serialize, E: Serialize {
                     state: 0,
                     _structure_ty: data
                 };
-                serializer.visit_enum_seq("Result", "Err", visitor)
+                serializer.visit_enum_seq("Result", 1, "Err", visitor)
             }
         }
     }

serde/src/ser/mod.rs

@@ -120,6 +120,7 @@ pub trait Serializer {
     #[inline]
     fn visit_enum_unit(&mut self,
                        _name: &str,
+                       _variant_index: usize,
                        _variant: &str) -> Result<(), Self::Error> {
         self.visit_unit()
     }
@@ -168,6 +169,7 @@ pub trait Serializer {
     #[inline]
     fn visit_enum_seq<V>(&mut self,
                          _name: &'static str,
+                         _variant_index: usize,
                          variant: &'static str,
                          visitor: V) -> Result<(), Self::Error>
         where V: SeqVisitor,
@@ -209,6 +211,7 @@ pub trait Serializer {
     #[inline]
     fn visit_enum_map<V>(&mut self,
                          _name: &'static str,
+                         _variant_index: usize,
                          variant: &'static str,
                          visitor: V) -> Result<(), Self::Error>
         where V: MapVisitor,

serde_codegen/src/ser.rs

@@ -243,7 +243,8 @@ fn serialize_item_enum(
     enum_def: &ast::EnumDef,
 ) -> P<ast::Expr> {
     let arms: Vec<ast::Arm> = enum_def.variants.iter()
-        .map(|variant| {
+        .enumerate()
+        .map(|(variant_index, variant)| {
             serialize_variant(
                 cx,
                 builder,
@@ -251,6 +252,7 @@ fn serialize_item_enum(
                 impl_generics,
                 ty.clone(),
                 variant,
+                variant_index,
             )
         })
         .collect();
@@ -269,6 +271,7 @@ fn serialize_variant(
     generics: &ast::Generics,
     ty: P<ast::Ty>,
     variant: &ast::Variant,
+    variant_index: usize,
 ) -> ast::Arm {
     let type_name = builder.expr().str(type_ident);
     let variant_ident = variant.node.name;
@@ -285,6 +288,7 @@ fn serialize_variant(
                     ::serde::ser::Serializer::visit_enum_unit(
                         serializer,
                         $type_name,
+                        $variant_index,
                         $variant_name,
                     )
                 }
@@ -304,6 +308,7 @@ fn serialize_variant(
                 cx,
                 builder,
                 type_name,
+                variant_index,
                 variant_name,
                 generics,
                 ty,
@@ -340,6 +345,7 @@ fn serialize_variant(
                 cx,
                 builder,
                 type_name,
+                variant_index,
                 variant_name,
                 generics,
                 ty,
@@ -356,6 +362,7 @@ fn serialize_tuple_variant(
     cx: &ExtCtxt,
     builder: &aster::AstBuilder,
     type_name: P<ast::Expr>,
+    variant_index: usize,
     variant_name: P<ast::Expr>,
     generics: &ast::Generics,
     structure_ty: P<ast::Ty>,
@@ -395,7 +402,7 @@ fn serialize_tuple_variant(
     quote_expr!(cx, {
         $visitor_struct
         $visitor_impl
-        serializer.visit_enum_seq($type_name, $variant_name, Visitor {
+        serializer.visit_enum_seq($type_name, $variant_index, $variant_name, Visitor {
             value: $value_expr,
             state: 0,
             _structure_ty: ::std::marker::PhantomData,
@@ -407,6 +414,7 @@ fn serialize_struct_variant(
     cx: &ExtCtxt,
     builder: &aster::AstBuilder,
     type_name: P<ast::Expr>,
+    variant_index: usize,
     variant_name: P<ast::Expr>,
     generics: &ast::Generics,
     structure_ty: P<ast::Ty>,
@@ -451,7 +459,7 @@ fn serialize_struct_variant(
     quote_expr!(cx, {
         $visitor_struct
         $visitor_impl
-        serializer.visit_enum_map($type_name, $variant_name, Visitor {
+        serializer.visit_enum_map($type_name, $variant_index, $variant_name, Visitor {
             value: $value_expr,
             state: 0,
             _structure_ty: ::std::marker::PhantomData,

serde_tests/tests/test_ser.rs

@@ -85,7 +85,10 @@ impl<'a> Serializer for AssertSerializer<'a> {
         Ok(())
     }
 
-    fn visit_enum_unit(&mut self, name: &str, variant: &str) -> Result<(), ()> {
+    fn visit_enum_unit(&mut self,
+                       name: &str,
+                       _variant_index: usize,
+                       variant: &str) -> Result<(), ()> {
         assert_eq!(self.iter.next().unwrap(), Token::EnumUnit(name, variant));
         Ok(())
     }
@@ -200,6 +203,7 @@ impl<'a> Serializer for AssertSerializer<'a> {
 
     fn visit_enum_seq<V>(&mut self,
                          name: &str,
+                         _variant_index: usize,
                          variant: &str,
                          visitor: V) -> Result<(), ()>
         where V: SeqVisitor
@@ -238,7 +242,11 @@ impl<'a> Serializer for AssertSerializer<'a> {
         self.visit_mapping(visitor)
     }
 
-    fn visit_enum_map<V>(&mut self, name: &str, variant: &str, visitor: V) -> Result<(), ()>
+    fn visit_enum_map<V>(&mut self,
+                         name: &str,
+                         _variant_index: usize,
+                         variant: &str,
+                         visitor: V) -> Result<(), ()>
         where V: MapVisitor
     {
         let len = visitor.len();