Add newtype handlers to speed up parsing newtype structs and variants

src/reader_serde.rs

@@ -483,6 +483,14 @@ impl<'a, R: Read> serde::Deserializer for Deserializer<'a, R> {
     {
         self.visit_tuple(fields.len(), visitor)
     }
+
+    fn visit_newtype_struct<V>(&mut self,
+                               _name: &str,
+                               mut visitor: V) -> Result<V::Value, Self::Error>
+        where V: serde::de::Visitor,
+    {
+        visitor.visit_newtype_struct(self)
+    }
 }
 
 impl<'a, R: Read> serde::de::VariantVisitor for Deserializer<'a, R> {
@@ -500,6 +508,12 @@ impl<'a, R: Read> serde::de::VariantVisitor for Deserializer<'a, R> {
         Ok(())
     }
 
+    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
+        where T: serde::de::Deserialize,
+    {
+        serde::de::Deserialize::deserialize(self)
+    }
+
     fn visit_tuple<V>(&mut self,
                       len: usize,
                       visitor: V) -> Result<V::Value, Self::Error>

src/writer_serde.rs

@@ -218,6 +218,14 @@ impl<'a, W: Write> serde::Serializer for Serializer<'a, W> {
         value.serialize(self)
     }
 
+    fn visit_newtype_struct<T>(&mut self,
+                               _name: &str,
+                               value: T) -> SerializeResult<()>
+        where T: serde::ser::Serialize,
+    {
+        value.serialize(self)
+    }
+
     fn visit_unit_variant(&mut self,
                           _name: &str,
                           variant_index: usize,

tests/test_serde.rs

@@ -133,6 +133,14 @@ fn test_nested_struct() {
     });
 }
 
+#[test]
+fn test_struct_newtype() {
+    #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)]
+    struct NewtypeStr(usize);
+
+    the_same(NewtypeStr(5));
+}
+
 #[test]
 fn test_struct_tuple() {
     #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)]
@@ -154,24 +162,13 @@ fn test_enum() {
     enum TestEnum {
         NoArg,
         OneArg(usize),
-        AnotherNoArg
-    }
-    the_same(TestEnum::NoArg);
-    the_same(TestEnum::OneArg(4));
-    the_same(TestEnum::AnotherNoArg);
-}
-
-#[test]
-fn test_struct_enum() {
-    #[derive(RustcEncodable, RustcDecodable, Serialize, Deserialize, PartialEq, Debug)]
-    enum TestEnum {
-        NoArg,
-        OneArg(usize),
+        Args(usize, usize),
         AnotherNoArg,
         StructLike{x: usize, y: f32}
     }
     the_same(TestEnum::NoArg);
     the_same(TestEnum::OneArg(4));
+    the_same(TestEnum::Args(4, 5));
     the_same(TestEnum::AnotherNoArg);
     the_same(TestEnum::StructLike{x: 4, y: 3.14159});
     the_same(vec![TestEnum::NoArg, TestEnum::OneArg(5), TestEnum::AnotherNoArg,