diff --git a/serde_test/src/de.rs b/serde_test/src/de.rs
index 8bfb8f70..fcbb762b 100644
--- a/serde_test/src/de.rs
+++ b/serde_test/src/de.rs
@@ -104,32 +104,32 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             Token::Bytes(v) => visitor.visit_bytes(v),
             Token::BorrowedBytes(v) => visitor.visit_borrowed_bytes(v),
             Token::ByteBuf(v) => visitor.visit_byte_buf(v.to_vec()),
-            Token::Option(false) => visitor.visit_none(),
-            Token::Option(true) => visitor.visit_some(self),
+            Token::None => visitor.visit_none(),
+            Token::Some => visitor.visit_some(self),
             Token::Unit => visitor.visit_unit(),
             Token::UnitStruct(_name) => visitor.visit_unit(),
-            Token::StructNewType(_name) => visitor.visit_newtype_struct(self),
-            Token::SeqStart(len) => {
+            Token::NewtypeStruct(_name) => visitor.visit_newtype_struct(self),
+            Token::Seq(len) => {
                 self.visit_seq(len, Token::SeqEnd, visitor)
             }
-            Token::SeqArrayStart(len) => {
+            Token::SeqFixedSize(len) => {
                 self.visit_seq(Some(len), Token::SeqEnd, visitor)
             }
-            Token::TupleStart(len) => {
+            Token::Tuple(len) => {
                 self.visit_seq(Some(len), Token::TupleEnd, visitor)
             }
-            Token::TupleStructStart(_, len) => {
+            Token::TupleStruct(_, len) => {
                 self.visit_seq(Some(len),
                                Token::TupleStructEnd,
                                visitor)
             }
-            Token::MapStart(len) => {
+            Token::Map(len) => {
                 self.visit_map(len, Token::MapEnd, visitor)
             }
-            Token::StructStart(_, len) => {
+            Token::Struct(_, len) => {
                 self.visit_map(Some(len), Token::StructEnd, visitor)
             }
-            Token::EnumStart(_) => {
+            Token::Enum(_) => {
                 let variant = self.next_token().ok_or(Error::EndOfTokens)?;
                 let next = *self.tokens.first().ok_or(Error::EndOfTokens)?;
                 match (variant, next) {
@@ -153,14 +153,14 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
                     }
                 }
             }
-            Token::EnumUnit(_, variant) => visitor.visit_str(variant),
-            Token::EnumNewType(_, variant) => {
+            Token::UnitVariant(_, variant) => visitor.visit_str(variant),
+            Token::NewtypeVariant(_, variant) => {
                 visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Any))
             }
-            Token::EnumSeqStart(_, variant, _) => {
+            Token::TupleVariant(_, variant, _) => {
                 visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Seq))
             }
-            Token::EnumMapStart(_, variant, _) => {
+            Token::StructVariant(_, variant, _) => {
                 visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Map))
             }
             Token::SeqEnd |
@@ -168,8 +168,8 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             Token::TupleStructEnd |
             Token::MapEnd |
             Token::StructEnd |
-            Token::EnumSeqEnd |
-            Token::EnumMapEnd => Err(Error::UnexpectedToken(token)),
+            Token::TupleVariantEnd |
+            Token::StructVariantEnd => Err(Error::UnexpectedToken(token)),
         }
     }
 
@@ -180,11 +180,11 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     {
         match self.tokens.first() {
             Some(&Token::Unit) |
-            Some(&Token::Option(false)) => {
+            Some(&Token::None) => {
                 self.next_token();
                 visitor.visit_none()
             }
-            Some(&Token::Option(true)) => {
+            Some(&Token::Some) => {
                 self.next_token();
                 visitor.visit_some(self)
             }
@@ -201,15 +201,15 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         where V: Visitor<'de>
     {
         match self.tokens.first() {
-            Some(&Token::EnumStart(n)) if name == n => {
+            Some(&Token::Enum(n)) if name == n => {
                 self.next_token();
 
                 visitor.visit_enum(DeserializerEnumVisitor { de: self })
             }
-            Some(&Token::EnumUnit(n, _)) |
-            Some(&Token::EnumNewType(n, _)) |
-            Some(&Token::EnumSeqStart(n, _, _)) |
-            Some(&Token::EnumMapStart(n, _, _)) if name == n => {
+            Some(&Token::UnitVariant(n, _)) |
+            Some(&Token::NewtypeVariant(n, _)) |
+            Some(&Token::TupleVariant(n, _, _)) |
+            Some(&Token::StructVariant(n, _, _)) if name == n => {
                 visitor.visit_enum(DeserializerEnumVisitor { de: self })
             }
             Some(_) => {
@@ -241,7 +241,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         where V: Visitor<'de>
     {
         match self.tokens.first() {
-            Some(&Token::StructNewType(n)) => {
+            Some(&Token::NewtypeStruct(n)) => {
                 self.next_token();
                 if name == n {
                     visitor.visit_newtype_struct(self)
@@ -258,7 +258,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         where V: Visitor<'de>
     {
         match self.tokens.first() {
-            Some(&Token::SeqArrayStart(_)) => {
+            Some(&Token::SeqFixedSize(_)) => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::SeqEnd, visitor)
             }
@@ -276,19 +276,19 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
                 self.next_token();
                 visitor.visit_unit()
             }
-            Some(&Token::SeqStart(_)) => {
+            Some(&Token::Seq(_)) => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::SeqEnd, visitor)
             }
-            Some(&Token::SeqArrayStart(_)) => {
+            Some(&Token::SeqFixedSize(_)) => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::SeqEnd, visitor)
             }
-            Some(&Token::TupleStart(_)) => {
+            Some(&Token::Tuple(_)) => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::TupleEnd, visitor)
             }
-            Some(&Token::TupleStructStart(_, _)) => {
+            Some(&Token::TupleStruct(_, _)) => {
                 self.next_token();
                 self.visit_seq(Some(len),
                                Token::TupleStructEnd,
@@ -319,19 +319,19 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
                     Err(Error::InvalidName(n))
                 }
             }
-            Some(&Token::SeqStart(_)) => {
+            Some(&Token::Seq(_)) => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::SeqEnd, visitor)
             }
-            Some(&Token::SeqArrayStart(_)) => {
+            Some(&Token::SeqFixedSize(_)) => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::SeqEnd, visitor)
             }
-            Some(&Token::TupleStart(_)) => {
+            Some(&Token::Tuple(_)) => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::TupleEnd, visitor)
             }
-            Some(&Token::TupleStructStart(n, _)) => {
+            Some(&Token::TupleStruct(n, _)) => {
                 self.next_token();
                 if name == n {
                     self.visit_seq(Some(len),
@@ -354,7 +354,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         where V: Visitor<'de>
     {
         match self.tokens.first() {
-            Some(&Token::StructStart(n, _)) => {
+            Some(&Token::Struct(n, _)) => {
                 self.next_token();
                 if name == n {
                     self.visit_map(Some(fields.len()),
@@ -364,7 +364,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
                     Err(Error::InvalidName(n))
                 }
             }
-            Some(&Token::MapStart(_)) => {
+            Some(&Token::Map(_)) => {
                 self.next_token();
                 self.visit_map(Some(fields.len()), Token::MapEnd, visitor)
             }
@@ -448,10 +448,10 @@ impl<'de, 'a> EnumVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
         where V: DeserializeSeed<'de>
     {
         match self.de.tokens.first() {
-            Some(&Token::EnumUnit(_, v)) |
-            Some(&Token::EnumNewType(_, v)) |
-            Some(&Token::EnumSeqStart(_, v, _)) |
-            Some(&Token::EnumMapStart(_, v, _)) => {
+            Some(&Token::UnitVariant(_, v)) |
+            Some(&Token::NewtypeVariant(_, v)) |
+            Some(&Token::TupleVariant(_, v, _)) |
+            Some(&Token::StructVariant(_, v, _)) => {
                 let de = v.into_deserializer();
                 let value = try!(seed.deserialize(de));
                 Ok((value, self))
@@ -470,7 +470,7 @@ impl<'de, 'a> VariantVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
 
     fn visit_unit(self) -> Result<(), Error> {
         match self.de.tokens.first() {
-            Some(&Token::EnumUnit(_, _)) => {
+            Some(&Token::UnitVariant(_, _)) => {
                 self.de.next_token();
                 Ok(())
             }
@@ -483,7 +483,7 @@ impl<'de, 'a> VariantVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
         where T: DeserializeSeed<'de>
     {
         match self.de.tokens.first() {
-            Some(&Token::EnumNewType(_, _)) => {
+            Some(&Token::NewtypeVariant(_, _)) => {
                 self.de.next_token();
                 seed.deserialize(self.de)
             }
@@ -496,16 +496,16 @@ impl<'de, 'a> VariantVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
         where V: Visitor<'de>
     {
         match self.de.tokens.first() {
-            Some(&Token::EnumSeqStart(_, _, enum_len)) => {
+            Some(&Token::TupleVariant(_, _, enum_len)) => {
                 let token = self.de.next_token().unwrap();
 
                 if len == enum_len {
-                    self.de.visit_seq(Some(len), Token::EnumSeqEnd, visitor)
+                    self.de.visit_seq(Some(len), Token::TupleVariantEnd, visitor)
                 } else {
                     Err(Error::UnexpectedToken(token))
                 }
             }
-            Some(&Token::SeqStart(Some(enum_len))) => {
+            Some(&Token::Seq(Some(enum_len))) => {
                 let token = self.de.next_token().unwrap();
 
                 if len == enum_len {
@@ -523,18 +523,18 @@ impl<'de, 'a> VariantVisitor<'de> for DeserializerEnumVisitor<'a, 'de> {
         where V: Visitor<'de>
     {
         match self.de.tokens.first() {
-            Some(&Token::EnumMapStart(_, _, enum_len)) => {
+            Some(&Token::StructVariant(_, _, enum_len)) => {
                 let token = self.de.next_token().unwrap();
 
                 if fields.len() == enum_len {
                     self.de.visit_map(Some(fields.len()),
-                                      Token::EnumMapEnd,
+                                      Token::StructVariantEnd,
                                       visitor)
                 } else {
                     Err(Error::UnexpectedToken(token))
                 }
             }
-            Some(&Token::MapStart(Some(enum_len))) => {
+            Some(&Token::Map(Some(enum_len))) => {
                 let token = self.de.next_token().unwrap();
 
                 if fields.len() == enum_len {
@@ -605,11 +605,11 @@ impl<'de, 'a> MapVisitor<'de> for EnumMapVisitor<'a, 'de> {
                     let visitor = DeserializerSeqVisitor {
                         de: self.de,
                         len: None,
-                        end: Token::EnumSeqEnd,
+                        end: Token::TupleVariantEnd,
                     };
                     try!(seed.deserialize(SeqVisitorDeserializer::new(visitor)))
                 };
-                try!(self.de.expect_token(Token::EnumSeqEnd));
+                try!(self.de.expect_token(Token::TupleVariantEnd));
                 Ok(value)
             }
             EnumFormat::Map => {
@@ -617,11 +617,11 @@ impl<'de, 'a> MapVisitor<'de> for EnumMapVisitor<'a, 'de> {
                     let visitor = DeserializerMapVisitor {
                         de: self.de,
                         len: None,
-                        end: Token::EnumMapEnd,
+                        end: Token::StructVariantEnd,
                     };
                     try!(seed.deserialize(MapVisitorDeserializer::new(visitor)))
                 };
-                try!(self.de.expect_token(Token::EnumMapEnd));
+                try!(self.de.expect_token(Token::StructVariantEnd));
                 Ok(value)
             }
             EnumFormat::Any => seed.deserialize(&mut *self.de),
diff --git a/serde_test/src/ser.rs b/serde_test/src/ser.rs
index 919565b1..2a82970f 100644
--- a/serde_test/src/ser.rs
+++ b/serde_test/src/ser.rs
@@ -149,12 +149,12 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
                               _variant_index: usize,
                               variant: &'static str)
                               -> Result<(), Error> {
-        if self.tokens.first() == Some(&Token::EnumStart(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, EnumUnit(name, variant));
+            assert_next_token!(self, UnitVariant(name, variant));
         }
         Ok(())
     }
@@ -162,7 +162,7 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
     fn serialize_newtype_struct<T: ?Sized>(self, name: &'static str, value: &T) -> Result<(), Error>
         where T: Serialize
     {
-        assert_next_token!(self, StructNewType(name));
+        assert_next_token!(self, NewtypeStruct(name));
         value.serialize(self)
     }
 
@@ -174,44 +174,44 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
                                             -> Result<(), Error>
         where T: Serialize
     {
-        if self.tokens.first() == Some(&Token::EnumStart(name)) {
+        if self.tokens.first() == Some(&Token::Enum(name)) {
             self.next_token();
             assert_next_token!(self, Str(variant));
         } else {
-            assert_next_token!(self, EnumNewType(name, variant));
+            assert_next_token!(self, NewtypeVariant(name, variant));
         }
         value.serialize(self)
     }
 
     fn serialize_none(self) -> Result<(), Error> {
-        assert_next_token!(self, Option(false));
+        assert_next_token!(self, None);
         Ok(())
     }
 
     fn serialize_some<T: ?Sized>(self, value: &T) -> Result<(), Error>
         where T: Serialize
     {
-        assert_next_token!(self, Option(true));
+        assert_next_token!(self, Some);
         value.serialize(self)
     }
 
     fn serialize_seq(self, len: Option<usize>) -> Result<Self, Error> {
-        assert_next_token!(self, SeqStart(len));
+        assert_next_token!(self, Seq(len));
         Ok(self)
     }
 
     fn serialize_seq_fixed_size(self, len: usize) -> Result<Self, Error> {
-        assert_next_token!(self, SeqArrayStart(len));
+        assert_next_token!(self, SeqFixedSize(len));
         Ok(self)
     }
 
     fn serialize_tuple(self, len: usize) -> Result<Self, Error> {
-        assert_next_token!(self, TupleStart(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, TupleStructStart(name, len));
+        assert_next_token!(self, TupleStruct(name, len));
         Ok(self)
     }
 
@@ -221,17 +221,17 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
                                variant: &'static str,
                                len: usize)
                                -> Result<Self, Error> {
-        assert_next_token!(self, EnumSeqStart(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, MapStart(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, StructStart(name, len));
+        assert_next_token!(self, Struct(name, len));
         Ok(self)
     }
 
@@ -241,7 +241,7 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
                                 variant: &'static str,
                                 len: usize)
                                 -> Result<Self, Error> {
-        assert_next_token!(self, EnumMapStart(name, variant, len));
+        assert_next_token!(self, StructVariant(name, variant, len));
         Ok(self)
     }
 }
@@ -305,7 +305,7 @@ impl<'s, 'a> ser::SerializeTupleVariant for &'s mut Serializer<'a> {
     }
 
     fn end(self) -> Result<(), Error> {
-        assert_next_token!(self, EnumSeqEnd);
+        assert_next_token!(self, TupleVariantEnd);
         Ok(())
     }
 }
@@ -367,7 +367,7 @@ impl<'s, 'a> ser::SerializeStructVariant for &'s mut Serializer<'a> {
     }
 
     fn end(self) -> Result<(), Self::Error> {
-        assert_next_token!(self, EnumMapEnd);
+        assert_next_token!(self, StructVariantEnd);
         Ok(())
     }
 }