Use struct variants in token

serde_test/src/de.rs

@@ -166,14 +166,14 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             Token::None => visitor.visit_none(),
             Token::Some => visitor.visit_some(self),
             Token::Unit => visitor.visit_unit(),
-            Token::UnitStruct(_name) => visitor.visit_unit(),
-            Token::NewtypeStruct(_name) => visitor.visit_newtype_struct(self),
-            Token::Seq(len) => self.visit_seq(len, Token::SeqEnd, visitor),
-            Token::Tuple(len) => self.visit_seq(Some(len), Token::TupleEnd, visitor),
-            Token::TupleStruct(_, len) => self.visit_seq(Some(len), Token::TupleStructEnd, visitor),
-            Token::Map(len) => self.visit_map(len, Token::MapEnd, visitor),
-            Token::Struct(_, len) => self.visit_map(Some(len), Token::StructEnd, visitor),
-            Token::Enum(_) => {
+            Token::UnitStruct { name: _ } => visitor.visit_unit(),
+            Token::NewtypeStruct { name: _ } => visitor.visit_newtype_struct(self),
+            Token::Seq { len } => self.visit_seq(len, Token::SeqEnd, visitor),
+            Token::Tuple { len } => self.visit_seq(Some(len), Token::TupleEnd, visitor),
+            Token::TupleStruct { name: _, len } => self.visit_seq(Some(len), Token::TupleStructEnd, visitor),
+            Token::Map { len } => self.visit_map(len, Token::MapEnd, visitor),
+            Token::Struct { name: _, len } => self.visit_map(Some(len), Token::StructEnd, visitor),
+            Token::Enum { name: _ } => {
                 let variant = self.next_token();
                 let next = self.peek_token();
                 match (variant, next) {
@@ -195,14 +195,14 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
                     }
                 }
             }
-            Token::UnitVariant(_, variant) => visitor.visit_str(variant),
-            Token::NewtypeVariant(_, variant) => {
+            Token::UnitVariant { name: _, variant } => visitor.visit_str(variant),
+            Token::NewtypeVariant { name: _, variant } => {
                 visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Any),)
             }
-            Token::TupleVariant(_, variant, _) => {
+            Token::TupleVariant { name: _, variant, len: _ } => {
                 visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Seq),)
             }
-            Token::StructVariant(_, variant, _) => {
+            Token::StructVariant { name: _, variant, len: _ } => {
                 visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Map),)
             }
             Token::SeqEnd | Token::TupleEnd | Token::TupleStructEnd | Token::MapEnd |
@@ -240,15 +240,15 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         V: Visitor<'de>,
     {
         match self.peek_token() {
-            Token::Enum(n) if name == n => {
+            Token::Enum { name: n } if name == n => {
                 self.next_token();
 
                 visitor.visit_enum(DeserializerEnumVisitor { de: self })
             }
-            Token::UnitVariant(n, _) |
-            Token::NewtypeVariant(n, _) |
-            Token::TupleVariant(n, _, _) |
-            Token::StructVariant(n, _, _) if name == n => {
+            Token::UnitVariant { name: n, variant: _ } |
+            Token::NewtypeVariant { name: n, variant: _ } |
+            Token::TupleVariant { name: n, variant: _, len: _ } |
+            Token::StructVariant { name: n, variant: _, len: _ } if name == n => {
                 visitor.visit_enum(DeserializerEnumVisitor { de: self })
             }
             _ => {
@@ -262,8 +262,8 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         V: Visitor<'de>,
     {
         match self.peek_token() {
-            Token::UnitStruct(_) => {
-                assert_next_token!(self, Token::UnitStruct(name));
+            Token::UnitStruct { name: _ } => {
+                assert_next_token!(self, Token::UnitStruct { name: name });
                 visitor.visit_unit()
             }
             _ => self.deserialize_any(visitor),
@@ -275,8 +275,8 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         V: Visitor<'de>,
     {
         match self.peek_token() {
-            Token::NewtypeStruct(_) => {
-                assert_next_token!(self, Token::NewtypeStruct(name));
+            Token::NewtypeStruct { name: _ } => {
+                assert_next_token!(self, Token::NewtypeStruct { name: name });
                 visitor.visit_newtype_struct(self)
             }
             _ => self.deserialize_any(visitor),
@@ -289,19 +289,19 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     {
         match self.peek_token() {
             Token::Unit |
-            Token::UnitStruct(_) => {
+            Token::UnitStruct { name: _ } => {
                 self.next_token();
                 visitor.visit_unit()
             }
-            Token::Seq(_) => {
+            Token::Seq { len: _ } => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::SeqEnd, visitor)
             }
-            Token::Tuple(_) => {
+            Token::Tuple { len: _ } => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::TupleEnd, visitor)
             }
-            Token::TupleStruct(_, _) => {
+            Token::TupleStruct { name: _, len: _ } => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::TupleStructEnd, visitor)
             }
@@ -323,20 +323,20 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
                 self.next_token();
                 visitor.visit_unit()
             }
-            Token::UnitStruct(_) => {
-                assert_next_token!(self, Token::UnitStruct(name));
+            Token::UnitStruct { name: _ } => {
+                assert_next_token!(self, Token::UnitStruct { name: name });
                 visitor.visit_unit()
             }
-            Token::Seq(_) => {
+            Token::Seq { len: _ } => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::SeqEnd, visitor)
             }
-            Token::Tuple(_) => {
+            Token::Tuple { len: _ } => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::TupleEnd, visitor)
             }
-            Token::TupleStruct(_, n) => {
-                assert_next_token!(self, Token::TupleStruct(name, n));
+            Token::TupleStruct { name: _, len: n } => {
+                assert_next_token!(self, Token::TupleStruct { name: name, len: n });
                 self.visit_seq(Some(len), Token::TupleStructEnd, visitor)
             }
             _ => self.deserialize_any(visitor),
@@ -353,11 +353,11 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         V: Visitor<'de>,
     {
         match self.peek_token() {
-            Token::Struct(_, n) => {
-                assert_next_token!(self, Token::Struct(name, n));
+            Token::Struct { name: _, len: n } => {
+                assert_next_token!(self, Token::Struct { name: name, len: n });
                 self.visit_map(Some(fields.len()), Token::StructEnd, visitor)
             }
-            Token::Map(_) => {
+            Token::Map { len: _ } => {
                 self.next_token();
                 self.visit_map(Some(fields.len()), Token::MapEnd, visitor)
             }
@@ -442,10 +442,10 @@ impl<'de, 'a> EnumAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
         V: DeserializeSeed<'de>,
     {
         match self.de.peek_token() {
-            Token::UnitVariant(_, v) |
-            Token::NewtypeVariant(_, v) |
-            Token::TupleVariant(_, v, _) |
-            Token::StructVariant(_, v, _) => {
+            Token::UnitVariant { name: _, variant: v } |
+            Token::NewtypeVariant { name: _, variant: v } |
+            Token::TupleVariant { name: _, variant: v, len: _ } |
+            Token::StructVariant { name: _, variant: v, len: _ } => {
                 let de = v.into_deserializer();
                 let value = try!(seed.deserialize(de));
                 Ok((value, self))
@@ -463,7 +463,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
 
     fn unit_variant(self) -> Result<(), Error> {
         match self.de.peek_token() {
-            Token::UnitVariant(_, _) => {
+            Token::UnitVariant { name: _, variant: _ } => {
                 self.de.next_token();
                 Ok(())
             }
@@ -476,7 +476,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
         T: DeserializeSeed<'de>,
     {
         match self.de.peek_token() {
-            Token::NewtypeVariant(_, _) => {
+            Token::NewtypeVariant { name: _, variant: _ } => {
                 self.de.next_token();
                 seed.deserialize(self.de)
             }
@@ -489,7 +489,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
         V: Visitor<'de>,
     {
         match self.de.peek_token() {
-            Token::TupleVariant(_, _, enum_len) => {
+            Token::TupleVariant { name: _, variant: _, len: enum_len } => {
                 let token = self.de.next_token();
 
                 if len == enum_len {
@@ -499,7 +499,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
                     unexpected!(token);
                 }
             }
-            Token::Seq(Some(enum_len)) => {
+            Token::Seq { len: Some(enum_len) } => {
                 let token = self.de.next_token();
 
                 if len == enum_len {
@@ -517,7 +517,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
         V: Visitor<'de>,
     {
         match self.de.peek_token() {
-            Token::StructVariant(_, _, enum_len) => {
+            Token::StructVariant { name: _, variant: _, len: enum_len } => {
                 let token = self.de.next_token();
 
                 if fields.len() == enum_len {
@@ -527,7 +527,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
                     unexpected!(token);
                 }
             }
-            Token::Map(Some(enum_len)) => {
+            Token::Map { len: Some(enum_len) } => {
                 let token = self.de.next_token();
 
                 if fields.len() == enum_len {

serde_test/src/ser.rs

@@ -39,25 +39,27 @@ impl<'a> Serializer<'a> {
 }
 
 macro_rules! assert_next_token {
-    ($ser:ident, $expected:ident($a:expr)) => {
-        assert_next_token!($ser, $expected { a: $a });
+    ($ser:ident, $expected:ident) => {
+        assert_next_token!($ser, Token::$expected, true);
     };
-    ($ser:ident, $expected:ident($a:expr, $b:expr)) => {
-        assert_next_token!($ser, $expected { a: $a, b: $b });
+    ($ser:ident, $expected:ident($v:expr)) => {
+        assert_next_token!($ser, Token::$expected(v), v == $v);
     };
-    ($ser:ident, $expected:ident($a:expr, $b:expr, $c:expr)) => {
-        assert_next_token!($ser, $expected { a: $a, b: $b, c: $c });
+    ($ser:ident, $expected:ident { $($k:ident),* }) => {
+        let compare = ($($k,)*);
+        assert_next_token!($ser, Token::$expected { $($k),* }, ($($k,)*) == compare);
     };
-    ($ser:ident, $expected:ident $({ $($n:ident: $v:expr),* })*) => {
+    ($ser:ident, $pat:pat, $guard:expr) => {
         match $ser.next_token() {
-            Some(Token::$expected $(($($n),*))*) $(if $($n == $v)&&*)* => {}
+            Some($pat) if $guard => {}
+            //Some(Token::$expected $(($($n),*))*) $(if $($n == $v)&&*)* => {}
             Some(other) => {
                 panic!("expected Token::{} but serialized as {:?}",
-                       stringify!($expected), other);
+                       stringify!($pat), other);
             }
             None => {
                 panic!("expected Token::{} after end of serialized tokens",
-                       stringify!($expected));
+                       stringify!($pat));
             }
         }
     };
@@ -151,7 +153,7 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
     }
 
     fn serialize_unit_struct(self, name: &'static str) -> Result<(), Error> {
-        assert_next_token!(self, UnitStruct(name));
+        assert_next_token!(self, UnitStruct { name });
         Ok(())
     }
 
@@ -161,12 +163,12 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
         _variant_index: u32,
         variant: &'static str,
     ) -> Result<(), Error> {
-        if self.tokens.first() == Some(&Token::Enum(name)) {
+        if self.tokens.first() == Some(&Token::Enum { name }) {
             self.next_token();
             assert_next_token!(self, Str(variant));
             assert_next_token!(self, Unit);
         } else {
-            assert_next_token!(self, UnitVariant(name, variant));
+            assert_next_token!(self, UnitVariant { name, variant });
         }
         Ok(())
     }
@@ -175,7 +177,7 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
     where
         T: Serialize,
     {
-        assert_next_token!(self, NewtypeStruct(name));
+        assert_next_token!(self, NewtypeStruct { name });
         value.serialize(self)
     }
 
@@ -189,11 +191,11 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
     where
         T: Serialize,
     {
-        if self.tokens.first() == Some(&Token::Enum(name)) {
+        if self.tokens.first() == Some(&Token::Enum { name }) {
             self.next_token();
             assert_next_token!(self, Str(variant));
         } else {
-            assert_next_token!(self, NewtypeVariant(name, variant));
+            assert_next_token!(self, NewtypeVariant { name, variant });
         }
         value.serialize(self)
     }
@@ -212,17 +214,17 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
     }
 
     fn serialize_seq(self, len: Option<usize>) -> Result<Self, Error> {
-        assert_next_token!(self, Seq(len));
+        assert_next_token!(self, Seq { len });
         Ok(self)
     }
 
     fn serialize_tuple(self, len: usize) -> Result<Self, Error> {
-        assert_next_token!(self, Tuple(len));
+        assert_next_token!(self, Tuple { len });
         Ok(self)
     }
 
     fn serialize_tuple_struct(self, name: &'static str, len: usize) -> Result<Self, Error> {
-        assert_next_token!(self, TupleStruct(name, len));
+        assert_next_token!(self, TupleStruct { name, len });
         Ok(self)
     }
 
@@ -233,17 +235,17 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
         variant: &'static str,
         len: usize,
     ) -> Result<Self, Error> {
-        assert_next_token!(self, TupleVariant(name, variant, len));
+        assert_next_token!(self, TupleVariant { name, variant, len });
         Ok(self)
     }
 
     fn serialize_map(self, len: Option<usize>) -> Result<Self, Error> {
-        assert_next_token!(self, Map(len));
+        assert_next_token!(self, Map { len });
         Ok(self)
     }
 
     fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self, Error> {
-        assert_next_token!(self, Struct(name, len));
+        assert_next_token!(self, Struct { name, len });
         Ok(self)
     }
 
@@ -254,7 +256,7 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
         variant: &'static str,
         len: usize,
     ) -> Result<Self, Error> {
-        assert_next_token!(self, StructVariant(name, variant, len));
+        assert_next_token!(self, StructVariant { name, variant, len });
         Ok(self)
     }
 }

serde_test/src/token.rs

@@ -76,46 +76,46 @@ pub enum Token {
     Unit,
 
     /// A serialized unit struct of the given name.
-    UnitStruct(&'static str),
+    UnitStruct { name: &'static str },
 
     /// The header to a serialized newtype struct of the given name.
     ///
     /// Newtype structs are serialized with this header, followed by the value contained in the
     /// newtype struct.
-    NewtypeStruct(&'static str),
+    NewtypeStruct { name: &'static str },
 
     /// The header to an enum of the given name.
-    Enum(&'static str),
+    Enum { name: &'static str },
 
     /// A unit variant of an enum of the given name, of the given name.
     ///
     /// The first string represents the name of the enum, and the second represents the name of the
     /// variant.
-    UnitVariant(&'static str, &'static str),
+    UnitVariant { name: &'static str, variant: &'static str },
 
     /// The header to a newtype variant of an enum of the given name, of the given name.
     ///
     /// The first string represents the name of the enum, and the second represents the name of the
     /// variant. The value contained within this enum works the same as `StructNewType`.
-    NewtypeVariant(&'static str, &'static str),
+    NewtypeVariant { name: &'static str, variant: &'static str },
 
     /// The header to a sequence of the given length.
     ///
     /// These are serialized via `serialize_seq`, which takes an optional length. After this
     /// header is a list of elements, followed by `SeqEnd`.
-    Seq(Option<usize>),
+    Seq { len: Option<usize> },
 
     /// An indicator of the end of a sequence.
     SeqEnd,
 
     /// The header to a tuple of the given length, similar to `SeqFixedSize`.
-    Tuple(usize),
+    Tuple { len: usize },
 
     /// An indicator of the end of a tuple, similar to `SeqEnd`.
     TupleEnd,
 
     /// The header to a tuple struct of the given name and length.
-    TupleStruct(&'static str, usize),
+    TupleStruct { name: &'static str, len: usize },
 
     /// An indicator of the end of a tuple struct, similar to `TupleEnd`.
     TupleStructEnd,
@@ -124,26 +124,26 @@ pub enum Token {
     ///
     /// These are serialized via `serialize_map`, which takes an optional length. After this header
     /// is a list of key-value pairs, followed by `MapEnd`.
-    Map(Option<usize>),
+    Map { len: Option<usize> },
 
     /// An indicator of the end of a map.
     MapEnd,
 
     /// The header of a struct of the given name and length, similar to `Map`.
-    Struct(&'static str, usize),
+    Struct { name: &'static str, len: usize },
 
     /// An indicator of the end of a struct, similar to `MapEnd`.
     StructEnd,
 
     /// The header to a tuple variant of an enum of the given name, of the given name and length.
-    TupleVariant(&'static str, &'static str, usize),
+    TupleVariant { name: &'static str, variant: &'static str, len: usize },
 
     /// An indicator of the end of a tuple variant, similar to `TupleEnd`.
     TupleVariantEnd,
 
     /// The header of a struct variant of an enum of the given name, of the given name and length,
     /// similar to `Struct`.
-    StructVariant(&'static str, &'static str, usize),
+    StructVariant { name: &'static str, variant: &'static str, len: usize },
 
     /// An indicator of the end of a struct, similar to `StructEnd`.
     StructVariantEnd,