Get serde2 compiling again

benches/bench_log.rs

@@ -18,6 +18,8 @@ use serde::json;
 use serde::ser::Serialize;
 use serde::ser;
 
+use serialize::Encodable;
+
 #[deriving(Show, PartialEq, Encodable, Decodable)]
 #[deriving_serialize]
 #[deriving_deserialize]
@@ -611,12 +613,6 @@ impl MyMemWriter0 {
             buf: Vec::with_capacity(cap)
         }
     }
-
-    #[inline]
-    pub fn clear(&mut self) { self.buf.clear() }
-
-    #[inline]
-    pub fn unwrap(self) -> Vec<u8> { self.buf }
 }
 
 
@@ -638,12 +634,6 @@ impl MyMemWriter1 {
             buf: Vec::with_capacity(cap)
         }
     }
-
-    #[inline]
-    pub fn clear(&mut self) { self.buf.clear() }
-
-    #[inline]
-    pub fn unwrap(self) -> Vec<u8> { self.buf }
 }
 
 // LLVM isn't yet able to lower `Vec::push_all` into a memcpy, so this helps
@@ -685,7 +675,7 @@ fn test_encoder() {
     let mut wr = Vec::with_capacity(1024);
 
     {
-        let mut encoder = serialize::json::Encoder::new(&mut wr as &mut io::Writer);
+        let mut encoder = serialize::json::Encoder::new(&mut wr as &mut Writer);
         log.encode(&mut encoder).unwrap();
     }
 
@@ -695,11 +685,21 @@ fn test_encoder() {
 #[bench]
 fn bench_encoder(b: &mut Bencher) {
     let log = Log::new();
-    let json = serialize::json::encode(&log);
+
-    b.bytes = json.len() as u64;
+    let mut wr = Vec::with_capacity(1024);
+
+    {
+        let mut encoder = serialize::json::Encoder::new(&mut wr as &mut Writer);
+        log.encode(&mut encoder).unwrap();
+    }
+
+    b.bytes = wr.len() as u64;
 
     b.iter(|| {
-        let _ = serialize::json::encode(&log);
+        wr.clear();
+
+        let mut encoder = serialize::json::Encoder::new(&mut wr as &mut Writer);
+        log.encode(&mut encoder).unwrap();
     });
 }
 
@@ -707,7 +707,7 @@ fn bench_encoder(b: &mut Bencher) {
 fn test_serializer() {
     let log = Log::new();
     let json = json::to_vec(&log);
-    assert_eq!(json.as_slice(), JSON_STR.as_bytes());
+    assert_eq!(json, JSON_STR.as_bytes());
 }
 
 #[bench]
@@ -717,7 +717,7 @@ fn bench_serializer(b: &mut Bencher) {
     b.bytes = json.len() as u64;
 
     b.iter(|| {
-        let _json = json::to_vec(&log);
+        let _ = json::to_vec(&log);
     });
 }
 
@@ -760,7 +760,7 @@ fn test_serializer_my_mem_writer0() {
         log.serialize(&mut serializer).unwrap();
     }
 
-    assert_eq!(wr.unwrap().as_slice(), JSON_STR.as_bytes());
+    assert_eq!(wr.buf.as_slice(), JSON_STR.as_bytes());
 }
 
 #[bench]
@@ -772,7 +772,7 @@ fn bench_serializer_my_mem_writer0(b: &mut Bencher) {
     let mut wr = MyMemWriter0::with_capacity(1024);
 
     b.iter(|| {
-        wr.clear();
+        wr.buf.clear();
 
         let mut serializer = json::Serializer::new(wr.by_ref());
         log.serialize(&mut serializer).unwrap();
@@ -790,7 +790,7 @@ fn test_serializer_my_mem_writer1() {
         log.serialize(&mut serializer).unwrap();
     }
 
-    assert_eq!(wr.unwrap().as_slice(), JSON_STR.as_bytes());
+    assert_eq!(wr.buf.as_slice(), JSON_STR.as_bytes());
 }
 
 #[bench]
@@ -802,7 +802,7 @@ fn bench_serializer_my_mem_writer1(b: &mut Bencher) {
     let mut wr = MyMemWriter1::with_capacity(1024);
 
     b.iter(|| {
-        wr.clear();
+        wr.buf.clear();
 
         let mut serializer = json::Serializer::new(wr.by_ref());
         log.serialize(&mut serializer).unwrap();
@@ -819,165 +819,165 @@ fn bench_copy(b: &mut Bencher) {
     });
 }
 
-fn manual_no_escape<W: Writer>(mut wr: W, log: &Log) {
+fn manual_no_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str("{\"timestamp\":").unwrap();
-    (write!(&mut wr, "{}", log.timestamp)).unwrap();
+    (write!(wr, "{}", log.timestamp)).unwrap();
     wr.write_str(",\"zone_id\":").unwrap();
-    (write!(&mut wr, "{}", log.zone_id)).unwrap();
+    (write!(wr, "{}", log.zone_id)).unwrap();
     wr.write_str(",\"zone_plan\":").unwrap();
-    (write!(&mut wr, "{}", log.zone_plan as uint)).unwrap();
+    (write!(wr, "{}", log.zone_plan as uint)).unwrap();
 
     wr.write_str(",\"http\":{\"protocol\":").unwrap();
-    (write!(&mut wr, "{}", log.http.protocol as uint)).unwrap();
+    (write!(wr, "{}", log.http.protocol as uint)).unwrap();
     wr.write_str(",\"status\":").unwrap();
-    (write!(&mut wr, "{}", log.http.status)).unwrap();
+    (write!(wr, "{}", log.http.status)).unwrap();
     wr.write_str(",\"host_status\":").unwrap();
-    (write!(&mut wr, "{}", log.http.host_status)).unwrap();
+    (write!(wr, "{}", log.http.host_status)).unwrap();
     wr.write_str(",\"up_status\":").unwrap();
-    (write!(&mut wr, "{}", log.http.up_status)).unwrap();
+    (write!(wr, "{}", log.http.up_status)).unwrap();
     wr.write_str(",\"method\":").unwrap();
-    (write!(&mut wr, "{}", log.http.method as uint)).unwrap();
+    (write!(wr, "{}", log.http.method as uint)).unwrap();
     wr.write_str(",\"content_type\":").unwrap();
-    (write!(&mut wr, "\"{}\"", log.http.content_type)).unwrap();
+    (write!(wr, "\"{}\"", log.http.content_type)).unwrap();
     wr.write_str(",\"user_agent\":").unwrap();
-    (write!(&mut wr, "\"{}\"", log.http.user_agent)).unwrap();
+    (write!(wr, "\"{}\"", log.http.user_agent)).unwrap();
     wr.write_str(",\"referer\":").unwrap();
-    (write!(&mut wr, "\"{}\"", log.http.referer)).unwrap();
+    (write!(wr, "\"{}\"", log.http.referer)).unwrap();
     wr.write_str(",\"request_uri\":").unwrap();
-    (write!(&mut wr, "\"{}\"", log.http.request_uri)).unwrap();
+    (write!(wr, "\"{}\"", log.http.request_uri)).unwrap();
 
     wr.write_str("},\"origin\":{").unwrap();
 
     wr.write_str("\"ip\":").unwrap();
-    (write!(&mut wr, "\"{}\"", log.origin.ip)).unwrap();
+    (write!(wr, "\"{}\"", log.origin.ip)).unwrap();
     wr.write_str(",\"port\":").unwrap();
-    (write!(&mut wr, "{}", log.origin.port)).unwrap();
+    (write!(wr, "{}", log.origin.port)).unwrap();
     wr.write_str(",\"hostname\":").unwrap();
-    (write!(&mut wr, "\"{}\"", log.origin.hostname)).unwrap();
+    (write!(wr, "\"{}\"", log.origin.hostname)).unwrap();
 
     wr.write_str(",\"protocol\":").unwrap();
-    (write!(&mut wr, "{}", log.origin.protocol as uint)).unwrap();
+    (write!(wr, "{}", log.origin.protocol as uint)).unwrap();
 
     wr.write_str("},\"country\":").unwrap();
-    (write!(&mut wr, "{}", log.country as uint)).unwrap();
+    (write!(wr, "{}", log.country as uint)).unwrap();
     wr.write_str(",\"cache_status\":").unwrap();
-    (write!(&mut wr, "{}", log.cache_status as uint)).unwrap();
+    (write!(wr, "{}", log.cache_status as uint)).unwrap();
     wr.write_str(",\"server_ip\":").unwrap();
-    (write!(&mut wr, "\"{}\"", log.server_ip)).unwrap();
+    (write!(wr, "\"{}\"", log.server_ip)).unwrap();
     wr.write_str(",\"server_name\":").unwrap();
-    (write!(&mut wr, "\"{}\"", log.server_name)).unwrap();
+    (write!(wr, "\"{}\"", log.server_name)).unwrap();
     wr.write_str(",\"remote_ip\":").unwrap();
-    (write!(&mut wr, "\"{}\"", log.remote_ip)).unwrap();
+    (write!(wr, "\"{}\"", log.remote_ip)).unwrap();
     wr.write_str(",\"bytes_dlv\":").unwrap();
-    (write!(&mut wr, "{}", log.bytes_dlv)).unwrap();
+    (write!(wr, "{}", log.bytes_dlv)).unwrap();
 
     wr.write_str(",\"ray_id\":").unwrap();
-    (write!(&mut wr, "\"{}\"", log.ray_id)).unwrap();
+    (write!(wr, "\"{}\"", log.ray_id)).unwrap();
     wr.write_str("}").unwrap();
 }
 
-fn manual_escape<W: Writer>(mut wr: W, log: &Log) {
+fn manual_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str("{").unwrap();
-    escape_str(&mut wr, "timestamp").unwrap();
+    escape_str(wr, "timestamp").unwrap();
     wr.write_str(":").unwrap();
-    (write!(&mut wr, "{}", log.timestamp)).unwrap();
+    (write!(wr, "{}", log.timestamp)).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "zone_id").unwrap();
+    escape_str(wr, "zone_id").unwrap();
     wr.write_str(":").unwrap();
-    (write!(&mut wr, "{}", log.zone_id)).unwrap();
+    (write!(wr, "{}", log.zone_id)).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "zone_plan").unwrap();
+    escape_str(wr, "zone_plan").unwrap();
     wr.write_str(":").unwrap();
-    (write!(&mut wr, "{}", log.zone_plan as int)).unwrap();
+    (write!(wr, "{}", log.zone_plan as int)).unwrap();
 
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "http").unwrap();
+    escape_str(wr, "http").unwrap();
     wr.write_str(":{").unwrap();
-    escape_str(&mut wr, "protocol").unwrap();
+    escape_str(wr, "protocol").unwrap();
     wr.write_str(":").unwrap();
-    (write!(&mut wr, "{}", log.http.protocol as uint)).unwrap();
+    (write!(wr, "{}", log.http.protocol as uint)).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "status").unwrap();
+    escape_str(wr, "status").unwrap();
     wr.write_str(":").unwrap();
-    (write!(&mut wr, "{}", log.http.status)).unwrap();
+    (write!(wr, "{}", log.http.status)).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "host_status").unwrap();
+    escape_str(wr, "host_status").unwrap();
     wr.write_str(":").unwrap();
-    (write!(&mut wr, "{}", log.http.host_status)).unwrap();
+    (write!(wr, "{}", log.http.host_status)).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "up_status").unwrap();
+    escape_str(wr, "up_status").unwrap();
     wr.write_str(":").unwrap();
-    (write!(&mut wr, "{}", log.http.up_status)).unwrap();
+    (write!(wr, "{}", log.http.up_status)).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "method").unwrap();
+    escape_str(wr, "method").unwrap();
     wr.write_str(":").unwrap();
-    (write!(&mut wr, "{}", log.http.method as uint)).unwrap();
+    (write!(wr, "{}", log.http.method as uint)).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "content_type").unwrap();
+    escape_str(wr, "content_type").unwrap();
     wr.write_str(":").unwrap();
-    escape_str(&mut wr, log.http.content_type.as_slice()).unwrap();
+    escape_str(wr, log.http.content_type.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "user_agent").unwrap();
+    escape_str(wr, "user_agent").unwrap();
     wr.write_str(":").unwrap();
-    escape_str(&mut wr, log.http.user_agent.as_slice()).unwrap();
+    escape_str(wr, log.http.user_agent.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "referer").unwrap();
+    escape_str(wr, "referer").unwrap();
     wr.write_str(":").unwrap();
-    escape_str(&mut wr, log.http.referer.as_slice()).unwrap();
+    escape_str(wr, log.http.referer.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "request_uri").unwrap();
+    escape_str(wr, "request_uri").unwrap();
     wr.write_str(":").unwrap();
-    escape_str(&mut wr, log.http.request_uri.as_slice()).unwrap();
+    escape_str(wr, log.http.request_uri.as_slice()).unwrap();
 
     wr.write_str("},").unwrap();
-    escape_str(&mut wr, "origin").unwrap();
+    escape_str(wr, "origin").unwrap();
     wr.write_str(":{").unwrap();
 
-    escape_str(&mut wr, "ip").unwrap();
+    escape_str(wr, "ip").unwrap();
     wr.write_str(":").unwrap();
-    escape_str(&mut wr, log.origin.ip.as_slice()).unwrap();
+    escape_str(wr, log.origin.ip.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "port").unwrap();
+    escape_str(wr, "port").unwrap();
     wr.write_str(":").unwrap();
-    (write!(&mut wr, "{}", log.origin.port)).unwrap();
+    (write!(wr, "{}", log.origin.port)).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "hostname").unwrap();
+    escape_str(wr, "hostname").unwrap();
     wr.write_str(":").unwrap();
-    escape_str(&mut wr, log.origin.hostname.as_slice()).unwrap();
+    escape_str(wr, log.origin.hostname.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "protocol").unwrap();
+    escape_str(wr, "protocol").unwrap();
     wr.write_str(":").unwrap();
-    (write!(&mut wr, "{}", log.origin.protocol as uint)).unwrap();
+    (write!(wr, "{}", log.origin.protocol as uint)).unwrap();
 
     wr.write_str("},").unwrap();
-    escape_str(&mut wr, "country").unwrap();
+    escape_str(wr, "country").unwrap();
     wr.write_str(":").unwrap();
-    (write!(&mut wr, "{}", log.country as uint)).unwrap();
+    (write!(wr, "{}", log.country as uint)).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "cache_status").unwrap();
+    escape_str(wr, "cache_status").unwrap();
     wr.write_str(":").unwrap();
-    (write!(&mut wr, "{}", log.cache_status as uint)).unwrap();
+    (write!(wr, "{}", log.cache_status as uint)).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "server_ip").unwrap();
+    escape_str(wr, "server_ip").unwrap();
     wr.write_str(":").unwrap();
-    escape_str(&mut wr, log.server_ip.as_slice()).unwrap();
+    escape_str(wr, log.server_ip.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "server_name").unwrap();
+    escape_str(wr, "server_name").unwrap();
     wr.write_str(":").unwrap();
-    escape_str(&mut wr, log.server_name.as_slice()).unwrap();
+    escape_str(wr, log.server_name.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "remote_ip").unwrap();
+    escape_str(wr, "remote_ip").unwrap();
     wr.write_str(":").unwrap();
-    escape_str(&mut wr, log.remote_ip.as_slice()).unwrap();
+    escape_str(wr, log.remote_ip.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "bytes_dlv").unwrap();
+    escape_str(wr, "bytes_dlv").unwrap();
     wr.write_str(":").unwrap();
-    (write!(&mut wr, "{}", log.bytes_dlv)).unwrap();
+    (write!(wr, "{}", log.bytes_dlv)).unwrap();
 
     wr.write_str(",").unwrap();
-    escape_str(&mut wr, "ray_id").unwrap();
+    escape_str(wr, "ray_id").unwrap();
     wr.write_str(":").unwrap();
-    escape_str(&mut wr, log.ray_id.as_slice()).unwrap();
+    escape_str(wr, log.ray_id.as_slice()).unwrap();
     wr.write_str("}").unwrap();
 }
 
@@ -986,7 +986,7 @@ fn test_manual_vec_no_escape() {
     let log = Log::new();
 
     let mut wr = Vec::with_capacity(1024);
-    manual_no_escape(wr.by_ref(), &log);
+    manual_no_escape(&mut wr, &log);
 
     let json = String::from_utf8(wr).unwrap();
     assert_eq!(JSON_STR, json.as_slice());
@@ -997,12 +997,12 @@ fn bench_manual_vec_no_escape(b: &mut Bencher) {
     let log = Log::new();
 
     let mut wr = Vec::with_capacity(1024);
-    manual_no_escape(wr.by_ref(), &log);
+    manual_no_escape(&mut wr, &log);
     b.bytes = wr.len() as u64;
 
     b.iter(|| {
         wr.clear();
-        manual_no_escape(wr.by_ref(), &log);
+        manual_no_escape(&mut wr, &log);
     });
 }
 
@@ -1011,7 +1011,7 @@ fn test_manual_vec_escape() {
     let log = Log::new();
 
     let mut wr = Vec::with_capacity(1024);
-    manual_escape(wr.by_ref(), &log);
+    manual_escape(&mut wr, &log);
 
     let json = String::from_utf8(wr).unwrap();
     assert_eq!(JSON_STR, json.as_slice());
@@ -1022,13 +1022,13 @@ fn bench_manual_vec_escape(b: &mut Bencher) {
     let log = Log::new();
 
     let mut wr = Vec::with_capacity(1024);
-    manual_escape(wr.by_ref(), &log);
+    manual_escape(&mut wr, &log);
     b.bytes = wr.len() as u64;
 
     b.iter(|| {
         wr.clear();
 
-        manual_escape(wr.by_ref(), &log);
+        manual_escape(&mut wr, &log);
     });
 }
 
@@ -1037,9 +1037,9 @@ fn test_manual_my_mem_writer0_no_escape() {
     let log = Log::new();
 
     let mut wr = MyMemWriter0::with_capacity(1000);
-    manual_no_escape(wr.by_ref(), &log);
+    manual_no_escape(&mut wr, &log);
 
-    let json = String::from_utf8(wr.unwrap()).unwrap();
+    let json = String::from_utf8(wr.buf).unwrap();
     assert_eq!(JSON_STR, json.as_slice());
 }
 
@@ -1047,14 +1047,14 @@ fn test_manual_my_mem_writer0_no_escape() {
 fn bench_manual_my_mem_writer0_no_escape(b: &mut Bencher) {
     let log = Log::new();
 
-    let mut wr = MyMemWriter0::with_capacity(1000);
+    let mut wr = MyMemWriter0::with_capacity(1024);
-    manual_no_escape(wr.by_ref(), &log);
+    manual_no_escape(&mut wr, &log);
     b.bytes = wr.buf.len() as u64;
 
     b.iter(|| {
-        wr.clear();
+        wr.buf.clear();
 
-        manual_no_escape(wr.by_ref(), &log);
+        manual_no_escape(&mut wr, &log);
     });
 }
 
@@ -1063,9 +1063,9 @@ fn test_manual_my_mem_writer0_escape() {
     let log = Log::new();
 
     let mut wr = MyMemWriter0::with_capacity(1024);
-    manual_escape(wr.by_ref(), &log);
+    manual_escape(&mut wr, &log);
 
-    let json = String::from_utf8(wr.unwrap()).unwrap();
+    let json = String::from_utf8(wr.buf).unwrap();
     assert_eq!(JSON_STR, json.as_slice());
 }
 
@@ -1074,13 +1074,13 @@ fn bench_manual_my_mem_writer0_escape(b: &mut Bencher) {
     let log = Log::new();
 
     let mut wr = MyMemWriter0::with_capacity(1024);
-    manual_escape(wr.by_ref(), &log);
+    manual_escape(&mut wr, &log);
     b.bytes = wr.buf.len() as u64;
 
     b.iter(|| {
-        wr.clear();
+        wr.buf.clear();
 
-        manual_escape(wr.by_ref(), &log);
+        manual_escape(&mut wr, &log);
     });
 }
 
@@ -1089,9 +1089,9 @@ fn test_manual_my_mem_writer1_no_escape() {
     let log = Log::new();
 
     let mut wr = MyMemWriter1::with_capacity(1024);
-    manual_no_escape(wr.by_ref(), &log);
+    manual_no_escape(&mut wr, &log);
 
-    let json = String::from_utf8(wr.unwrap()).unwrap();
+    let json = String::from_utf8(wr.buf).unwrap();
     assert_eq!(JSON_STR, json.as_slice());
 }
 
@@ -1099,14 +1099,14 @@ fn test_manual_my_mem_writer1_no_escape() {
 fn bench_manual_my_mem_writer1_no_escape(b: &mut Bencher) {
     let log = Log::new();
 
-    let mut wr = MyMemWriter1::with_capacity(1000);
+    let mut wr = MyMemWriter1::with_capacity(1024);
-    manual_no_escape(wr.by_ref(), &log);
+    manual_no_escape(&mut wr, &log);
     b.bytes = wr.buf.len() as u64;
 
     b.iter(|| {
-        wr.clear();
+        wr.buf.clear();
 
-        manual_no_escape(wr.by_ref(), &log);
+        manual_no_escape(&mut wr, &log);
     });
 }
 
@@ -1115,9 +1115,9 @@ fn test_manual_my_mem_writer1_escape() {
     let log = Log::new();
 
     let mut wr = MyMemWriter1::with_capacity(1024);
-    manual_escape(wr.by_ref(), &log);
+    manual_escape(&mut wr, &log);
 
-    let json = String::from_utf8(wr.unwrap()).unwrap();
+    let json = String::from_utf8(wr.buf).unwrap();
     assert_eq!(JSON_STR, json.as_slice());
 }
 
@@ -1126,20 +1126,20 @@ fn bench_manual_my_mem_writer1_escape(b: &mut Bencher) {
     let log = Log::new();
 
     let mut wr = MyMemWriter1::with_capacity(1024);
-    manual_escape(wr.by_ref(), &log);
+    manual_escape(&mut wr, &log);
-    b.bytes = wr.unwrap().len() as u64;
+    b.bytes = wr.buf.len() as u64;
 
     b.iter(|| {
-        let mut wr = MyMemWriter1::with_capacity(1024);
+        wr.buf.clear();
-        manual_escape(wr.by_ref(), &log);
+
-        let _json = wr.unwrap();
+        manual_escape(&mut wr, &log);
     });
 }
 
-fn direct<W: Writer>(wr: W, log: &Log) {
+fn direct<W: Writer>(wr: &mut W, log: &Log) {
     use serde::ser::Serializer;
 
-    let mut serializer = json::Serializer::new(wr);
+    let mut serializer = json::Serializer::new(wr.by_ref());
 
     serializer.serialize_struct_start("Log", 12).unwrap();
 
@@ -1164,7 +1164,7 @@ fn test_direct_vec() {
     let log = Log::new();
 
     let mut wr = Vec::with_capacity(1024);
-    direct(wr.by_ref(), &log);
+    direct(&mut wr, &log);
 
     let json = String::from_utf8(wr).unwrap();
     assert_eq!(JSON_STR, json.as_slice());
@@ -1175,12 +1175,12 @@ fn bench_direct_vec(b: &mut Bencher) {
     let log = Log::new();
 
     let mut wr = Vec::with_capacity(1024);
-    direct(wr.by_ref(), &log);
+    direct(&mut wr, &log);
     b.bytes = wr.len() as u64;
 
     b.iter(|| {
         let mut wr = Vec::with_capacity(1024);
-        direct(wr.by_ref(), &log);
+        direct(&mut wr, &log);
     });
 }
 
@@ -1189,9 +1189,9 @@ fn test_direct_my_mem_writer0() {
     let log = Log::new();
 
     let mut wr = MyMemWriter0::with_capacity(1024);
-    direct(wr.by_ref(), &log);
+    direct(&mut wr, &log);
 
-    let json = String::from_utf8(wr.unwrap()).unwrap();
+    let json = String::from_utf8(wr.buf).unwrap();
     assert_eq!(JSON_STR, json.as_slice());
 }
 
@@ -1200,13 +1200,13 @@ fn bench_direct_my_mem_writer0(b: &mut Bencher) {
     let log = Log::new();
 
     let mut wr = MyMemWriter0::with_capacity(1024);
-    direct(wr.by_ref(), &log);
+    direct(&mut wr, &log);
     b.bytes = wr.buf.len() as u64;
 
     b.iter(|| {
-        wr.clear();
+        wr.buf.clear();
 
-        direct(wr.by_ref(), &log);
+        direct(&mut wr, &log);
     });
 }
 
@@ -1215,9 +1215,9 @@ fn test_direct_my_mem_writer1() {
     let log = Log::new();
 
     let mut wr = MyMemWriter1::with_capacity(1024);
-    direct(wr.by_ref(), &log);
+    direct(&mut wr, &log);
 
-    let json = String::from_utf8(wr.unwrap()).unwrap();
+    let json = String::from_utf8(wr.buf).unwrap();
     assert_eq!(JSON_STR, json.as_slice());
 }
 
@@ -1226,13 +1226,13 @@ fn bench_direct_my_mem_writer1(b: &mut Bencher) {
     let log = Log::new();
 
     let mut wr = MyMemWriter1::with_capacity(1024);
-    direct(wr.by_ref(), &log);
+    direct(&mut wr, &log);
     b.bytes = wr.buf.len() as u64;
 
     b.iter(|| {
-        wr.clear();
+        wr.buf.clear();
 
-        direct(wr.by_ref(), &log);
+        direct(&mut wr, &log);
     });
 }
 

serde2/benches/bench_log.rs

@@ -9,14 +9,17 @@ extern crate serialize;
 extern crate test;
 
 use std::io;
-use std::io::{ByRefWriter, MemWriter};
+use std::io::ByRefWriter;
 use test::Bencher;
 
-//use serde2::de;
+use serde2::json::ser::escape_str;
 use serde2::json;
+use serde2::ser::{Serialize, Serializer};
 use serde2::ser;
 
-#[deriving(Encodable, Decodable)]
+use serialize::Encodable;
+
+#[deriving(Show, PartialEq, Encodable, Decodable)]
 #[deriving_serialize]
 //#[deriving_deserialize]
 struct Http {
@@ -31,13 +34,28 @@ struct Http {
     request_uri: String,
 }
 
-#[deriving(Show, Encodable, Decodable, FromPrimitive)]
+#[deriving(Show, PartialEq, FromPrimitive)]
 enum HttpProtocol {
     HTTP_PROTOCOL_UNKNOWN,
     HTTP10,
     HTTP11,
 }
 
+impl<S: serialize::Encoder<E>, E> serialize::Encodable<S, E> for HttpProtocol {
+    fn encode(&self, s: &mut S) -> Result<(), E> {
+        (*self as uint).encode(s)
+    }
+}
+
+impl<D: ::serialize::Decoder<E>, E> serialize::Decodable<D, E> for HttpProtocol {
+    fn decode(d: &mut D) -> Result<HttpProtocol, E> {
+        match FromPrimitive::from_uint(try!(d.read_uint())) {
+            Some(value) => Ok(value),
+            None => Err(d.error("cannot convert from uint")),
+        }
+    }
+}
+
 impl ser::Serialize for HttpProtocol {
     #[inline]
     fn visit<
@@ -59,7 +77,7 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for HttpProtocol {
 }
 */
 
-#[deriving(Show, Encodable, Decodable, FromPrimitive)]
+#[deriving(Show, PartialEq, FromPrimitive)]
 enum HttpMethod {
     METHOD_UNKNOWN,
     GET,
@@ -74,6 +92,21 @@ enum HttpMethod {
     PATCH,
 }
 
+impl<S: serialize::Encoder<E>, E> serialize::Encodable<S, E> for HttpMethod {
+    fn encode(&self, s: &mut S) -> Result<(), E> {
+        (*self as uint).encode(s)
+    }
+}
+
+impl<D: ::serialize::Decoder<E>, E> serialize::Decodable<D, E> for HttpMethod {
+    fn decode(d: &mut D) -> Result<HttpMethod, E> {
+        match FromPrimitive::from_uint(try!(d.read_uint())) {
+            Some(value) => Ok(value),
+            None => Err(d.error("cannot convert from uint")),
+        }
+    }
+}
+
 impl ser::Serialize for HttpMethod {
     #[inline]
     fn visit<
@@ -95,7 +128,7 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for HttpMethod {
 }
 */
 
-#[deriving(Show, Encodable, Decodable, FromPrimitive)]
+#[deriving(Show, PartialEq, FromPrimitive)]
 enum CacheStatus {
     CACHESTATUS_UNKNOWN,
     Miss,
@@ -103,6 +136,21 @@ enum CacheStatus {
     Hit,
 }
 
+impl<S: serialize::Encoder<E>, E> serialize::Encodable<S, E> for CacheStatus {
+    fn encode(&self, s: &mut S) -> Result<(), E> {
+        (*self as uint).encode(s)
+    }
+}
+
+impl<D: ::serialize::Decoder<E>, E> serialize::Decodable<D, E> for CacheStatus {
+    fn decode(d: &mut D) -> Result<CacheStatus, E> {
+        match FromPrimitive::from_uint(try!(d.read_uint())) {
+            Some(value) => Ok(value),
+            None => Err(d.error("cannot convert from uint")),
+        }
+    }
+}
+
 impl ser::Serialize for CacheStatus {
     #[inline]
     fn visit<
@@ -124,7 +172,7 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for CacheStatus {
 }
 */
 
-#[deriving(Encodable, Decodable)]
+#[deriving(Show, PartialEq, Encodable, Decodable)]
 #[deriving_serialize]
 //#[deriving_deserialize]
 struct Origin {
@@ -134,13 +182,28 @@ struct Origin {
     protocol: OriginProtocol,
 }
 
-#[deriving(Show, Encodable, Decodable, FromPrimitive)]
+#[deriving(Show, PartialEq, FromPrimitive)]
 enum OriginProtocol {
     ORIGIN_PROTOCOL_UNKNOWN,
     HTTP,
     HTTPS,
 }
 
+impl<S: serialize::Encoder<E>, E> serialize::Encodable<S, E> for OriginProtocol {
+    fn encode(&self, s: &mut S) -> Result<(), E> {
+        (*self as uint).encode(s)
+    }
+}
+
+impl<D: ::serialize::Decoder<E>, E> serialize::Decodable<D, E> for OriginProtocol {
+    fn decode(d: &mut D) -> Result<OriginProtocol, E> {
+        match FromPrimitive::from_uint(try!(d.read_uint())) {
+            Some(value) => Ok(value),
+            None => Err(d.error("cannot convert from uint")),
+        }
+    }
+}
+
 impl ser::Serialize for OriginProtocol {
     #[inline]
     fn visit<
@@ -162,7 +225,7 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for OriginProtocol {
 }
 */
 
-#[deriving(Show, Encodable, Decodable, FromPrimitive)]
+#[deriving(Show, PartialEq, FromPrimitive)]
 enum ZonePlan {
     ZONEPLAN_UNKNOWN,
     FREE,
@@ -171,6 +234,21 @@ enum ZonePlan {
     ENT,
 }
 
+impl<S: serialize::Encoder<E>, E> serialize::Encodable<S, E> for ZonePlan {
+    fn encode(&self, s: &mut S) -> Result<(), E> {
+        (*self as uint).encode(s)
+    }
+}
+
+impl<D: ::serialize::Decoder<E>, E> serialize::Decodable<D, E> for ZonePlan {
+    fn decode(d: &mut D) -> Result<ZonePlan, E> {
+        match FromPrimitive::from_uint(try!(d.read_uint())) {
+            Some(value) => Ok(value),
+            None => Err(d.error("cannot convert from uint")),
+        }
+    }
+}
+
 impl ser::Serialize for ZonePlan {
     #[inline]
     fn visit<
@@ -192,7 +270,7 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for ZonePlan {
 }
 */
 
-#[deriving(Show, Encodable, Decodable, FromPrimitive)]
+#[deriving(Show, PartialEq, FromPrimitive)]
 enum Country {
 	UNKNOWN,
 	A1,
@@ -452,6 +530,21 @@ enum Country {
 	ZW,
 }
 
+impl<S: serialize::Encoder<E>, E> serialize::Encodable<S, E> for Country {
+    fn encode(&self, s: &mut S) -> Result<(), E> {
+        (*self as uint).encode(s)
+    }
+}
+
+impl<D: ::serialize::Decoder<E>, E> serialize::Decodable<D, E> for Country {
+    fn decode(d: &mut D) -> Result<Country, E> {
+        match FromPrimitive::from_uint(try!(d.read_uint())) {
+            Some(value) => Ok(value),
+            None => Err(d.error("cannot convert from uint")),
+        }
+    }
+}
+
 impl ser::Serialize for Country {
     #[inline]
     fn visit<
@@ -473,7 +566,7 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Country {
 }
 */
 
-#[deriving(Encodable, Decodable)]
+#[deriving(Show, PartialEq, Encodable, Decodable)]
 #[deriving_serialize]
 //#[deriving_deserialize]
 struct Log {
@@ -496,13 +589,13 @@ impl Log {
         Log {
             timestamp: 2837513946597,
             zone_id: 123456,
-            zone_plan: FREE,
+            zone_plan: ZonePlan::FREE,
             http: Http {
-                protocol: HTTP11,
+                protocol: HttpProtocol::HTTP11,
                 status: 200,
                 host_status: 503,
                 up_status: 520,
-                method: GET,
+                method: HttpMethod::GET,
                 content_type: "text/html".to_string(),
                 user_agent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36".to_string(),
                 referer: "https://www.cloudflare.com/".to_string(),
@@ -512,10 +605,10 @@ impl Log {
                 ip: "1.2.3.4".to_string(),
                 port: 8000,
                 hostname: "www.example.com".to_string(),
-                protocol: HTTPS,
+                protocol: OriginProtocol::HTTPS,
             },
-            country: US,
+            country: Country::US,
-            cache_status: Hit,
+            cache_status: CacheStatus::Hit,
             server_ip: "192.168.1.1".to_string(),
             server_name: "metal.cloudflare.com".to_string(),
             remote_ip: "10.1.2.3".to_string(),
@@ -525,7 +618,6 @@ impl Log {
     }
 }
 
-
 macro_rules! likely(
     ($val:expr) => {
         {
@@ -557,20 +649,11 @@ struct MyMemWriter0 {
 }
 
 impl MyMemWriter0 {
-    /*
-    pub fn new() -> MyMemWriter0 {
-        MyMemWriter0::with_capacity(128)
-    }
-    */
-
     pub fn with_capacity(cap: uint) -> MyMemWriter0 {
         MyMemWriter0 {
             buf: Vec::with_capacity(cap)
         }
     }
-
-    #[inline]
-    pub fn unwrap(self) -> Vec<u8> { self.buf }
 }
 
 
@@ -587,20 +670,11 @@ struct MyMemWriter1 {
 }
 
 impl MyMemWriter1 {
-    /*
-    pub fn new() -> MyMemWriter1 {
-        MyMemWriter1::with_capacity(128)
-    }
-    */
-
     pub fn with_capacity(cap: uint) -> MyMemWriter1 {
         MyMemWriter1 {
             buf: Vec::with_capacity(cap)
         }
     }
-
-    #[inline]
-    pub fn unwrap(self) -> Vec<u8> { self.buf }
 }
 
 // LLVM isn't yet able to lower `Vec::push_all` into a memcpy, so this helps
@@ -631,19 +705,52 @@ impl Writer for MyMemWriter1 {
     }
 }
 
+const JSON_STR: &'static str = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":1,"http":{"protocol":2,"status":200,"host_status":503,"up_status":520,"method":1,"content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":2},"country":238,"cache_status":3,"server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
+
+#[test]
+fn test_encoder() {
+    use serialize::Encodable;
+
+    let log = Log::new();
+
+    let mut wr = Vec::with_capacity(1024);
+
+    {
+        let mut encoder = serialize::json::Encoder::new(&mut wr as &mut Writer);
+        log.encode(&mut encoder).unwrap();
+    }
+
+    assert_eq!(wr.as_slice(), JSON_STR.as_bytes());
+}
+
 #[bench]
 fn bench_encoder(b: &mut Bencher) {
     let log = Log::new();
-    let json = serialize::json::encode(&log);
+
-    b.bytes = json.len() as u64;
+    let mut wr = Vec::with_capacity(1024);
+
+    {
+        let mut encoder = serialize::json::Encoder::new(&mut wr as &mut Writer);
+        log.encode(&mut encoder).unwrap();
+    }
+
+    b.bytes = wr.len() as u64;
 
     b.iter(|| {
-        //for _ in range(0u, 1000) {
+        wr.clear();
-        let _json = serialize::json::encode(&log);
+
-        //}
+        let mut encoder = serialize::json::Encoder::new(&mut wr as &mut Writer);
+        log.encode(&mut encoder).unwrap();
     });
 }
 
+#[test]
+fn test_serializer() {
+    let log = Log::new();
+    let json = json::to_vec(&log).unwrap();
+    assert_eq!(json, JSON_STR.as_bytes());
+}
+
 #[bench]
 fn bench_serializer(b: &mut Bencher) {
     let log = Log::new();
@@ -651,25 +758,50 @@ fn bench_serializer(b: &mut Bencher) {
     b.bytes = json.len() as u64;
 
     b.iter(|| {
-        //for _ in range(0u, 1000) {
+        let _ = json::to_vec(&log);
-        let _json = json::to_vec(&log).unwrap();
-        //}
     });
 }
 
+#[test]
+fn test_serializer_vec() {
+    let log = Log::new();
+    let wr = Vec::with_capacity(1024);
+    let mut serializer = json::Writer::new(wr);
+    serializer.visit(&log).unwrap();
+
+    let json = serializer.unwrap();
+    assert_eq!(json.as_slice(), JSON_STR.as_bytes());
+}
+
 #[bench]
-fn bench_copy(b: &mut Bencher) {
+fn bench_serializer_vec(b: &mut Bencher) {
-    let s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
+    let log = Log::new();
-
+    let json = json::to_vec(&log).unwrap();
-    let json = s.as_bytes().to_vec();
     b.bytes = json.len() as u64;
 
+    let mut wr = Vec::with_capacity(1024);
+
     b.iter(|| {
-        let _json = s.as_bytes().to_vec();
+        wr.clear();
+
+        let mut serializer = json::Writer::new(wr.by_ref());
+        serializer.visit(&log).unwrap();
+        let _json = serializer.unwrap();
     });
 }
 
-fn manual_no_escape<W: Writer>(mut wr: W, log: &Log) {
+
+#[bench]
+fn bench_copy(b: &mut Bencher) {
+    let json = JSON_STR.as_bytes().to_vec();
+    b.bytes = json.len() as u64;
+
+    b.iter(|| {
+        let _json = JSON_STR.as_bytes().to_vec();
+    });
+}
+
+fn manual_no_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str("{\"timestamp\":").unwrap();
     (write!(wr, "{}", log.timestamp)).unwrap();
     wr.write_str(",\"zone_id\":").unwrap();
@@ -726,336 +858,262 @@ fn manual_no_escape<W: Writer>(mut wr: W, log: &Log) {
     wr.write_str("}").unwrap();
 }
 
-fn manual_escape<W: Writer>(mut wr: W, log: &Log) {
+fn manual_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str("{").unwrap();
-    json::escape_str(&mut wr, "timestamp").unwrap();
+    escape_str(wr, "timestamp").unwrap();
     wr.write_str(":").unwrap();
     (write!(wr, "{}", log.timestamp)).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "zone_id").unwrap();
+    escape_str(wr, "zone_id").unwrap();
     wr.write_str(":").unwrap();
     (write!(wr, "{}", log.zone_id)).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "zone_plan").unwrap();
+    escape_str(wr, "zone_plan").unwrap();
     wr.write_str(":").unwrap();
     (write!(wr, "{}", log.zone_plan as int)).unwrap();
 
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "http").unwrap();
+    escape_str(wr, "http").unwrap();
     wr.write_str(":{").unwrap();
-    json::escape_str(&mut wr, "protocol").unwrap();
+    escape_str(wr, "protocol").unwrap();
     wr.write_str(":").unwrap();
     (write!(wr, "{}", log.http.protocol as uint)).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "status").unwrap();
+    escape_str(wr, "status").unwrap();
     wr.write_str(":").unwrap();
     (write!(wr, "{}", log.http.status)).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "host_status").unwrap();
+    escape_str(wr, "host_status").unwrap();
     wr.write_str(":").unwrap();
     (write!(wr, "{}", log.http.host_status)).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "up_status").unwrap();
+    escape_str(wr, "up_status").unwrap();
     wr.write_str(":").unwrap();
     (write!(wr, "{}", log.http.up_status)).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "method").unwrap();
+    escape_str(wr, "method").unwrap();
     wr.write_str(":").unwrap();
     (write!(wr, "{}", log.http.method as uint)).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "content_type").unwrap();
+    escape_str(wr, "content_type").unwrap();
     wr.write_str(":").unwrap();
-    json::escape_str(&mut wr, log.http.content_type.as_slice()).unwrap();
+    escape_str(wr, log.http.content_type.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "user_agent").unwrap();
+    escape_str(wr, "user_agent").unwrap();
     wr.write_str(":").unwrap();
-    json::escape_str(&mut wr, log.http.user_agent.as_slice()).unwrap();
+    escape_str(wr, log.http.user_agent.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "referer").unwrap();
+    escape_str(wr, "referer").unwrap();
     wr.write_str(":").unwrap();
-    json::escape_str(&mut wr, log.http.referer.as_slice()).unwrap();
+    escape_str(wr, log.http.referer.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "request_uri").unwrap();
+    escape_str(wr, "request_uri").unwrap();
     wr.write_str(":").unwrap();
-    json::escape_str(&mut wr, log.http.request_uri.as_slice()).unwrap();
+    escape_str(wr, log.http.request_uri.as_slice()).unwrap();
 
     wr.write_str("},").unwrap();
-    json::escape_str(&mut wr, "origin").unwrap();
+    escape_str(wr, "origin").unwrap();
     wr.write_str(":{").unwrap();
 
-    json::escape_str(&mut wr, "ip").unwrap();
+    escape_str(wr, "ip").unwrap();
     wr.write_str(":").unwrap();
-    json::escape_str(&mut wr, log.origin.ip.as_slice()).unwrap();
+    escape_str(wr, log.origin.ip.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "port").unwrap();
+    escape_str(wr, "port").unwrap();
     wr.write_str(":").unwrap();
     (write!(wr, "{}", log.origin.port)).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "hostname").unwrap();
+    escape_str(wr, "hostname").unwrap();
     wr.write_str(":").unwrap();
-    json::escape_str(&mut wr, log.origin.hostname.as_slice()).unwrap();
+    escape_str(wr, log.origin.hostname.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "protocol").unwrap();
+    escape_str(wr, "protocol").unwrap();
     wr.write_str(":").unwrap();
     (write!(wr, "{}", log.origin.protocol as uint)).unwrap();
 
     wr.write_str("},").unwrap();
-    json::escape_str(&mut wr, "country").unwrap();
+    escape_str(wr, "country").unwrap();
     wr.write_str(":").unwrap();
     (write!(wr, "{}", log.country as uint)).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "cache_status").unwrap();
+    escape_str(wr, "cache_status").unwrap();
     wr.write_str(":").unwrap();
     (write!(wr, "{}", log.cache_status as uint)).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "server_ip").unwrap();
+    escape_str(wr, "server_ip").unwrap();
     wr.write_str(":").unwrap();
-    json::escape_str(&mut wr, log.server_ip.as_slice()).unwrap();
+    escape_str(wr, log.server_ip.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "server_name").unwrap();
+    escape_str(wr, "server_name").unwrap();
     wr.write_str(":").unwrap();
-    json::escape_str(&mut wr, log.server_name.as_slice()).unwrap();
+    escape_str(wr, log.server_name.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "remote_ip").unwrap();
+    escape_str(wr, "remote_ip").unwrap();
     wr.write_str(":").unwrap();
-    json::escape_str(&mut wr, log.remote_ip.as_slice()).unwrap();
+    escape_str(wr, log.remote_ip.as_slice()).unwrap();
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "bytes_dlv").unwrap();
+    escape_str(wr, "bytes_dlv").unwrap();
     wr.write_str(":").unwrap();
     (write!(wr, "{}", log.bytes_dlv)).unwrap();
 
     wr.write_str(",").unwrap();
-    json::escape_str(&mut wr, "ray_id").unwrap();
+    escape_str(wr, "ray_id").unwrap();
     wr.write_str(":").unwrap();
-    json::escape_str(&mut wr, log.ray_id.as_slice()).unwrap();
+    escape_str(wr, log.ray_id.as_slice()).unwrap();
     wr.write_str("}").unwrap();
 }
 
-#[bench]
+#[test]
-fn bench_manual_mem_writer_no_escape(b: &mut Bencher) {
+fn test_manual_vec_no_escape() {
     let log = Log::new();
-    let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":1,"http":{"protocol":2,"status":200,"host_status":503,"up_status":520,"method":1,"content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":2},"country":238,"cache_status":3,"server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
 
-    let mut wr = MemWriter::with_capacity(1024);
+    let mut wr = Vec::with_capacity(1024);
-    manual_no_escape(wr.by_ref(), &log);
+    manual_no_escape(&mut wr, &log);
-    b.bytes = wr.unwrap().len() as u64;
 
-    b.iter(|| {
+    let json = String::from_utf8(wr).unwrap();
-        let mut wr = MemWriter::with_capacity(1024);
+    assert_eq!(JSON_STR, json.as_slice());
-        manual_no_escape(wr.by_ref(), &log);
-        let _json = wr.unwrap();
-
-        //let _json = String::from_utf8(_json).unwrap();
-        //assert_eq!(_s, _json.as_slice());
-    });
 }
 
 #[bench]
-fn bench_manual_mem_writer_escape(b: &mut Bencher) {
+fn bench_manual_vec_no_escape(b: &mut Bencher) {
     let log = Log::new();
-    let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":1,"http":{"protocol":2,"status":200,"host_status":503,"up_status":520,"method":1,"content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":2},"country":238,"cache_status":3,"server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
 
-    let mut wr = MemWriter::with_capacity(1024);
+    let mut wr = Vec::with_capacity(1024);
-    manual_escape(wr.by_ref(), &log);
+    manual_no_escape(&mut wr, &log);
-    b.bytes = wr.unwrap().len() as u64;
+    b.bytes = wr.len() as u64;
 
     b.iter(|| {
-        let mut wr = MemWriter::with_capacity(1024);
+        wr.clear();
-        manual_escape(wr.by_ref(), &log);
+        manual_no_escape(&mut wr, &log);
-        let _json = wr.unwrap();
-
-        //let _json = String::from_utf8(_json).unwrap();
-        //assert_eq!(_s, _json.as_slice());
     });
 }
 
+#[test]
+fn test_manual_vec_escape() {
+    let log = Log::new();
+
+    let mut wr = Vec::with_capacity(1024);
+    manual_escape(&mut wr, &log);
+
+    let json = String::from_utf8(wr).unwrap();
+    assert_eq!(JSON_STR, json.as_slice());
+}
+
+#[bench]
+fn bench_manual_vec_escape(b: &mut Bencher) {
+    let log = Log::new();
+
+    let mut wr = Vec::with_capacity(1024);
+    manual_escape(&mut wr, &log);
+    b.bytes = wr.len() as u64;
+
+    b.iter(|| {
+        wr.clear();
+
+        manual_escape(&mut wr, &log);
+    });
+}
+
+#[test]
+fn test_manual_my_mem_writer0_no_escape() {
+    let log = Log::new();
+
+    let mut wr = MyMemWriter0::with_capacity(1000);
+    manual_no_escape(&mut wr, &log);
+
+    let json = String::from_utf8(wr.buf).unwrap();
+    assert_eq!(JSON_STR, json.as_slice());
+}
+
 #[bench]
 fn bench_manual_my_mem_writer0_no_escape(b: &mut Bencher) {
     let log = Log::new();
-    let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
 
-    let mut wr = MyMemWriter0::with_capacity(1000);
+    let mut wr = MyMemWriter0::with_capacity(1024);
-    manual_no_escape(wr.by_ref(), &log);
+    manual_no_escape(&mut wr, &log);
-    b.bytes = wr.unwrap().len() as u64;
+    b.bytes = wr.buf.len() as u64;
 
     b.iter(|| {
-        let mut wr = MyMemWriter0::with_capacity(1024);
+        wr.buf.clear();
-        manual_no_escape(wr.by_ref(), &log);
 
-        let _json = wr.unwrap();
+        manual_no_escape(&mut wr, &log);
-
-        //let _json = String::from_utf8(wr.unwrap()).unwrap();
-        /*
-        assert_eq!(_s, _json.as_slice());
-        */
     });
 }
 
+#[test]
+fn test_manual_my_mem_writer0_escape() {
+    let log = Log::new();
+
+    let mut wr = MyMemWriter0::with_capacity(1024);
+    manual_escape(&mut wr, &log);
+
+    let json = String::from_utf8(wr.buf).unwrap();
+    assert_eq!(JSON_STR, json.as_slice());
+}
+
 #[bench]
 fn bench_manual_my_mem_writer0_escape(b: &mut Bencher) {
     let log = Log::new();
-    let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
 
-    let mut wr = MemWriter::with_capacity(1024);
+    let mut wr = MyMemWriter0::with_capacity(1024);
-    manual_escape(wr.by_ref(), &log);
+    manual_escape(&mut wr, &log);
-    b.bytes = wr.unwrap().len() as u64;
+    b.bytes = wr.buf.len() as u64;
 
     b.iter(|| {
-        let mut wr = MyMemWriter0::with_capacity(1024);
+        wr.buf.clear();
-        manual_escape(wr.by_ref(), &log);
-        let _json = wr.unwrap();
 
-        //let _json = String::from_utf8(wr.unwrap()).unwrap();
+        manual_escape(&mut wr, &log);
-        /*
-        assert_eq!(_s, _json.as_slice());
-        */
     });
 }
 
+#[test]
+fn test_manual_my_mem_writer1_no_escape() {
+    let log = Log::new();
+
+    let mut wr = MyMemWriter1::with_capacity(1024);
+    manual_no_escape(&mut wr, &log);
+
+    let json = String::from_utf8(wr.buf).unwrap();
+    assert_eq!(JSON_STR, json.as_slice());
+}
+
 #[bench]
 fn bench_manual_my_mem_writer1_no_escape(b: &mut Bencher) {
     let log = Log::new();
-    let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
 
-    let mut wr = MyMemWriter1::with_capacity(1000);
+    let mut wr = MyMemWriter1::with_capacity(1024);
-    manual_no_escape(wr.by_ref(), &log);
+    manual_no_escape(&mut wr, &log);
-    b.bytes = wr.unwrap().len() as u64;
+    b.bytes = wr.buf.len() as u64;
 
     b.iter(|| {
-        let mut wr = MyMemWriter1::with_capacity(1024);
+        wr.buf.clear();
-        manual_no_escape(wr.by_ref(), &log);
 
-        let _json = wr.unwrap();
+        manual_no_escape(&mut wr, &log);
-
-        //let _json = String::from_utf8(wr.unwrap()).unwrap();
-        /*
-        assert_eq!(_s, _json.as_slice());
-        */
     });
 }
 
+#[test]
+fn test_manual_my_mem_writer1_escape() {
+    let log = Log::new();
+
+    let mut wr = MyMemWriter1::with_capacity(1024);
+    manual_escape(&mut wr, &log);
+
+    let json = String::from_utf8(wr.buf).unwrap();
+    assert_eq!(JSON_STR, json.as_slice());
+}
+
 #[bench]
 fn bench_manual_my_mem_writer1_escape(b: &mut Bencher) {
     let log = Log::new();
-    let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
 
     let mut wr = MyMemWriter1::with_capacity(1024);
-    manual_escape(wr.by_ref(), &log);
+    manual_escape(&mut wr, &log);
-    b.bytes = wr.unwrap().len() as u64;
+    b.bytes = wr.buf.len() as u64;
 
     b.iter(|| {
-        let mut wr = MyMemWriter1::with_capacity(1024);
+        wr.buf.clear();
-        manual_escape(wr.by_ref(), &log);
-        let _json = wr.unwrap();
 
-        //let _json = String::from_utf8(wr.unwrap()).unwrap();
+        manual_escape(&mut wr, &log);
-        /*
-        assert_eq!(_s, _json.as_slice());
-        */
     });
 }
-
-/*
-fn direct<W: Writer>(wr: W, log: &Log) {
-    use serde2::ser::VisitorState;
-
-    let mut serializer = json::Writer::new(wr);
-    serializer.serialize_struct_start("Log", 12).unwrap();
-
-    serializer.serialize_struct_elt("timestamp", &log.timestamp).unwrap();
-    serializer.serialize_struct_elt("zone_id", &log.zone_id).unwrap();
-    serializer.serialize_struct_elt("zone_plan", &(log.zone_plan as uint)).unwrap();
-
-    serializer.serialize_struct_start("Http", 9).unwrap();
-    serializer.serialize_struct_elt("protocol", &(log.http.protocol as uint)).unwrap();
-    serializer.serialize_struct_elt("status", &log.http.status).unwrap();
-    serializer.serialize_struct_elt("host_status", &log.http.host_status).unwrap();
-    serializer.serialize_struct_elt("up_status", &log.http.up_status).unwrap();
-    serializer.serialize_struct_elt("method", &(log.http.method as uint)).unwrap();
-    serializer.serialize_struct_elt("content_type", &log.http.content_type).unwrap();
-    serializer.serialize_struct_elt("user_agent", &log.http.user_agent).unwrap();
-    serializer.serialize_struct_elt("referer", &log.http.referer.as_slice()).unwrap();
-    serializer.serialize_struct_elt("request_uri", &log.http.request_uri.as_slice()).unwrap();
-    serializer.serialize_struct_end().unwrap();
-
-    serializer.serialize_struct_start("Origin", 3).unwrap();
-    serializer.serialize_struct_elt("port", &log.origin.port).unwrap();
-    serializer.serialize_struct_elt("hostname", &log.origin.hostname.as_slice()).unwrap();
-    serializer.serialize_struct_elt("protocol", &(log.origin.protocol as uint)).unwrap();
-    serializer.serialize_struct_end().unwrap();
-
-    serializer.serialize_struct_elt("country", &(log.country as uint)).unwrap();
-    serializer.serialize_struct_elt("cache_status", &(log.cache_status as uint)).unwrap();
-    serializer.serialize_struct_elt("server_ip", &log.server_ip.as_slice()).unwrap();
-    serializer.serialize_struct_elt("server_name", &log.server_name.as_slice()).unwrap();
-    serializer.serialize_struct_elt("remote_ip", &log.remote_ip.as_slice()).unwrap();
-    serializer.serialize_struct_elt("bytes_dlv", &log.bytes_dlv).unwrap();
-    serializer.serialize_struct_elt("ray_id", &log.ray_id.as_slice()).unwrap();
-
-    serializer.serialize_struct_end().unwrap();
-}
-
-#[bench]
-fn bench_direct_mem_writer(b: &mut Bencher) {
-    let log = Log::new();
-    let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
-
-    let mut wr = MemWriter::with_capacity(1024);
-    direct(wr.by_ref(), &log);
-    b.bytes = wr.unwrap().len() as u64;
-
-    b.iter(|| {
-        let mut wr = MemWriter::with_capacity(1024);
-        direct(wr.by_ref(), &log);
-        let _json = wr.unwrap();
-
-        //let _json = String::from_utf8(_json).unwrap();
-        //assert_eq!(_s, _json.as_slice());
-    });
-}
-
-#[bench]
-fn bench_direct_my_mem_writer0(b: &mut Bencher) {
-    let log = Log::new();
-    let _s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
-
-    let mut wr = MyMemWriter0::with_capacity(1024);
-    direct(wr.by_ref(), &log);
-    b.bytes = wr.unwrap().len() as u64;
-
-    b.iter(|| {
-        let mut wr = MyMemWriter0::with_capacity(1024);
-        direct(wr.by_ref(), &log);
-        let _json = wr.unwrap();
-
-        //let _json = String::from_utf8(_json).unwrap();
-        //assert_eq!(_s, _json.as_slice());
-    });
-}
-*/
-
-/*
-#[bench]
-fn bench_decoder(b: &mut Bencher) {
-    let s = r#"{"timestamp":2837513946597,"zone_id":123456,"zone_plan":"FREE","http":{"protocol":"HTTP11","status":200,"host_status":503,"up_status":520,"method":"GET","content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":"HTTPS"},"country":"US","cache_status":"Hit","server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
-
-    b.bytes = s.len() as u64;
-
-    b.iter(|| {
-        let json = serialize::json::from_str(s).unwrap();
-        let mut decoder = serialize::json::Decoder::new(json);
-        let _log: Log = serialize::Decodable::decode(&mut decoder).unwrap();
-    });
-}
-
-#[bench]
-fn bench_deserializer(b: &mut Bencher) {
-    let s = r#"{"timestamp":25469139677502,"zone_id":123456,"zone_plan":1,"http":{"protocol":2,"status":200,"host_status":503,"up_status":520,"method":1,"content_type":"text/html","user_agent":"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/33.0.1750.146 Safari/537.36","referer":"https://www.cloudflare.com/","request_uri":"/cdn-cgi/trace"},"origin":{"ip":"1.2.3.4","port":8000,"hostname":"www.example.com","protocol":2},"country":238,"cache_status":3,"server_ip":"192.168.1.1","server_name":"metal.cloudflare.com","remote_ip":"10.1.2.3","bytes_dlv":123456,"ray_id":"10c73629cce30078-LAX"}"#;
-
-    b.bytes = s.len() as u64;
-
-    b.iter(|| {
-        let _log: Log = json::from_str(s).unwrap();
-    });
-}
-*/

serde2/src/bin.rs

@@ -64,27 +64,27 @@ impl<Iter: Iterator<Token>> Deserializer<Error> for MyDeserializer<Iter> {
         V: de::Visitor<MyDeserializer<Iter>, R, Error>,
     >(&mut self, visitor: &mut V) -> Result<R, Error> {
         match self.next() {
-            Some(Null) => {
+            Some(Token::Null) => {
                 visitor.visit_null(self)
             }
-            Some(Int(v)) => {
+            Some(Token::Int(v)) => {
                 visitor.visit_int(self, v)
             }
-            Some(String(v)) => {
+            Some(Token::String(v)) => {
                 visitor.visit_string(self, v)
             }
-            Some(Option(is_some)) => {
+            Some(Token::Option(is_some)) => {
                 visitor.visit_option(self, MyOptionVisitor {
                     is_some: is_some,
                 })
             }
-            Some(SeqStart(len)) => {
+            Some(Token::SeqStart(len)) => {
                 visitor.visit_seq(self, MySeqVisitor { len: len })
             }
-            Some(MapStart(len)) => {
+            Some(Token::MapStart(len)) => {
                 visitor.visit_map(self, MyMapVisitor { len: len })
             }
-            Some(End) => {
+            Some(Token::End) => {
                 Err(self.syntax_error())
             }
             None => {
@@ -98,13 +98,13 @@ impl<Iter: Iterator<Token>> Deserializer<Error> for MyDeserializer<Iter> {
         V: de::Visitor<MyDeserializer<Iter>, R, Error>,
     >(&mut self, visitor: &mut V) -> Result<R, Error> {
         match self.peek() {
-            Some(&Null) => {
+            Some(&Token::Null) => {
                 self.next();
                 visitor.visit_option(self, MyOptionVisitor {
                     is_some: false,
                 })
             }
-            Some(&Option(is_some)) => {
+            Some(&Token::Option(is_some)) => {
                 self.next();
                 visitor.visit_option(self, MyOptionVisitor {
                     is_some: is_some,
@@ -119,11 +119,11 @@ impl<Iter: Iterator<Token>> Deserializer<Error> for MyDeserializer<Iter> {
     }
 
     fn syntax_error(&mut self) -> Error {
-        SyntaxError
+        Error::SyntaxError
     }
 
     fn end_of_stream_error(&mut self) -> Error {
-        EndOfStreamError
+        Error::EndOfStreamError
     }
 }
 
@@ -158,7 +158,7 @@ impl<
         T: Deserialize<MyDeserializer<Iter>, Error>
     >(&mut self, d: &mut MyDeserializer<Iter>) -> Result<option::Option<T>, Error> {
         match d.peek() {
-            Some(&End) => {
+            Some(&Token::End) => {
                 d.next();
                 Ok(None)
             }
@@ -175,7 +175,7 @@ impl<
 
     fn end(&mut self, d: &mut MyDeserializer<Iter>) -> Result<(), Error> {
         match d.next() {
-            Some(End) => Ok(()),
+            Some(Token::End) => Ok(()),
             Some(_) => Err(d.syntax_error()),
             None => Err(d.end_of_stream_error()),
         }
@@ -198,7 +198,7 @@ impl<
         V: Deserialize<MyDeserializer<Iter>, Error>,
     >(&mut self, d: &mut MyDeserializer<Iter>) -> Result<option::Option<(K, V)>, Error> {
         match d.peek() {
-            Some(&End) => {
+            Some(&Token::End) => {
                 d.next();
                 Ok(None)
             }
@@ -218,7 +218,7 @@ impl<
 
     fn end(&mut self, d: &mut MyDeserializer<Iter>) -> Result<(), Error> {
         match d.next() {
-            Some(End) => Ok(()),
+            Some(Token::End) => Ok(()),
             Some(_) => Err(d.syntax_error()),
             None => Err(d.end_of_stream_error()),
         }
@@ -257,16 +257,16 @@ mod json {
                 E,
             > de::Visitor<D, Value, E> for Visitor {
                 fn visit_null(&mut self, _d: &mut D) -> Result<Value, E> {
-                    Ok(Null)
+                    Ok(Value::Null)
                 }
 
                 fn visit_int(&mut self, _d: &mut D, v: int) -> Result<Value, E> {
-                    Ok(Int(v))
+                    Ok(Value::Int(v))
                 }
 
                 /*
                 fn visit_string(&mut self, _d: &mut D, v: String) -> Result<Value, E> {
-                    Ok(String(v))
+                    Ok(Value::String(v))
                 }
                 */
 
@@ -275,7 +275,7 @@ mod json {
                 >(&mut self, d: &mut D, mut visitor: Visitor) -> Result<Value, E> {
                     match try!(visitor.visit(d)) {
                         Some(value) => Ok(value),
-                        None => Ok(Null),
+                        None => Ok(Value::Null),
                     }
                 }
 
@@ -296,7 +296,7 @@ mod json {
                         }
                     }
 
-                    Ok(List(values))
+                    Ok(Value::List(values))
                 }
 
                 fn visit_map<
@@ -315,7 +315,7 @@ mod json {
                         }
                     }
 
-                    Ok(Map(values))
+                    Ok(Value::Map(values))
                 }
             }
 
@@ -328,10 +328,10 @@ mod json {
 
 fn main() {
     let tokens = vec!(
-        SeqStart(2),
+        Token::SeqStart(2),
-        Int(1),
+        Token::Int(1),
-        Int(2),
+        Token::Int(2),
-        End,
+        Token::End,
     );
     let mut state = MyDeserializer::new(tokens.into_iter());
 
@@ -341,10 +341,10 @@ fn main() {
     ////
 
     let tokens = vec!(
-        SeqStart(2),
+        Token::SeqStart(2),
-        Int(3),
+        Token::Int(3),
-        Int(4),
+        Token::Int(4),
-        End,
+        Token::End,
     );
     let mut state = MyDeserializer::new(tokens.into_iter());
 
@@ -354,10 +354,10 @@ fn main() {
     ////
 
     let tokens = vec!(
-        SeqStart(2),
+        Token::SeqStart(2),
-        Int(5),
+        Token::Int(5),
-        Int(6),
+        Token::Int(6),
-        End,
+        Token::End,
     );
     let mut state = MyDeserializer::new(tokens.into_iter());
 
@@ -367,8 +367,8 @@ fn main() {
     ////
 
     let tokens = vec!(
-        Option(true),
+        Token::Option(true),
-        Int(7),
+        Token::Int(7),
     );
     let mut state = MyDeserializer::new(tokens.into_iter());
 
@@ -378,7 +378,7 @@ fn main() {
     ////
 
     let tokens = vec!(
-        Option(false),
+        Token::Option(false),
     );
     let mut state = MyDeserializer::new(tokens.into_iter());
 
@@ -388,8 +388,8 @@ fn main() {
     ////
 
     let tokens = vec!(
-        Option(true),
+        Token::Option(true),
-        Int(8),
+        Token::Int(8),
     );
     let mut state = MyDeserializer::new(tokens.into_iter());
 
@@ -399,7 +399,7 @@ fn main() {
     ////
 
     let tokens = vec!(
-        Option(false),
+        Token::Option(false),
     );
     let mut state = MyDeserializer::new(tokens.into_iter());
 
@@ -409,7 +409,7 @@ fn main() {
     ////
 
     let tokens = vec!(
-        Int(9),
+        Token::Int(9),
     );
     let mut state = MyDeserializer::new(tokens.into_iter());
 
@@ -419,7 +419,7 @@ fn main() {
     ////
 
     let tokens = vec!(
-        Null,
+        Token::Null,
     );
     let mut state = MyDeserializer::new(tokens.into_iter());
 
@@ -429,7 +429,7 @@ fn main() {
     ////
 
     let tokens = vec!(
-        Int(10),
+        Token::Int(10),
     );
     let mut state = MyDeserializer::new(tokens.into_iter());
 
@@ -439,7 +439,7 @@ fn main() {
     ////
 
     let tokens = vec!(
-        Null,
+        Token::Null,
     );
     let mut state = MyDeserializer::new(tokens.into_iter());
 
@@ -449,12 +449,12 @@ fn main() {
     ////
 
     let tokens = vec!(
-        MapStart(2),
+        Token::MapStart(2),
-        String("a".to_string()),
+        Token::String("a".to_string()),
-        Int(1),
+        Token::Int(1),
-        String("b".to_string()),
+        Token::String("b".to_string()),
-        Int(2),
+        Token::Int(2),
-        End
+        Token::End
     );
     let mut state = MyDeserializer::new(tokens.into_iter());
 
@@ -464,12 +464,12 @@ fn main() {
     ////
 
     let tokens = vec!(
-        MapStart(2),
+        Token::MapStart(2),
-        String("a".to_string()),
+        Token::String("a".to_string()),
-        Int(1),
+        Token::Int(1),
-        String("b".to_string()),
+        Token::String("b".to_string()),
-        Int(2),
+        Token::Int(2),
-        End
+        Token::End
     );
     let mut state = MyDeserializer::new(tokens.into_iter());
 

serde2/src/json/de.rs

@@ -46,28 +46,28 @@ pub enum SyntaxExpectation {
 impl fmt::Show for ErrorCode {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            EOFWhileParsingList => "EOF While parsing list".fmt(f),
+            ErrorCode::EOFWhileParsingList => "EOF While parsing list".fmt(f),
-            EOFWhileParsingObject => "EOF While parsing object".fmt(f),
+            ErrorCode::EOFWhileParsingObject => "EOF While parsing object".fmt(f),
-            EOFWhileParsingString => "EOF While parsing string".fmt(f),
+            ErrorCode::EOFWhileParsingString => "EOF While parsing string".fmt(f),
-            EOFWhileParsingValue => "EOF While parsing value".fmt(f),
+            ErrorCode::EOFWhileParsingValue => "EOF While parsing value".fmt(f),
-            ExpectedColon => "expected `:`".fmt(f),
+            ErrorCode::ExpectedColon => "expected `:`".fmt(f),
-            InvalidEscape => "invalid escape".fmt(f),
+            ErrorCode::InvalidEscape => "invalid escape".fmt(f),
-            InvalidNumber => "invalid number".fmt(f),
+            ErrorCode::InvalidNumber => "invalid number".fmt(f),
-            InvalidSyntax(expect) => {
+            ErrorCode::InvalidSyntax(expect) => {
                 write!(f, "invalid syntax, expected: {}", expect)
             }
-            InvalidUnicodeCodePoint => "invalid unicode code point".fmt(f),
+            ErrorCode::InvalidUnicodeCodePoint => "invalid unicode code point".fmt(f),
-            KeyMustBeAString => "key must be a string".fmt(f),
+            ErrorCode::KeyMustBeAString => "key must be a string".fmt(f),
-            LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape".fmt(f),
+            ErrorCode::LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape".fmt(f),
-            MissingField(field) => {
+            ErrorCode::MissingField(field) => {
                 write!(f, "missing field \"{}\"", field)
             }
-            NotFourDigit => "invalid \\u escape (not four digits)".fmt(f),
+            ErrorCode::NotFourDigit => "invalid \\u escape (not four digits)".fmt(f),
-            NotUtf8 => "contents not utf-8".fmt(f),
+            ErrorCode::NotUtf8 => "contents not utf-8".fmt(f),
-            TrailingCharacters => "trailing characters".fmt(f),
+            ErrorCode::TrailingCharacters => "trailing characters".fmt(f),
-            UnexpectedEndOfHexEscape => "unexpected end of hex escape".fmt(f),
+            ErrorCode::UnexpectedEndOfHexEscape => "unexpected end of hex escape".fmt(f),
-            UnknownVariant => "unknown variant".fmt(f),
+            ErrorCode::UnknownVariant => "unknown variant".fmt(f),
-            UnrecognizedHex => "invalid \\u escape (unrecognized hex)".fmt(f),
+            ErrorCode::UnrecognizedHex => "invalid \\u escape (unrecognized hex)".fmt(f),
         }
     }
 }
@@ -103,7 +103,7 @@ impl<
         if self.eof() {
             Ok(())
         } else {
-            Err(self.error(TrailingCharacters))
+            Err(self.error(ErrorCode::TrailingCharacters))
         }
     }
 
@@ -140,7 +140,7 @@ impl<
 
     fn error(&mut self, reason: ErrorCode) -> Error {
         //self.state_stack.clear();
-        SyntaxError(reason, self.line, self.col)
+        Error::SyntaxError(reason, self.line, self.col)
     }
 
     fn parse_value<
@@ -150,7 +150,7 @@ impl<
         self.parse_whitespace();
 
         if self.eof() {
-            return Err(self.error(EOFWhileParsingValue));
+            return Err(self.error(ErrorCode::EOFWhileParsingValue));
         }
 
         match self.ch_or_null() {
@@ -180,7 +180,7 @@ impl<
                 visitor.visit_map(self, MapVisitor { first: true })
             }
             _ => {
-                Err(self.error(InvalidSyntax(SomeValue)))
+                Err(self.error(ErrorCode::InvalidSyntax(SyntaxExpectation::SomeValue)))
             }
         }
     }
@@ -190,7 +190,7 @@ impl<
             self.bump();
             Ok(())
         } else {
-            Err(self.error(InvalidSyntax(SomeIdent)))
+            Err(self.error(ErrorCode::InvalidSyntax(SyntaxExpectation::SomeIdent)))
         }
     }
 
@@ -235,7 +235,7 @@ impl<
                 // There can be only one leading '0'.
                 match self.ch_or_null() {
                     '0' ... '9' => {
-                        return Err(self.error(InvalidNumber));
+                        return Err(self.error(ErrorCode::InvalidNumber));
                     }
                     _ => ()
                 }
@@ -253,7 +253,7 @@ impl<
                 }
             }
             _ => {
-                return Err(self.error(InvalidNumber));
+                return Err(self.error(ErrorCode::InvalidNumber));
             }
         }
 
@@ -267,7 +267,7 @@ impl<
         match self.ch_or_null() {
             '0' ... '9' => (),
              _ => {
-                 return Err(self.error(InvalidNumber));
+                 return Err(self.error(ErrorCode::InvalidNumber));
              }
         }
 
@@ -304,7 +304,7 @@ impl<
         match self.ch_or_null() {
             '0' ... '9' => (),
             _ => {
-                return Err(self.error(InvalidNumber));
+                return Err(self.error(ErrorCode::InvalidNumber));
             }
         }
         while !self.eof() {
@@ -343,7 +343,7 @@ impl<
                 'e' | 'E' => n * 16_u16 + 14_u16,
                 'f' | 'F' => n * 16_u16 + 15_u16,
                 _ => {
-                    return Err(self.error(InvalidEscape));
+                    return Err(self.error(ErrorCode::InvalidEscape));
                 }
             };
 
@@ -352,7 +352,7 @@ impl<
 
         // Error out if we didn't parse 4 digits.
         if i != 4u {
-            return Err(self.error(InvalidEscape));
+            return Err(self.error(ErrorCode::InvalidEscape));
         }
 
         Ok(n)
@@ -365,7 +365,7 @@ impl<
         loop {
             self.bump();
             if self.eof() {
-                return Err(self.error(EOFWhileParsingString));
+                return Err(self.error(ErrorCode::EOFWhileParsingString));
             }
 
             if escape {
@@ -380,7 +380,7 @@ impl<
                     't' => res.push('\t'),
                     'u' => match try!(self.decode_hex_escape()) {
                         0xDC00 ... 0xDFFF => {
-                            return Err(self.error(LoneLeadingSurrogateInHexEscape));
+                            return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
                         }
 
                         // Non-BMP characters are encoded as a sequence of
@@ -391,7 +391,7 @@ impl<
                             match (c1, c2) {
                                 (Some('\\'), Some('u')) => (),
                                 _ => {
-                                    return Err(self.error(UnexpectedEndOfHexEscape));
+                                    return Err(self.error(ErrorCode::UnexpectedEndOfHexEscape));
                                 }
                             }
 
@@ -399,7 +399,7 @@ impl<
                             match str::utf16_items(buf.as_slice()).next() {
                                 Some(ScalarValue(c)) => res.push(c),
                                 _ => {
-                                    return Err(self.error(LoneLeadingSurrogateInHexEscape));
+                                    return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
                                 }
                             }
                         }
@@ -407,12 +407,12 @@ impl<
                         n => match char::from_u32(n as u32) {
                             Some(c) => res.push(c),
                             None => {
-                                return Err(self.error(InvalidUnicodeCodePoint));
+                                return Err(self.error(ErrorCode::InvalidUnicodeCodePoint));
                             }
                         },
                     },
                     _ => {
-                        return Err(self.error(InvalidEscape));
+                        return Err(self.error(ErrorCode::InvalidEscape));
                     }
                 }
                 escape = false;
@@ -442,11 +442,11 @@ impl<Iter: Iterator<char>> Deserializer<Error> for Parser<Iter> {
     }
 
     fn syntax_error(&mut self) -> Error {
-        SyntaxError(InvalidSyntax(SomeValue), self.line, self.col)
+        Error::SyntaxError(ErrorCode::InvalidSyntax(SyntaxExpectation::SomeValue), self.line, self.col)
     }
 
     fn end_of_stream_error(&mut self) -> Error {
-        SyntaxError(EOFWhileParsingValue, self.line, self.col)
+        Error::SyntaxError(ErrorCode::EOFWhileParsingValue, self.line, self.col)
     }
 }
 
@@ -471,9 +471,9 @@ impl<Iter: Iterator<char>> de::SeqVisitor<Parser<Iter>, Error> for SeqVisitor {
             if d.ch_is(',') {
                 d.bump();
             } else if d.eof() {
-                return Err(d.error(EOFWhileParsingList));
+                return Err(d.error(ErrorCode::EOFWhileParsingList));
             } else {
-                return Err(d.error(InvalidSyntax(ListCommaOrEnd)));
+                return Err(d.error(ErrorCode::InvalidSyntax(SyntaxExpectation::ListCommaOrEnd)));
             }
         }
 
@@ -486,9 +486,9 @@ impl<Iter: Iterator<char>> de::SeqVisitor<Parser<Iter>, Error> for SeqVisitor {
             d.bump();
             Ok(())
         } else if d.eof() {
-            Err(d.error(EOFWhileParsingList))
+            Err(d.error(ErrorCode::EOFWhileParsingList))
         } else {
-            Err(d.error(TrailingCharacters))
+            Err(d.error(ErrorCode::TrailingCharacters))
         }
     }
 }
@@ -516,18 +516,18 @@ impl<Iter: Iterator<char>> de::MapVisitor<Parser<Iter>, Error> for MapVisitor {
                 d.bump();
                 d.parse_whitespace();
             } else if d.eof() {
-                return Err(d.error(EOFWhileParsingObject));
+                return Err(d.error(ErrorCode::EOFWhileParsingObject));
             } else {
-                return Err(d.error(InvalidSyntax(ObjectCommaOrEnd)));
+                return Err(d.error(ErrorCode::InvalidSyntax(SyntaxExpectation::ObjectCommaOrEnd)));
             }
         }
 
         if d.eof() {
-            return Err(d.error(EOFWhileParsingValue));
+            return Err(d.error(ErrorCode::EOFWhileParsingValue));
         }
 
         if !d.ch_is('"') {
-            return Err(d.error(KeyMustBeAString));
+            return Err(d.error(ErrorCode::KeyMustBeAString));
         }
 
         let key = try!(de::Deserialize::deserialize(d));
@@ -537,9 +537,9 @@ impl<Iter: Iterator<char>> de::MapVisitor<Parser<Iter>, Error> for MapVisitor {
         if d.ch_is(':') {
             d.bump();
         } else if d.eof() {
-            return Err(d.error(EOFWhileParsingObject));
+            return Err(d.error(ErrorCode::EOFWhileParsingObject));
         } else {
-            return Err(d.error(ExpectedColon));
+            return Err(d.error(ErrorCode::ExpectedColon));
         }
 
         d.parse_whitespace();
@@ -554,9 +554,9 @@ impl<Iter: Iterator<char>> de::MapVisitor<Parser<Iter>, Error> for MapVisitor {
             d.bump();
             Ok(())
         } else if d.eof() {
-            Err(d.error(EOFWhileParsingList))
+            Err(d.error(ErrorCode::EOFWhileParsingList))
         } else {
-            Err(d.error(TrailingCharacters))
+            Err(d.error(ErrorCode::TrailingCharacters))
         }
     }
 }
@@ -590,25 +590,7 @@ mod tests {
     use std::collections::TreeMap;
 
     use de::Deserialize;
-    use super::{Parser, Error, from_str};
+    use super::{Parser, Error, ErrorCode, SyntaxExpectation, from_str};
-    use super::{
-        ListCommaOrEnd,
-        ObjectCommaOrEnd,
-        SomeIdent,
-        SomeValue,
-    };
-    use super::{
-        EOFWhileParsingList,
-        EOFWhileParsingObject,
-        EOFWhileParsingString,
-        EOFWhileParsingValue,
-        ExpectedColon,
-        InvalidNumber,
-        InvalidSyntax,
-        KeyMustBeAString,
-        TrailingCharacters,
-    };
-    use super::SyntaxError;
 
     macro_rules! treemap {
         ($($k:expr => $v:expr),*) => ({
@@ -653,12 +635,12 @@ mod tests {
     #[test]
     fn test_parse_bool() {
         test_parse_err::<bool>(vec![
-            ("t", SyntaxError(InvalidSyntax(SomeIdent), 1, 2)),
+            ("t", Error::SyntaxError(ErrorCode::InvalidSyntax(SyntaxExpectation::SomeIdent), 1, 2)),
-            ("truz", SyntaxError(InvalidSyntax(SomeIdent), 1, 4)),
+            ("truz", Error::SyntaxError(ErrorCode::InvalidSyntax(SyntaxExpectation::SomeIdent), 1, 4)),
-            ("f", SyntaxError(InvalidSyntax(SomeIdent), 1, 2)),
+            ("f", Error::SyntaxError(ErrorCode::InvalidSyntax(SyntaxExpectation::SomeIdent), 1, 2)),
-            ("faz", SyntaxError(InvalidSyntax(SomeIdent), 1, 3)),
+            ("faz", Error::SyntaxError(ErrorCode::InvalidSyntax(SyntaxExpectation::SomeIdent), 1, 3)),
-            ("truea", SyntaxError(TrailingCharacters, 1, 5)),
+            ("truea", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 5)),
-            ("falsea", SyntaxError(TrailingCharacters, 1, 6)),
+            ("falsea", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 6)),
         ]);
 
         test_parse_ok(vec![
@@ -670,14 +652,14 @@ mod tests {
     #[test]
     fn test_parse_numbers() {
         test_parse_err::<f64>(vec![
-            ("+", SyntaxError(InvalidSyntax(SomeValue), 1, 1)),
+            ("+", Error::SyntaxError(ErrorCode::InvalidSyntax(SyntaxExpectation::SomeValue), 1, 1)),
-            (".", SyntaxError(InvalidSyntax(SomeValue), 1, 1)),
+            (".", Error::SyntaxError(ErrorCode::InvalidSyntax(SyntaxExpectation::SomeValue), 1, 1)),
-            ("-", SyntaxError(InvalidNumber, 1, 2)),
+            ("-", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 2)),
-            ("00", SyntaxError(InvalidNumber, 1, 2)),
+            ("00", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 2)),
-            ("1.", SyntaxError(InvalidNumber, 1, 3)),
+            ("1.", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 3)),
-            ("1e", SyntaxError(InvalidNumber, 1, 3)),
+            ("1e", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 3)),
-            ("1e+", SyntaxError(InvalidNumber, 1, 4)),
+            ("1e+", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 4)),
-            ("1a", SyntaxError(TrailingCharacters, 1, 2)),
+            ("1a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 2)),
         ]);
 
         test_parse_ok(vec![
@@ -700,9 +682,9 @@ mod tests {
     #[test]
     fn test_parse_string() {
         test_parse_err::<String>(vec![
-            ("\"", SyntaxError(EOFWhileParsingString, 1, 2)),
+            ("\"", Error::SyntaxError(ErrorCode::EOFWhileParsingString, 1, 2)),
-            ("\"lol", SyntaxError(EOFWhileParsingString, 1, 5)),
+            ("\"lol", Error::SyntaxError(ErrorCode::EOFWhileParsingString, 1, 5)),
-            ("\"lol\"a", SyntaxError(TrailingCharacters, 1, 6)),
+            ("\"lol\"a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 6)),
         ]);
 
         test_parse_ok(vec![
@@ -721,13 +703,13 @@ mod tests {
     #[test]
     fn test_parse_list() {
         test_parse_err::<Vec<f64>>(vec![
-            ("[", SyntaxError(EOFWhileParsingValue, 1, 2)),
+            ("[", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 2)),
-            ("[ ", SyntaxError(EOFWhileParsingValue, 1, 3)),
+            ("[ ", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 3)),
-            ("[1", SyntaxError(EOFWhileParsingList,  1, 3)),
+            ("[1", Error::SyntaxError(ErrorCode::EOFWhileParsingList,  1, 3)),
-            ("[1,", SyntaxError(EOFWhileParsingValue, 1, 4)),
+            ("[1,", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 4)),
-            ("[1,]", SyntaxError(InvalidSyntax(SomeValue), 1, 4)),
+            ("[1,]", Error::SyntaxError(ErrorCode::InvalidSyntax(SyntaxExpectation::SomeValue), 1, 4)),
-            ("[1 2]", SyntaxError(InvalidSyntax(ListCommaOrEnd), 1, 4)),
+            ("[1 2]", Error::SyntaxError(ErrorCode::InvalidSyntax(SyntaxExpectation::ListCommaOrEnd), 1, 4)),
-            ("[]a", SyntaxError(TrailingCharacters, 1, 3)),
+            ("[]a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 3)),
         ]);
 
         test_parse_ok(vec![
@@ -770,18 +752,18 @@ mod tests {
     #[test]
     fn test_parse_object() {
         test_parse_err::<TreeMap<String, int>>(vec![
-            ("{", SyntaxError(EOFWhileParsingValue, 1, 2)),
+            ("{", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 2)),
-            ("{ ", SyntaxError(EOFWhileParsingValue, 1, 3)),
+            ("{ ", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 3)),
-            ("{1", SyntaxError(KeyMustBeAString, 1, 2)),
+            ("{1", Error::SyntaxError(ErrorCode::KeyMustBeAString, 1, 2)),
-            ("{ \"a\"", SyntaxError(EOFWhileParsingObject, 1, 6)),
+            ("{ \"a\"", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 6)),
-            ("{\"a\"", SyntaxError(EOFWhileParsingObject, 1, 5)),
+            ("{\"a\"", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 5)),
-            ("{\"a\" ", SyntaxError(EOFWhileParsingObject, 1, 6)),
+            ("{\"a\" ", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 6)),
-            ("{\"a\" 1", SyntaxError(ExpectedColon, 1, 6)),
+            ("{\"a\" 1", Error::SyntaxError(ErrorCode::ExpectedColon, 1, 6)),
-            ("{\"a\":", SyntaxError(EOFWhileParsingValue, 1, 6)),
+            ("{\"a\":", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 6)),
-            ("{\"a\":1", SyntaxError(EOFWhileParsingObject, 1, 7)),
+            ("{\"a\":1", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 7)),
-            ("{\"a\":1 1", SyntaxError(InvalidSyntax(ObjectCommaOrEnd), 1, 8)),
+            ("{\"a\":1 1", Error::SyntaxError(ErrorCode::InvalidSyntax(SyntaxExpectation::ObjectCommaOrEnd), 1, 8)),
-            ("{\"a\":1,", SyntaxError(EOFWhileParsingValue, 1, 8)),
+            ("{\"a\":1,", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 8)),
-            ("{}a", SyntaxError(TrailingCharacters, 1, 3)),
+            ("{}a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 3)),
         ]);
 
         test_parse_ok(vec![

serde2/src/json/ser.rs

@@ -218,7 +218,7 @@ pub fn escape_str<W: io::Writer>(wr: &mut W, value: &str) -> Result<(), IoError>
 
 #[inline]
 pub fn escape_char<W: io::Writer>(wr: &mut W, value: char) -> Result<(), IoError> {
-    let mut buf = [0, .. 4];
+    let mut buf = &mut [0, .. 4];
     value.encode_utf8(buf);
     escape_bytes(wr, buf)
 }