Point the serde_json readme at the root readme

json deser from Value adjusted to be equal to deser from strings

.gitignore

@@ -1,2 +1,2 @@
-/target/
-/Cargo.lock
+target
+Cargo.lock

.travis.yml

@@ -1,13 +1,37 @@
+sudo: false
 language: rust
-
 rust:
+  - stable
+  - beta
   - nightly
-
+env:
+  global:
+    secure: HO41LMpMXkF2In9+1sxWVu7fgolL+y9+4Q5PI6wZX2L5pDwpPJCjxaQarQXCEnoIxED1PlP03JuF7ULNz0zw1ylYhAOfOSdkxFZRnE2wMZqq6qvXBHwyMiDrAociIzoPKSGv7JVrKPsjsnd+96K6xxueIodQZrmAdyq7N/M82Mc=
+  matrix:
+    - CRATE=serde_tests TARGET=test
+matrix:
+  include:
+    - rust: nightly
+      env: CRATE=serde_macros TARGET=test
+    - rust: nightly
+      env: CRATE=serde_macros TARGET=bench
+    - rust: nightly
+      env: CRATE=serde_tests TARGET=bench
 script:
-  - cargo build --verbose
-  - cargo test --verbose
-  - cargo bench --verbose
-  - cd serde2
-  - cargo build --verbose
-  - cargo test --verbose
-  - cargo bench --verbose
+  - (cd $CRATE && cargo $TARGET)
+after_success: |
+  [ $TRAVIS_BRANCH = "master" ] &&
+  [ $TRAVIS_PULL_REQUEST  = false ] &&
+  mkdir -p target/doc &&
+  (cd serde && cargo doc --no-deps) &&
+  (cd serde_codegen && cargo doc --no-deps) &&
+  (cd serde_macros && cargo doc --no-deps) &&
+  (cd serde_json && cargo doc --no-deps) &&
+  cp -r serde/target/doc target/doc/serde &&
+  cp -r serde_codegen/target/doc target/doc/serde_codegen &&
+  cp -r serde_macros/target/doc target/doc/serde_macros &&
+  cp -r serde_json/target/doc target/doc/serde_json &&
+  echo "<meta http-equiv=refresh content=0;url=`echo $TRAVIS_REPO_SLUG | cut -d '/' -f 2`/index.html>" > target/doc/index.html &&
+  sudo pip install ghp-import &&
+  ghp-import -n target/doc &&
+  git push -fq https://${GH_TOKEN}@github.com/${TRAVIS_REPO_SLUG}.git gh-pages

Cargo.toml

@@ -1,16 +0,0 @@
-[package]
-name = "serde"
-version = "0.2.0"
-authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
-license = "MIT/Apache-2.0"
-description = "A quasi-quoting macro system"
-repository = "https://github.com/erickt/rust-quasi"
-
-[lib]
-name = "serde"
-
-[dependencies]
-rustc-serialize = "*"
-
-[dev-dependencies]
-serde_macros = "0.2.0"

README.md

@@ -1,34 +1,424 @@
-Experimental Rust Serialization Library.
+Serde Rust Serialization Framework
+==================================
 
-[![Build Status](https://travis-ci.org/erickt/rust-serde.png?branch=master)](https://travis-ci.org/erickt/rust-serde)
+[![Build Status](https://api.travis-ci.org/serde-rs/serde.png?branch=master)](https://travis-ci.org/serde-rs/serde)
+[![Latest Version](https://img.shields.io/crates/v/serde.svg)](https://crates.io/crates/serde)
 
-This is an experiment to modernize rust's `libserialize` library. It is designed to implement https://github.com/rust-lang/rfcs/pull/22. `rust-serde` is an attempt to address a major shortcoming in `libserialize`. For normal structures, when you say you want to deserialize into:
+Serde is a powerful framework that enables serialization libraries to
+generically serialize Rust data structures without the overhead of runtime type
+information. In many situations, the handshake protocol between serializers and
+serializees can be completely optimized away, leaving Serde to perform roughly
+the same speed as a hand written serializer for a specific type.
+
+Documentation is available at http://serde-rs.github.io/serde/serde
+
+Making a Type Serializable
+==========================
+
+The simplest way to make a type serializable is to use the `serde_macros`
+syntax extension, which comes with a `#[derive(Serialize, Deserialize)]`
+annotation, which automatically generates implementations of 
+[Serialize](http://serde-rs.github.io/serde/serde/ser/trait.Serialize.html)
+and
+[Deserialize](http://serde-rs.github.io/serde/serde/de/trait.Deserialize.html)
+for the annotated type:
 
 ```rust
-struct Foo {
-    x: int,
-    y: int,
+#![feature(custom_derive, plugin)]
+#![plugin(serde_macros)]
+
+extern crate serde;
+
+...
+
+#[derive(Serialize, Deserialize)]
+struct Point {
+    x: i32,
+    y: i32,
 }
 ```
 
-`libserialize`'s deserializer essentially asks for:
+Serde bundles a high performance JSON serializer and deserializer,
+[serde_json](http://serde-rs.github.io/serde/serde_json/index.html),
+which comes with the helper functions
+[to_string](http://serde-rs.github.io/serde/serde/json/ser/fn.to_string.html)
+and
+[from_str](http://serde-rs.github.io/serde/serde/json/de/fn.from_str.html)
+that make it easy to go to and from JSON:
 
-* Is the next value a struct named "Foo"? If not, error.
-* Is the next field named "x"? If not, error.
-* Is the next value an "int"? If not, error.
-* Is the next field named "y"? If not, error.
-* Is the next value an "int"? If not, error.
-* Is the struct finished? If not, error.
+```rust
+use serde_json;
 
-While this works for user defined structures, it cannot support deserializing into a value like `json::Json`, which is an enum that can represent every JSON value. In order to support that, it needs to be able to do some lookahead:
+...
 
-* What is the next value type?
-    * If a struct, parse a struct.
-    * If an integer, parse an integer.
-    * ...
+let point = Point { x: 1, y: 2 };
+let serialized_point = json::to_string(&point).unwrap();
 
-More formally, `libserialize` implements a LL(0) grammar, whereas `json::Json` requires a LL(1) grammar. `rust-serde` provides this by implementing a serializer and deserializer that produces a tagged token stream of values. This enables a `Deserializable` for `json::Json` to look at the next token before deciding on how to parse the value.
+println!("{}", serialized_point); // prints: {"x":1,"y":2}
 
----
+let deserialize_point: Point = json::from_str(&serialized_point).unwrap();
+```
 
-There is now also a new library variation called `serde2`. This removes the need for tagged values and replaces them with a `Visitor` pattern. This pattern is very similar to the `Iterator` pattern, but it threads some custom state through visiting each type. This gets many of the benefits of the `serde` library without needing to always pay for tagging the variants.
+[serde_json](http://serde-rs.github.io/serde/serde_json/index.html) also
+supports a generic
+[Value](http://serde-rs.github.io/serde/serde/json/value/enum.Value.html)
+type, which can represent any JSON value. Also, any
+[Serialize](http://serde-rs.github.io/serde/serde/ser/trait.Serialize.html)
+and
+[Deserialize](http://serde-rs.github.io/serde/serde/de/trait.Deserialize.html)
+can be converted into a 
+[Value](http://serde-rs.github.io/serde/serde/json/value/enum.Value.html)
+with the methods
+[to_value](http://serde-rs.github.io/serde/serde/json/value/fn.to_value.html)
+and
+[from_value](http://serde-rs.github.io/serde/serde/json/value/fn.from_value.html):
+
+```rust
+let point = Point { x: 1, y: 2 };
+let point_value = json::to_value(&point).unwrap();
+
+println!("{}", point_value.find("x")); // prints: Some(1)
+
+let deserialize_point: Point = json::from_value(point_value).unwrap();
+```
+
+Serialization without Macros
+============================
+
+Under the covers, Serde extensively uses the Visitor pattern to thread state
+between the
+[Serializer](http://serde-rs.github.io/serde/serde/ser/trait.Serializer.html)
+and
+[Serialize](http://serde-rs.github.io/serde/serde/ser/trait.Serialize.html)
+without the two having specific information about each other's concrete type.
+This has many of the same benefits as frameworks that use runtime type
+information without the overhead.  In fact, when compiling with optimizations,
+Rust is able to remove most or all the visitor state, and generate code that's
+nearly as fast as a hand written serializer format for a specific type.
+
+To see it in action, lets look at how a simple type like `i32` is serialized.
+The
+[Serializer](http://serde-rs.github.io/serde/serde/ser/trait.Serializer.html)
+is threaded through the type:
+
+```rust
+impl serde::Serialize for i32 {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: serde::Serializer,
+    {
+        serializer.visit_i32(*self)
+    }
+}
+```
+
+As you can see it's pretty simple. More complex types like `BTreeMap` need to
+pass a
+[MapVisitor](http://serde-rs.github.io/serde/serde/ser/trait.MapVisitor.html)
+to the 
+[Serializer](http://serde-rs.github.io/serde/serde/ser/trait.Serializer.html)
+in order to walk through the type:
+
+```rust
+impl<K, V> Serialize for BTreeMap<K, V>
+    where K: Serialize + Ord,
+          V: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+pub struct MapIteratorVisitor<Iter> {
+    iter: Iter,
+    len: Option<usize>,
+}
+
+impl<K, V, Iter> MapIteratorVisitor<Iter>
+    where Iter: Iterator<Item=(K, V)>
+{
+    #[inline]
+    pub fn new(iter: Iter, len: Option<usize>) -> MapIteratorVisitor<Iter> {
+        MapIteratorVisitor {
+            iter: iter,
+            len: len,
+        }
+    }
+}
+
+impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
+    where K: Serialize,
+          V: Serialize,
+          I: Iterator<Item=(K, V)>,
+{
+    #[inline]
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: Serializer,
+    {
+        match self.iter.next() {
+            Some((key, value)) => {
+                let value = try!(serializer.visit_map_elt(key, value));
+                Ok(Some(value))
+            }
+            None => Ok(None)
+        }
+    }
+
+    #[inline]
+    fn len(&self) -> Option<usize> {
+        self.len
+    }
+}
+```
+
+Serializing structs follow this same pattern. In fact, structs are represented
+as a named map. Its visitor uses a simple state machine to iterate through all
+the fields:
+
+```rust
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+impl serde::Serialize for Point {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: serde::Serializer
+    {
+        serializer.visit_struct("Point", PointMapVisitor {
+            value: self,
+            state: 0,
+        })
+    }
+}
+
+struct PointMapVisitor<'a> {
+    value: &'a Point,
+    state: u8,
+}
+
+impl<'a> serde::ser::MapVisitor for PointMapVisitor<'a> {
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: serde::Serializer
+    {
+        match self.state {
+            0 => {
+                self.state += 1;
+                Ok(Some(try!(serializer.visit_map_elt("x", &self.value.x))))
+            }
+            1 => {
+                self.state += 1;
+                Ok(Some(try!(serializer.visit_map_elt("y", &self.value.y))))
+            }
+            _ => {
+                Ok(None)
+            }
+        }
+    }
+}
+```
+
+Deserialization without Macros
+==============================
+
+Deserialization is a little more complicated since there's a bit more error
+handling that needs to occur. Let's start with the simple `i32`
+[Deserialize](http://serde-rs.github.io/serde/serde/de/trait.Deserialize.html)
+implementation. It passes a
+[Visitor](http://serde-rs.github.io/serde/serde/de/trait.Visitor.html) to the
+[Deserializer](http://serde-rs.github.io/serde/serde/de/trait.Deserializer.html).
+The [Visitor](http://serde-rs.github.io/serde/serde/de/trait.Visitor.html)
+can create the `i32` from a variety of different types:
+
+```rust
+impl Deserialize for i32 {
+    fn deserialize<D>(deserializer: &mut D) -> Result<i32, D::Error>
+        where D: serde::Deserializer,
+    {
+        deserializer.visit(I32Visitor)
+    }
+}
+
+struct I32Visitor;
+
+impl serde::de::Visitor for I32Visitor {
+    type Value = i32;
+
+    fn visit_i16<E>(&mut self, value: i16) -> Result<i16, E>
+        where E: Error,
+    {
+        self.visit_i32(value as i32)
+    }
+
+    fn visit_i32<E>(&mut self, value: i32) -> Result<i32, E>
+        where E: Error,
+    {
+        Ok(value)
+    }
+
+    ...
+
+```
+
+Since it's possible for this type to get passed an unexpected type, we need a
+way to error out. This is done by way of the
+[Error](http://serde-rs.github.io/serde/serde/de/trait.Error.html) trait,
+which allows a 
+[Deserialize](http://serde-rs.github.io/serde/serde/de/trait.Deserialize.html)
+to generate an error for a few common error conditions. Here's how it could be used:
+
+```rust
+    ...
+
+    fn visit_string<E>(&mut self, _: String) -> Result<i32, E>
+        where E: Error,
+    {
+        Err(serde::de::Error::syntax("expect a string"))
+    }
+
+    ...
+
+```
+
+Maps follow a similar pattern as before, and use a
+[MapVisitor](http://serde-rs.github.io/serde/serde/de/trait.MapVisitor.html)
+to walk through the values generated by the 
+[Deserializer](http://serde-rs.github.io/serde/serde/de/trait.Deserializer.html).
+
+```rust
+impl<K, V> serde::Deserialize for BTreeMap<K, V>
+    where K: serde::Deserialize + Eq + Ord,
+          V: serde::Deserialize,
+{
+    fn deserialize<D>(deserializer: &mut D) -> Result<BTreeMap<K, V>, D::Error>
+        where D: serde::Deserializer,
+    {
+        deserializer.visit(BTreeMapVisitor::new())
+    }
+}
+
+pub struct BTreeMapVisitor<K, V> {
+    marker: PhantomData<BTreeMap<K, V>>,
+}
+
+impl<K, V> BTreeMapVisitor<K, V> {
+    pub fn new() -> Self {
+        BTreeMapVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<K, V> serde::de::Visitor for BTreeMapVisitor<K, V>
+    where K: serde::de::Deserialize + Ord,
+          V: serde::de::Deserialize
+{
+    type Value = BTreeMap<K, V>;
+
+    fn visit_unit<E>(&mut self) -> Result<BTreeMap<K, V>, E>
+        where E: Error,
+    {
+        Ok(BTreeMap::new())
+    }
+
+    fn visit_map<V_>(&mut self, mut visitor: V_) -> Result<BTreeMap<K, V>, V_::Error>
+        where V_: MapVisitor,
+    {
+        let mut values = BTreeMap::new();
+
+        while let Some((key, value)) = try!(visitor.visit()) {
+            values.insert(key, value);
+        }
+
+        try!(visitor.end());
+
+        Ok(values)
+    }
+}
+
+```
+
+Deserializing structs goes a step further in order to support not allocating a
+`String` to hold the field names. This is done by custom field enum that
+deserializes an enum variant from a string. So for our `Point` example from
+before, we need to generate:
+
+```rust
+enum PointField {
+    X,
+    Y,
+}
+
+impl serde::Deserialize for PointField {
+    fn deserialize<D>(deserializer: &mut D) -> Result<PointField, D::Error>
+        where D: serde::de::Deserializer
+    {
+        struct FieldVisitor;
+
+        impl serde::de::Visitor for FieldVisitor {
+            type Value = Field;
+
+            fn visit_str<E>(&mut self, value: &str) -> Result<PointField, E>
+                where E: serde::de::Error
+            {
+                match value {
+                    "x" => Ok(Field::X),
+                    "y" => Ok(Field::Y),
+                    _ => Err(serde::de::Error::syntax("expected x or y")),
+                }
+            }
+        }
+
+        deserializer.visit(FieldVisitor)
+    }
+}
+```
+
+This is then used in our actual deserializer:
+
+```rust
+impl serde::Deserialize for Point {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Point, D::Error>
+        where D: serde::de::Deserializer
+    {
+        deserializer.visit_struct("Point", PointVisitor)
+    }
+}
+
+struct PointVisitor;
+
+impl serde::de::Visitor for PointVisitor {
+    type Value = Point;
+
+    fn visit_map<V>(&mut self, mut visitor: V) -> Result<Point, V::Error>
+        where V: serde::de::MapVisitor
+    {
+        let mut x = None;
+        let mut y = None;
+
+        loop {
+            match try!(visitor.visit_key()) {
+                Some(Field::X) => { x = Some(try!(visitor.visit_value())); }
+                Some(Field::Y) => { y = Some(try!(visitor.visit_value())); }
+                None => { break; }
+            }
+        }
+
+        let x = match x {
+            Some(x) => x,
+            None => try!(visitor.missing_field("x")),
+        };
+
+        let y = match y {
+            Some(y) => y,
+            None => try!(visitor.missing_field("y")),
+        };
+
+        try!(visitor.end());
+
+        Ok(Point{ x: x, y: y })
+    }
+}
+```

serde/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "serde"
+version = "0.5.0"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+license = "MIT/Apache-2.0"
+description = "A generic serialization/deserialization framework"
+repository = "https://github.com/serde-rs/serde"
+documentation = "http://serde-rs.github.io/serde/serde"
+readme = "../README.md"
+keywords = ["serialization"]
+
+[dependencies]
+num = "*"
+
+[features]
+nightly = []
+

serde/src/buf.rs

@@ -0,0 +1,94 @@
+use std::cmp;
+use std::io;
+use std::slice;
+
+trait IntoBufRead {
+    type IntoBuf: io::BufRead + BufReadExt;
+
+    fn into_buf_read(self) -> Self::IntoBuf;
+}
+
+trait BufReadExt {
+    fn get_buf(&self) -> &[u8];
+    fn read_u8(&mut self) -> io::Result<Option<u8>>;
+}
+
+struct SliceReader<'a> {
+    buf: &'a [u8],
+}
+
+impl<'a> io::Read for SliceReader<'a> {
+    #[inline]
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        let amt = cmp::min(buf.len(), self.buf.len());
+        let (a, b) = self.buf.split_at(amt);
+        slice::bytes::copy_memory(buf, a);
+        *self.buf = b;
+        Ok(amt)
+    }
+}
+
+impl<'a> io::BufRead for SliceReader<'a> {
+    fn fill_buf(&mut self) -> io::Result<&[u8]> { Ok(*self) }
+    fn consume(&mut self, amt: usize) { *self.buf = &self.buf[amt..]; }
+}
+
+impl<'a> BufReadExt for SliceReader<'a> {
+    fn get_buf(&self) -> &[u8] { self.buf }
+    fn read_u8(&mut self) -> io::Result<Option<u8>> {
+        let byte = self.buf.get(0);
+        *self.buf = &self.buf[1..];
+        byte
+    }
+}
+
+struct BufReader<R> {
+    inner: R,
+    buf: io::Cursor<Vec<u8>>,
+}
+
+impl<R> BufReader<R> where R: io::Read {
+    fn new(inner: R) -> Self {
+        BufferedReader::with_capacity(io::DEFAULT_BUF_SIZE, inner)
+    }
+
+    fn new(cap: usize, inner: R) -> Self {
+        BufferedReader {
+            inner: inner,
+            buf: io::Cursor::new(Vec::with_capacity(cap)),
+        }
+    }
+
+    fn into_inner(self) -> R {
+        self.inner
+    }
+}
+
+impl<R> Read for BufReader<R> where R: io::Read {
+    fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
+        // If we don't have any buffered data and we're doing a massive read
+        // (larger than our internal buffer), bypass our internal buffer
+        // entirely.
+        if self.buf.get_ref().len() == self.buf.position() as usize &&
+            buf.len() >= self.buf.get_ref().capacity() {
+            return self.inner.read(buf);
+        }
+        try!(self.fill_buf());
+        self.buf.read(buf)
+    }
+}
+
+impl<R> BufReadExt for BufReader<R> {
+    fn get_buf(&self) -> &[u8] {
+        self.buf.get_ref()
+    }
+
+    fn read_u8(&mut self) -> io::Result<Option<u8>> {
+        if self.buf.get_ref().len() == self.buf.position() as usize {
+
+        }
+        let byte = self.buf.get(0);
+        *self.buf = &self.buf[1..];
+        byte
+    }
+}

serde/src/bytes.rs

@@ -0,0 +1,213 @@
+//! Helper module to enable serializing bytes more efficiently
+
+use std::ops;
+use std::fmt;
+use std::ascii;
+
+use ser;
+use de;
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// `Bytes` wraps a `&[u8]` in order to serialize into a byte array.
+#[derive(Clone, Copy, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub struct Bytes<'a> {
+    bytes: &'a [u8],
+}
+
+impl<'a> fmt::Debug for Bytes<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "b\"{}\"", escape_bytestring(self.bytes))
+    }
+}
+
+impl<'a> From<&'a [u8]> for Bytes<'a> {
+    fn from(bytes: &'a [u8]) -> Self {
+        Bytes {
+            bytes: bytes,
+        }
+    }
+}
+
+impl<'a> From<&'a Vec<u8>> for Bytes<'a> {
+    fn from(bytes: &'a Vec<u8>) -> Self {
+        Bytes {
+            bytes: &bytes,
+        }
+    }
+}
+
+impl<'a> Into<&'a [u8]> for Bytes<'a> {
+    fn into(self) -> &'a [u8] {
+        self.bytes
+    }
+}
+
+impl<'a> ops::Deref for Bytes<'a> {
+    type Target = [u8];
+
+    fn deref(&self) -> &[u8] { self.bytes }
+}
+
+impl<'a> ser::Serialize for Bytes<'a> {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer
+    {
+        serializer.visit_bytes(self.bytes)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// `ByteBuf` wraps a `Vec<u8>` in order to hook into serialize and from deserialize a byte array.
+#[derive(Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]
+pub struct ByteBuf {
+    bytes: Vec<u8>,
+}
+
+impl ByteBuf {
+    pub fn new() -> Self {
+        ByteBuf {
+            bytes: Vec::new(),
+        }
+    }
+
+    pub fn with_capacity(cap: usize) -> Self {
+        ByteBuf {
+            bytes: Vec::with_capacity(cap)
+        }
+    }
+}
+
+impl fmt::Debug for ByteBuf {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "b\"{}\"", escape_bytestring(self.bytes.as_ref()))
+    }
+}
+
+impl Into<Vec<u8>> for ByteBuf {
+    fn into(self) -> Vec<u8> {
+        self.bytes
+    }
+}
+
+impl From<Vec<u8>> for ByteBuf {
+    fn from(bytes: Vec<u8>) -> Self {
+        ByteBuf {
+            bytes: bytes,
+        }
+    }
+}
+
+impl AsRef<Vec<u8>> for ByteBuf {
+    fn as_ref(&self) -> &Vec<u8> {
+        &self.bytes
+    }
+}
+
+impl AsRef<[u8]> for ByteBuf {
+    fn as_ref(&self) -> &[u8] {
+        &self.bytes
+    }
+}
+
+impl AsMut<Vec<u8>> for ByteBuf {
+    fn as_mut(&mut self) -> &mut Vec<u8> {
+        &mut self.bytes
+    }
+}
+
+impl AsMut<[u8]> for ByteBuf {
+    fn as_mut(&mut self) -> &mut [u8] {
+        &mut self.bytes
+    }
+}
+
+impl ops::Deref for ByteBuf {
+    type Target = [u8];
+
+    fn deref(&self) -> &[u8] { &self.bytes[..] }
+}
+
+impl ops::DerefMut for ByteBuf {
+    fn deref_mut(&mut self) -> &mut [u8] { &mut self.bytes[..] }
+}
+
+impl ser::Serialize for ByteBuf {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer
+    {
+        serializer.visit_bytes(&self)
+    }
+}
+
+pub struct ByteBufVisitor;
+
+impl de::Visitor for ByteBufVisitor {
+    type Value = ByteBuf;
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<ByteBuf, E>
+        where E: de::Error,
+    {
+        Ok(ByteBuf {
+            bytes: Vec::new(),
+        })
+    }
+
+    #[inline]
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<ByteBuf, V::Error>
+        where V: de::SeqVisitor,
+    {
+        let (len, _) = visitor.size_hint();
+        let mut values = Vec::with_capacity(len);
+
+        while let Some(value) = try!(visitor.visit()) {
+            values.push(value);
+        }
+
+        try!(visitor.end());
+
+        Ok(ByteBuf {
+            bytes: values,
+        })
+    }
+
+    #[inline]
+    fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<ByteBuf, E>
+        where E: de::Error,
+    {
+        self.visit_byte_buf(v.to_vec())
+    }
+
+    #[inline]
+    fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<ByteBuf, E>
+        where E: de::Error,
+    {
+        Ok(ByteBuf {
+            bytes: v,
+        })
+    }
+}
+
+impl de::Deserialize for ByteBuf {
+    #[inline]
+    fn deserialize<D>(deserializer: &mut D) -> Result<ByteBuf, D::Error>
+        where D: de::Deserializer
+    {
+        deserializer.visit_bytes(ByteBufVisitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+fn escape_bytestring(bytes: &[u8]) -> String {
+    let mut result = String::new();
+    for &b in bytes {
+        for esc in ascii::escape_default(b) {
+            result.push(esc as char);
+        }
+    }
+    result
+}

serde/src/de/impls.rs

@@ -0,0 +1,942 @@
+use std::borrow::Cow;
+use std::collections::{
+    BinaryHeap,
+    BTreeMap,
+    BTreeSet,
+    LinkedList,
+    HashMap,
+    HashSet,
+    VecDeque,
+};
+#[cfg(feature = "nightly")]
+use collections::enum_set::{CLike, EnumSet};
+#[cfg(feature = "nightly")]
+use collections::vec_map::VecMap;
+use std::hash::Hash;
+use std::marker::PhantomData;
+use std::path;
+use std::rc::Rc;
+use std::str;
+use std::sync::Arc;
+
+use num::FromPrimitive;
+
+#[cfg(feature = "nightly")]
+use core::nonzero::{NonZero, Zeroable};
+
+#[cfg(feature = "nightly")]
+use std::num::Zero;
+
+use de::{
+    Deserialize,
+    Deserializer,
+    EnumVisitor,
+    Error,
+    MapVisitor,
+    SeqVisitor,
+    VariantVisitor,
+    Visitor,
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct UnitVisitor;
+
+impl Visitor for UnitVisitor {
+    type Value = ();
+
+    fn visit_unit<E>(&mut self) -> Result<(), E>
+        where E: Error,
+    {
+        Ok(())
+    }
+
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<(), V::Error>
+        where V: SeqVisitor,
+    {
+        visitor.end()
+    }
+}
+
+impl Deserialize for () {
+    fn deserialize<D>(deserializer: &mut D) -> Result<(), D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit_unit(UnitVisitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct BoolVisitor;
+
+impl Visitor for BoolVisitor {
+    type Value = bool;
+
+    fn visit_bool<E>(&mut self, v: bool) -> Result<bool, E>
+        where E: Error,
+    {
+        Ok(v)
+    }
+
+    fn visit_str<E>(&mut self, s: &str) -> Result<bool, E>
+        where E: Error,
+    {
+        match s.trim() {
+            "true" => Ok(true),
+            "false" => Ok(false),
+            _ => Err(Error::syntax("expected `true` or `false`")),
+        }
+    }
+}
+
+impl Deserialize for bool {
+    fn deserialize<D>(deserializer: &mut D) -> Result<bool, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit_bool(BoolVisitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+macro_rules! impl_deserialize_num_method {
+    ($src_ty:ty, $method:ident, $from_method:ident) => {
+        #[inline]
+        fn $method<E>(&mut self, v: $src_ty) -> Result<T, E>
+            where E: Error,
+        {
+            match FromPrimitive::$from_method(v) {
+                Some(v) => Ok(v),
+                None => Err(Error::syntax("expected a number")),
+            }
+        }
+    }
+}
+
+pub struct PrimitiveVisitor<T> {
+    marker: PhantomData<T>,
+}
+
+impl<T> PrimitiveVisitor<T> {
+    #[inline]
+    pub fn new() -> Self {
+        PrimitiveVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<
+    T: Deserialize + FromPrimitive + str::FromStr
+> Visitor for PrimitiveVisitor<T> {
+    type Value = T;
+
+    impl_deserialize_num_method!(isize, visit_isize, from_isize);
+    impl_deserialize_num_method!(i8, visit_i8, from_i8);
+    impl_deserialize_num_method!(i16, visit_i16, from_i16);
+    impl_deserialize_num_method!(i32, visit_i32, from_i32);
+    impl_deserialize_num_method!(i64, visit_i64, from_i64);
+    impl_deserialize_num_method!(usize, visit_usize, from_usize);
+    impl_deserialize_num_method!(u8, visit_u8, from_u8);
+    impl_deserialize_num_method!(u16, visit_u16, from_u16);
+    impl_deserialize_num_method!(u32, visit_u32, from_u32);
+    impl_deserialize_num_method!(u64, visit_u64, from_u64);
+    impl_deserialize_num_method!(f32, visit_f32, from_f32);
+    impl_deserialize_num_method!(f64, visit_f64, from_f64);
+
+    #[inline]
+    fn visit_str<E>(&mut self, v: &str) -> Result<T, E>
+        where E: Error,
+    {
+        str::FromStr::from_str(v.trim()).or(Err(Error::syntax("expected a str")))
+    }
+}
+
+macro_rules! impl_deserialize_num {
+    ($ty:ty, $method:ident) => {
+        impl Deserialize for $ty {
+            #[inline]
+            fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
+                where D: Deserializer,
+            {
+                deserializer.$method(PrimitiveVisitor::new())
+            }
+        }
+    }
+}
+
+impl_deserialize_num!(isize, visit_isize);
+impl_deserialize_num!(i8, visit_i8);
+impl_deserialize_num!(i16, visit_i16);
+impl_deserialize_num!(i32, visit_i32);
+impl_deserialize_num!(i64, visit_i64);
+impl_deserialize_num!(usize, visit_usize);
+impl_deserialize_num!(u8, visit_u8);
+impl_deserialize_num!(u16, visit_u16);
+impl_deserialize_num!(u32, visit_u32);
+impl_deserialize_num!(u64, visit_u64);
+impl_deserialize_num!(f32, visit_f32);
+impl_deserialize_num!(f64, visit_f64);
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct CharVisitor;
+
+impl Visitor for CharVisitor {
+    type Value = char;
+
+    #[inline]
+    fn visit_char<E>(&mut self, v: char) -> Result<char, E>
+        where E: Error,
+    {
+        Ok(v)
+    }
+
+    #[inline]
+    fn visit_str<E>(&mut self, v: &str) -> Result<char, E>
+        where E: Error,
+    {
+        let mut iter = v.chars();
+        if let Some(v) = iter.next() {
+            if iter.next().is_some() {
+                Err(Error::syntax("expected a character"))
+            } else {
+                Ok(v)
+            }
+        } else {
+            Err(Error::end_of_stream())
+        }
+    }
+}
+
+impl Deserialize for char {
+    #[inline]
+    fn deserialize<D>(deserializer: &mut D) -> Result<char, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit_char(CharVisitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct StringVisitor;
+
+impl Visitor for StringVisitor {
+    type Value = String;
+
+    fn visit_str<E>(&mut self, v: &str) -> Result<String, E>
+        where E: Error,
+    {
+        Ok(v.to_string())
+    }
+
+    fn visit_string<E>(&mut self, v: String) -> Result<String, E>
+        where E: Error,
+    {
+        Ok(v)
+    }
+
+    fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<String, E>
+        where E: Error,
+    {
+        match str::from_utf8(v) {
+            Ok(s) => Ok(s.to_string()),
+            Err(_) => Err(Error::syntax("expected utf8 `&[u8]`")),
+        }
+    }
+
+    fn visit_byte_buf<'a, E>(&mut self, v: Vec<u8>) -> Result<String, E>
+        where E: Error,
+    {
+        match String::from_utf8(v) {
+            Ok(s) => Ok(s),
+            Err(_) => Err(Error::syntax("expected utf8 `&[u8]`")),
+        }
+    }
+}
+
+impl Deserialize for String {
+    fn deserialize<D>(deserializer: &mut D) -> Result<String, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit_string(StringVisitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct OptionVisitor<T> {
+    marker: PhantomData<T>,
+}
+
+impl<
+    T: Deserialize,
+> Visitor for OptionVisitor<T> {
+    type Value = Option<T>;
+
+    #[inline]
+    fn visit_none<E>(&mut self) -> Result<Option<T>, E>
+        where E: Error,
+    {
+        Ok(None)
+    }
+
+    #[inline]
+    fn visit_some<D>(&mut self, deserializer: &mut D) -> Result<Option<T>, D::Error>
+        where D: Deserializer,
+    {
+        Ok(Some(try!(Deserialize::deserialize(deserializer))))
+    }
+}
+
+impl<T> Deserialize for Option<T> where T: Deserialize {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Option<T>, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit_option(OptionVisitor { marker: PhantomData })
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+macro_rules! set_impl {
+    (
+        $ty:ty,
+        < $($constraints:ident),* >,
+        $visitor_name:ident,
+        $visitor:ident,
+        $ctor:expr,
+        $with_capacity:expr,
+        $insert:expr
+    ) => {
+        pub struct $visitor_name<T> {
+            marker: PhantomData<T>,
+        }
+
+        impl<T> $visitor_name<T> {
+            pub fn new() -> Self {
+                $visitor_name {
+                    marker: PhantomData,
+                }
+            }
+        }
+
+        impl<T> Visitor for $visitor_name<T>
+            where T: $($constraints +)*,
+        {
+            type Value = $ty;
+
+            #[inline]
+            fn visit_unit<E>(&mut self) -> Result<$ty, E>
+                where E: Error,
+            {
+                Ok($ctor)
+            }
+
+            #[inline]
+            fn visit_seq<V>(&mut self, mut $visitor: V) -> Result<$ty, V::Error>
+                where V: SeqVisitor,
+            {
+                let mut values = $with_capacity;
+
+                while let Some(value) = try!($visitor.visit()) {
+                    $insert(&mut values, value);
+                }
+
+                try!($visitor.end());
+
+                Ok(values)
+            }
+        }
+
+        impl<T> Deserialize for $ty
+            where T: $($constraints +)*,
+        {
+            fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
+                where D: Deserializer,
+            {
+                deserializer.visit_seq($visitor_name::new())
+            }
+        }
+    }
+}
+
+set_impl!(
+    BinaryHeap<T>,
+    <Deserialize, Ord>,
+    BinaryHeapVisitor,
+    visitor,
+    BinaryHeap::new(),
+    BinaryHeap::with_capacity(visitor.size_hint().0),
+    BinaryHeap::push);
+
+set_impl!(
+    BTreeSet<T>,
+    <Deserialize, Eq, Ord>,
+    BTreeSetVisitor,
+    visitor,
+    BTreeSet::new(),
+    BTreeSet::new(),
+    BTreeSet::insert);
+
+#[cfg(feature = "nightly")]
+set_impl!(
+    EnumSet<T>,
+    <Deserialize, CLike>,
+    EnumSetVisitor,
+    visitor,
+    EnumSet::new(),
+    EnumSet::new(),
+    EnumSet::insert);
+
+set_impl!(
+    LinkedList<T>,
+    <Deserialize>,
+    LinkedListVisitor,
+    visitor,
+    LinkedList::new(),
+    LinkedList::new(),
+    LinkedList::push_back);
+
+set_impl!(
+    HashSet<T>,
+    <Deserialize, Eq, Hash>,
+    HashSetVisitor,
+    visitor,
+    HashSet::new(),
+    HashSet::with_capacity(visitor.size_hint().0),
+    HashSet::insert);
+
+set_impl!(
+    Vec<T>,
+    <Deserialize>,
+    VecVisitor,
+    visitor,
+    Vec::new(),
+    Vec::with_capacity(visitor.size_hint().0),
+    Vec::push);
+
+set_impl!(
+    VecDeque<T>,
+    <Deserialize>,
+    VecDequeVisitor,
+    visitor,
+    VecDeque::new(),
+    VecDeque::with_capacity(visitor.size_hint().0),
+    VecDeque::push_back);
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct ArrayVisitor0<T> {
+    marker: PhantomData<T>,
+}
+
+impl<T> ArrayVisitor0<T> {
+    pub fn new() -> Self {
+        ArrayVisitor0 {
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T> Visitor for ArrayVisitor0<T> where T: Deserialize + Default {
+    type Value = [T; 0];
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<[T; 0], E>
+        where E: Error,
+    {
+        Ok([T::default(); 0])
+    }
+
+    #[inline]
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<[T; 0], V::Error>
+        where V: SeqVisitor,
+    {
+        try!(visitor.end());
+        Ok([T::default(); 0])
+    }
+}
+
+impl<T> Deserialize for [T; 0]
+    where T: Deserialize + Default
+{
+    fn deserialize<D>(deserializer: &mut D) -> Result<[T; 0], D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit_seq(ArrayVisitor0::new())
+    }
+}
+
+macro_rules! array_impls {
+    ($($visitor:ident, $len:expr => ($($name:ident),+),)+) => {
+        $(
+            struct $visitor<T> {
+                marker: PhantomData<T>,
+            }
+
+            impl<T> $visitor<T> {
+                pub fn new() -> Self {
+                    $visitor {
+                        marker: PhantomData
+                    }
+                }
+            }
+
+            impl<T> Visitor for $visitor<T> where T: Deserialize {
+                type Value = [T; $len];
+
+                #[inline]
+                fn visit_seq<V>(&mut self, mut visitor: V) -> Result<[T; $len], V::Error>
+                    where V: SeqVisitor,
+                {
+                    $(
+                        let $name = match try!(visitor.visit()) {
+                            Some(val) => val,
+                            None => { return Err(Error::end_of_stream()); }
+                        };
+                    )+;
+
+                    try!(visitor.end());
+
+                    Ok([$($name,)+])
+                }
+            }
+
+            impl<T> Deserialize for [T; $len]
+                where T: Deserialize,
+            {
+                fn deserialize<D>(deserializer: &mut D) -> Result<[T; $len], D::Error>
+                    where D: Deserializer,
+                {
+                    deserializer.visit_seq($visitor::new())
+                }
+            }
+        )+
+    }
+}
+
+array_impls! {
+    ArrayVisitor1, 1 => (a),
+    ArrayVisitor2, 2 => (a, b),
+    ArrayVisitor3, 3 => (a, b, c),
+    ArrayVisitor4, 4 => (a, b, c, d),
+    ArrayVisitor5, 5 => (a, b, c, d, e),
+    ArrayVisitor6, 6 => (a, b, c, d, e, f),
+    ArrayVisitor7, 7 => (a, b, c, d, e, f, g),
+    ArrayVisitor8, 8 => (a, b, c, d, e, f, g, h),
+    ArrayVisitor9, 9 => (a, b, c, d, e, f, g, h, i),
+    ArrayVisitor10, 10 => (a, b, c, d, e, f, g, h, i, j),
+    ArrayVisitor11, 11 => (a, b, c, d, e, f, g, h, i, j, k),
+    ArrayVisitor12, 12 => (a, b, c, d, e, f, g, h, i, j, k, l),
+    ArrayVisitor13, 13 => (a, b, c, d, e, f, g, h, i, j, k, l, m),
+    ArrayVisitor14, 14 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n),
+    ArrayVisitor15, 15 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o),
+    ArrayVisitor16, 16 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p),
+    ArrayVisitor17, 17 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q),
+    ArrayVisitor18, 18 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r),
+    ArrayVisitor19, 19 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s),
+    ArrayVisitor20, 20 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s ,t),
+    ArrayVisitor21, 21 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u),
+    ArrayVisitor22, 22 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v),
+    ArrayVisitor23, 23 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w),
+    ArrayVisitor24, 24 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x),
+    ArrayVisitor25, 25 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y),
+    ArrayVisitor26, 26 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z),
+    ArrayVisitor27, 27 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z, aa),
+    ArrayVisitor28, 28 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z, aa, ab),
+    ArrayVisitor29, 29 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z, aa, ab, ac),
+    ArrayVisitor30, 30 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z, aa, ab, ac, ad),
+    ArrayVisitor31, 31 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z, aa, ab, ac, ad, ae),
+    ArrayVisitor32, 32 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
+                           y, z, aa, ab, ac, ad, ae, af),
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+macro_rules! tuple_impls {
+    () => {};
+    ($($len:expr => $visitor:ident => ($($name:ident),+),)+) => {
+        $(
+            pub struct $visitor<$($name,)+> {
+                marker: PhantomData<($($name,)+)>,
+            }
+
+            impl<
+                $($name: Deserialize,)+
+            > $visitor<$($name,)+> {
+                pub fn new() -> Self {
+                    $visitor { marker: PhantomData }
+                }
+            }
+
+
+            impl<
+                $($name: Deserialize,)+
+            > Visitor for $visitor<$($name,)+> {
+                type Value = ($($name,)+);
+
+                #[inline]
+                #[allow(non_snake_case)]
+                fn visit_seq<V>(&mut self, mut visitor: V) -> Result<($($name,)+), V::Error>
+                    where V: SeqVisitor,
+                {
+                    $(
+                        let $name = match try!(visitor.visit()) {
+                            Some(value) => value,
+                            None => { return Err(Error::end_of_stream()); }
+                        };
+                     )+;
+
+                    try!(visitor.end());
+
+                    Ok(($($name,)+))
+                }
+            }
+
+            impl<
+                $($name: Deserialize),+
+            > Deserialize for ($($name,)+) {
+                #[inline]
+                fn deserialize<D>(deserializer: &mut D) -> Result<($($name,)+), D::Error>
+                    where D: Deserializer,
+                {
+                    deserializer.visit_tuple($len, $visitor::new())
+                }
+            }
+        )+
+    }
+}
+
+tuple_impls! {
+    1 => TupleVisitor1 => (T0),
+    2 => TupleVisitor2 => (T0, T1),
+    3 => TupleVisitor3 => (T0, T1, T2),
+    4 => TupleVisitor4 => (T0, T1, T2, T3),
+    5 => TupleVisitor5 => (T0, T1, T2, T3, T4),
+    6 => TupleVisitor6 => (T0, T1, T2, T3, T4, T5),
+    7 => TupleVisitor7 => (T0, T1, T2, T3, T4, T5, T6),
+    8 => TupleVisitor8 => (T0, T1, T2, T3, T4, T5, T6, T7),
+    9 => TupleVisitor9 => (T0, T1, T2, T3, T4, T5, T6, T7, T8),
+    10 => TupleVisitor10 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9),
+    11 => TupleVisitor11 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10),
+    12 => TupleVisitor12 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11),
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+macro_rules! map_impl {
+    (
+        $ty:ty,
+        < $($constraints:ident),* >,
+        $visitor_name:ident,
+        $visitor:ident,
+        $ctor:expr,
+        $with_capacity:expr,
+        $insert:expr
+    ) => {
+        pub struct $visitor_name<K, V> {
+            marker: PhantomData<$ty>,
+        }
+
+        impl<K, V> $visitor_name<K, V> {
+            pub fn new() -> Self {
+                $visitor_name {
+                    marker: PhantomData,
+                }
+            }
+        }
+
+        impl<K, V> Visitor for $visitor_name<K, V>
+            where K: $($constraints +)*,
+                  V: Deserialize,
+        {
+            type Value = $ty;
+
+            #[inline]
+            fn visit_unit<E>(&mut self) -> Result<$ty, E>
+                where E: Error,
+            {
+                Ok($ctor)
+            }
+
+            #[inline]
+            fn visit_map<Visitor>(&mut self, mut $visitor: Visitor) -> Result<$ty, Visitor::Error>
+                where Visitor: MapVisitor,
+            {
+                let mut values = $with_capacity;
+
+                while let Some((key, value)) = try!($visitor.visit()) {
+                    $insert(&mut values, key, value);
+                }
+
+                try!($visitor.end());
+
+                Ok(values)
+            }
+        }
+
+        impl<K, V> Deserialize for $ty
+            where K: $($constraints +)*,
+                  V: Deserialize,
+        {
+            fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
+                where D: Deserializer,
+            {
+                deserializer.visit_map($visitor_name::new())
+            }
+        }
+    }
+}
+
+map_impl!(
+    BTreeMap<K, V>,
+    <Deserialize, Eq, Ord>,
+    BTreeMapVisitor,
+    visitor,
+    BTreeMap::new(),
+    BTreeMap::new(),
+    BTreeMap::insert);
+
+map_impl!(
+    HashMap<K, V>,
+    <Deserialize, Eq, Hash>,
+    HashMapVisitor,
+    visitor,
+    HashMap::new(),
+    HashMap::with_capacity(visitor.size_hint().0),
+    HashMap::insert);
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[cfg(feature = "nightly")]
+pub struct VecMapVisitor<V> {
+    marker: PhantomData<VecMap<V>>,
+}
+
+#[cfg(feature = "nightly")]
+impl<V> VecMapVisitor<V> {
+    #[inline]
+    pub fn new() -> Self {
+        VecMapVisitor {
+            marker: PhantomData,
+        }
+    }
+}
+
+#[cfg(feature = "nightly")]
+impl<V> Visitor for VecMapVisitor<V>
+    where V: Deserialize,
+{
+    type Value = VecMap<V>;
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<VecMap<V>, E>
+        where E: Error,
+    {
+        Ok(VecMap::new())
+    }
+
+    #[inline]
+    fn visit_map<V_>(&mut self, mut visitor: V_) -> Result<VecMap<V>, V_::Error>
+        where V_: MapVisitor,
+    {
+        let (len, _) = visitor.size_hint();
+        let mut values = VecMap::with_capacity(len);
+
+        while let Some((key, value)) = try!(visitor.visit()) {
+            values.insert(key, value);
+        }
+
+        try!(visitor.end());
+
+        Ok(values)
+    }
+}
+
+#[cfg(feature = "nightly")]
+impl<V> Deserialize for VecMap<V>
+    where V: Deserialize,
+{
+    fn deserialize<D>(deserializer: &mut D) -> Result<VecMap<V>, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit_map(VecMapVisitor::new())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct PathBufVisitor;
+
+impl Visitor for PathBufVisitor {
+    type Value = path::PathBuf;
+
+    fn visit_str<E>(&mut self, v: &str) -> Result<path::PathBuf, E>
+        where E: Error,
+    {
+        Ok(From::from(v))
+    }
+
+    fn visit_string<E>(&mut self, v: String) -> Result<path::PathBuf, E>
+        where E: Error,
+    {
+        self.visit_str(&v)
+    }
+}
+
+impl Deserialize for path::PathBuf {
+    fn deserialize<D>(deserializer: &mut D) -> Result<path::PathBuf, D::Error>
+        where D: Deserializer,
+    {
+        deserializer.visit(PathBufVisitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<T: Deserialize> Deserialize for Box<T> {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Box<T>, D::Error>
+        where D: Deserializer,
+    {
+        let val = try!(Deserialize::deserialize(deserializer));
+        Ok(Box::new(val))
+    }
+}
+
+impl<T: Deserialize> Deserialize for Arc<T> {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Arc<T>, D::Error>
+        where D: Deserializer,
+    {
+        let val = try!(Deserialize::deserialize(deserializer));
+        Ok(Arc::new(val))
+    }
+}
+
+impl<T: Deserialize> Deserialize for Rc<T> {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Rc<T>, D::Error>
+        where D: Deserializer,
+    {
+        let val = try!(Deserialize::deserialize(deserializer));
+        Ok(Rc::new(val))
+    }
+}
+
+impl<'a, T: ?Sized> Deserialize for Cow<'a, T> where T: ToOwned, T::Owned: Deserialize, {
+    #[inline]
+    fn deserialize<D>(deserializer: &mut D) -> Result<Cow<'a, T>, D::Error>
+        where D: Deserializer,
+    {
+        let val = try!(Deserialize::deserialize(deserializer));
+        Ok(Cow::Owned(val))
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[cfg(feature = "nightly")]
+impl<T> Deserialize for NonZero<T> where T: Deserialize + PartialEq + Zeroable + Zero {
+    fn deserialize<D>(deserializer: &mut D) -> Result<NonZero<T>, D::Error> where D: Deserializer {
+        let value = try!(Deserialize::deserialize(deserializer));
+        if value == Zero::zero() {
+            return Err(Error::syntax("expected a non-zero value"))
+        }
+        unsafe {
+            Ok(NonZero::new(value))
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+
+impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Result<T, E>, D::Error>
+                      where D: Deserializer {
+        enum Field {
+            Ok,
+            Err,
+        }
+
+        impl Deserialize for Field {
+            #[inline]
+            fn deserialize<D>(deserializer: &mut D) -> Result<Field, D::Error>
+                where D: Deserializer
+            {
+                struct FieldVisitor;
+
+                impl ::de::Visitor for FieldVisitor {
+                    type Value = Field;
+
+                    fn visit_usize<E>(&mut self, value: usize) -> Result<Field, E> where E: Error {
+                        match value {
+                            0 => Ok(Field::Ok),
+                            1 => Ok(Field::Err),
+                            _ => Err(Error::unknown_field(&value.to_string())),
+                        }
+                    }
+
+                    fn visit_str<E>(&mut self, value: &str) -> Result<Field, E> where E: Error {
+                        match value {
+                            "Ok" => Ok(Field::Ok),
+                            "Err" => Ok(Field::Err),
+                            _ => Err(Error::unknown_field(value)),
+                        }
+                    }
+
+                    fn visit_bytes<E>(&mut self, value: &[u8]) -> Result<Field, E> where E: Error {
+                        match value {
+                            b"Ok" => Ok(Field::Ok),
+                            b"Err" => Ok(Field::Err),
+                            _ => {
+                                match str::from_utf8(value) {
+                                    Ok(value) => Err(Error::unknown_field(value)),
+                                    Err(_) => Err(Error::syntax("expected a `&[u8]`")),
+                                }
+                            }
+                        }
+                    }
+                }
+
+                deserializer.visit(FieldVisitor)
+            }
+        }
+
+        struct Visitor<T, E>(PhantomData<Result<T, E>>);
+
+        impl<T, E> EnumVisitor for Visitor<T, E>
+            where T: Deserialize,
+                  E: Deserialize
+        {
+            type Value = Result<T, E>;
+
+            fn visit<V>(&mut self, mut visitor: V) -> Result<Result<T, E>, V::Error>
+                where V: VariantVisitor
+            {
+                match try!(visitor.visit_variant()) {
+                    Field::Ok => {
+                        let value = try!(visitor.visit_newtype());
+                        Ok(Ok(value))
+                    }
+                    Field::Err => {
+                        let value = try!(visitor.visit_newtype());
+                        Ok(Err(value))
+                    }
+                }
+            }
+        }
+
+        const VARIANTS: &'static [&'static str] = &["Ok", "Err"];
+
+        deserializer.visit_enum("Result", VARIANTS, Visitor(PhantomData))
+    }
+}

serde/src/de/mod.rs

@@ -0,0 +1,680 @@
+//! Generic deserialization framework.
+
+pub mod impls;
+pub mod value;
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait Error {
+    fn syntax(msg: &str) -> Self;
+
+    fn end_of_stream() -> Self;
+
+    fn unknown_field(field: &str) -> Self;
+
+    fn missing_field(field: &'static str) -> Self;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait Deserialize {
+    /// Deserialize this value given this `Deserializer`.
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// `Deserializer` is a trait that can deserialize values by threading a `Visitor` trait through a
+/// value. It supports two entry point styles which enables different kinds of deserialization.
+///
+/// 1) The `visit` method. File formats like JSON embed the type of it's construct in it's file
+///    format. This allows the `Deserializer` to deserialize into a generic type like
+///    `json::Value`, which can represent all JSON types.
+///
+/// 2) The `visit_*` methods. File formats like bincode do not embed in it's format how to decode
+///    it's values. It relies instead on the `Deserialize` type to hint to the `Deserializer` with
+///    the `visit_*` methods how it should parse the next value. One downside though to only
+///    supporting the `visit_*` types is that it does not allow for deserializing into a generic
+///    `json::Value`-esque type.
+pub trait Deserializer {
+    type Error: Error;
+
+    /// This method walks a visitor through a value as it is being deserialized.
+    fn visit<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor;
+
+    /// This method hints that the `Deserialize` type is expecting a `bool` value.
+    #[inline]
+    fn visit_bool<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `usize` value.
+    #[inline]
+    fn visit_usize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `u8` value.
+    #[inline]
+    fn visit_u8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `u16` value.
+    #[inline]
+    fn visit_u16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `u32` value.
+    #[inline]
+    fn visit_u32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `u64` value.
+    #[inline]
+    fn visit_u64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `isize` value.
+    #[inline]
+    fn visit_isize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `i8` value.
+    #[inline]
+    fn visit_i8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `i16` value.
+    #[inline]
+    fn visit_i16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `i32` value.
+    #[inline]
+    fn visit_i32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `i64` value.
+    #[inline]
+    fn visit_i64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a `f32` value.
+    #[inline]
+    fn visit_f32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a `f64` value.
+    #[inline]
+    fn visit_f64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a `char` value.
+    #[inline]
+    fn visit_char<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a `&str` value.
+    #[inline]
+    fn visit_str<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a `String` value.
+    #[inline]
+    fn visit_string<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_str(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `unit` value.
+    #[inline]
+    fn visit_unit<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an `Option` value. This allows
+    /// deserializers that encode an optional value as a nullable value to convert the null value
+    /// into a `None`, and a regular value as `Some(value)`.
+    #[inline]
+    fn visit_option<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a sequence value. This allows
+    /// deserializers to parse sequences that aren't tagged as sequences.
+    #[inline]
+    fn visit_seq<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a map of values. This allows
+    /// deserializers to parse sequences that aren't tagged as maps.
+    #[inline]
+    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a unit struct. This allows
+    /// deserializers to a unit struct that aren't tagged as a unit struct.
+    #[inline]
+    fn visit_unit_struct<V>(&mut self,
+                            _name: &'static str,
+                            visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_unit(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a newtype struct. This allows
+    /// deserializers to a newtype struct that aren't tagged as a newtype struct.
+    #[inline]
+    fn visit_newtype_struct<V>(&mut self,
+                               name: &'static str,
+                               visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_tuple_struct(name, 1, visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a tuple struct. This allows
+    /// deserializers to parse sequences that aren't tagged as sequences.
+    #[inline]
+    fn visit_tuple_struct<V>(&mut self,
+                             _name: &'static str,
+                             len: usize,
+                             visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_tuple(len, visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a struct. This allows
+    /// deserializers to parse sequences that aren't tagged as maps.
+    #[inline]
+    fn visit_struct<V>(&mut self,
+                       _name: &'static str,
+                       _fields: &'static [&'static str],
+                       visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_map(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a tuple value. This allows
+    /// deserializers that provide a custom tuple serialization to properly deserialize the type.
+    #[inline]
+    fn visit_tuple<V>(&mut self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_seq(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting an enum value. This allows
+    /// deserializers that provide a custom enumeration serialization to properly deserialize the
+    /// type.
+    #[inline]
+    fn visit_enum<V>(&mut self,
+                     _enum: &'static str,
+                     _variants: &'static [&'static str],
+                     _visitor: V) -> Result<V::Value, Self::Error>
+        where V: EnumVisitor,
+    {
+        Err(Error::syntax("expected an enum"))
+    }
+
+    /// This method hints that the `Deserialize` type is expecting a `Vec<u8>`. This allows
+    /// deserializers that provide a custom byte vector serialization to properly deserialize the
+    /// type.
+    #[inline]
+    fn visit_bytes<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.visit_seq(visitor)
+    }
+
+    /// Specify a format string for the deserializer.
+    ///
+    /// The deserializer format is used to determine which format
+    /// specific field attributes should be used with the
+    /// deserializer.
+    fn format() -> &'static str {
+        ""
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait Visitor {
+    type Value: Deserialize;
+
+    fn visit_bool<E>(&mut self, _v: bool) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax("expected a bool"))
+    }
+
+    fn visit_isize<E>(&mut self, v: isize) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_i64(v as i64)
+    }
+
+    fn visit_i8<E>(&mut self, v: i8) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_i64(v as i64)
+    }
+
+    fn visit_i16<E>(&mut self, v: i16) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_i64(v as i64)
+    }
+
+    fn visit_i32<E>(&mut self, v: i32) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_i64(v as i64)
+    }
+
+    fn visit_i64<E>(&mut self, _v: i64) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax("expected a i64"))
+    }
+
+    fn visit_usize<E>(&mut self, v: usize) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_u64(v as u64)
+    }
+
+    fn visit_u8<E>(&mut self, v: u8) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_u64(v as u64)
+    }
+
+    fn visit_u16<E>(&mut self, v: u16) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_u64(v as u64)
+    }
+
+    fn visit_u32<E>(&mut self, v: u32) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_u64(v as u64)
+    }
+
+    fn visit_u64<E>(&mut self, _v: u64) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax("expected a u64"))
+    }
+
+    fn visit_f32<E>(&mut self, v: f32) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_f64(v as f64)
+    }
+
+    fn visit_f64<E>(&mut self, _v: f64) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax("expected a f64"))
+    }
+
+    #[inline]
+    fn visit_char<E>(&mut self, v: char) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        // FIXME: this allocation is required in order to be compatible with stable rust, which
+        // doesn't support encoding a `char` into a stack buffer.
+        self.visit_string(v.to_string())
+    }
+
+    fn visit_str<E>(&mut self, _v: &str) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax("expected a str"))
+    }
+
+    #[inline]
+    fn visit_string<E>(&mut self, v: String) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_str(&v)
+    }
+
+    fn visit_unit<E>(&mut self) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax("expected a unit"))
+    }
+
+    #[inline]
+    fn visit_unit_struct<E>(&mut self, _name: &'static str) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_unit()
+    }
+
+    fn visit_none<E>(&mut self) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax("expected an Option::None"))
+    }
+
+    fn visit_some<D>(&mut self, _deserializer: &mut D) -> Result<Self::Value, D::Error>
+        where D: Deserializer,
+    {
+        Err(Error::syntax("expected an Option::Some"))
+    }
+
+    fn visit_newtype_struct<D>(&mut self, _deserializer: &mut D) -> Result<Self::Value, D::Error>
+        where D: Deserializer,
+    {
+        Err(Error::syntax("expected a newtype struct"))
+    }
+
+    fn visit_seq<V>(&mut self, _visitor: V) -> Result<Self::Value, V::Error>
+        where V: SeqVisitor,
+    {
+        Err(Error::syntax("expected a sequence"))
+    }
+
+    fn visit_map<V>(&mut self, _visitor: V) -> Result<Self::Value, V::Error>
+        where V: MapVisitor,
+    {
+        Err(Error::syntax("expected a map"))
+    }
+
+    fn visit_bytes<E>(&mut self, _v: &[u8]) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        Err(Error::syntax("expected a &[u8]"))
+    }
+
+    fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<Self::Value, E>
+        where E: Error,
+    {
+        self.visit_bytes(&v)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait SeqVisitor {
+    type Error: Error;
+
+    fn visit<T>(&mut self) -> Result<Option<T>, Self::Error>
+        where T: Deserialize;
+
+    fn end(&mut self) -> Result<(), Self::Error>;
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, None)
+    }
+}
+
+impl<'a, V> SeqVisitor for &'a mut V where V: SeqVisitor {
+    type Error = V::Error;
+
+    #[inline]
+    fn visit<T>(&mut self) -> Result<Option<T>, V::Error>
+        where T: Deserialize
+    {
+        (**self).visit()
+    }
+
+    #[inline]
+    fn end(&mut self) -> Result<(), V::Error> {
+        (**self).end()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (**self).size_hint()
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait MapVisitor {
+    type Error: Error;
+
+    #[inline]
+    fn visit<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
+        where K: Deserialize,
+              V: Deserialize,
+    {
+        match try!(self.visit_key()) {
+            Some(key) => {
+                let value = try!(self.visit_value());
+                Ok(Some((key, value)))
+            }
+            None => Ok(None)
+        }
+    }
+
+    fn visit_key<K>(&mut self) -> Result<Option<K>, Self::Error>
+        where K: Deserialize;
+
+    fn visit_value<V>(&mut self) -> Result<V, Self::Error>
+        where V: Deserialize;
+
+    fn end(&mut self) -> Result<(), Self::Error>;
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (0, None)
+    }
+
+    fn missing_field<V>(&mut self, field: &'static str) -> Result<V, Self::Error>
+        where V: Deserialize,
+    {
+        Err(Error::missing_field(field))
+    }
+}
+
+impl<'a, V_> MapVisitor for &'a mut V_ where V_: MapVisitor {
+    type Error = V_::Error;
+
+    #[inline]
+    fn visit<K, V>(&mut self) -> Result<Option<(K, V)>, V_::Error>
+        where K: Deserialize,
+              V: Deserialize,
+    {
+        (**self).visit()
+    }
+
+    #[inline]
+    fn visit_key<K>(&mut self) -> Result<Option<K>, V_::Error>
+        where K: Deserialize
+    {
+        (**self).visit_key()
+    }
+
+    #[inline]
+    fn visit_value<V>(&mut self) -> Result<V, V_::Error>
+        where V: Deserialize
+    {
+        (**self).visit_value()
+    }
+
+    #[inline]
+    fn end(&mut self) -> Result<(), V_::Error> {
+        (**self).end()
+    }
+
+    #[inline]
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (**self).size_hint()
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// `EnumVisitor` is a visitor that is created by the `Deserialize` and passed to the
+/// `Deserializer` in order to deserialize enums.
+pub trait EnumVisitor {
+    type Value;
+
+    fn visit<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
+        where V: VariantVisitor;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// `VariantVisitor` is a visitor that is created by the `Deserializer` and passed to the
+/// `Deserialize` in order to deserialize a specific enum variant.
+pub trait VariantVisitor {
+    type Error: Error;
+
+    /// `visit_variant` is called to identify which variant to deserialize.
+    fn visit_variant<V>(&mut self) -> Result<V, Self::Error>
+        where V: Deserialize;
+
+    /// `visit_unit` is called when deserializing a variant with no values.
+    fn visit_unit(&mut self) -> Result<(), Self::Error> {
+        Err(Error::syntax("expected a univ variant"))
+    }
+
+    /// `visit_newtype` is called when deserializing a variant with a single value. By default this
+    /// uses the `visit_tuple` method to deserialize the value.
+    #[inline]
+    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
+        where T: Deserialize,
+    {
+        let (value,) = try!(self.visit_tuple(1, impls::TupleVisitor1::new()));
+        Ok(value)
+    }
+
+    /// `visit_tuple` is called when deserializing a tuple-like variant.
+    fn visit_tuple<V>(&mut self,
+                      _len: usize,
+                      _visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        Err(Error::syntax("expected a tuple variant"))
+    }
+
+    /// `visit_struct` is called when deserializing a struct-like variant.
+    fn visit_struct<V>(&mut self,
+                       _fields: &'static [&'static str],
+                       _visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        Err(Error::syntax("expected a struct variant"))
+    }
+}
+
+impl<'a, T> VariantVisitor for &'a mut T where T: VariantVisitor {
+    type Error = T::Error;
+
+    fn visit_variant<V>(&mut self) -> Result<V, T::Error>
+        where V: Deserialize
+    {
+        (**self).visit_variant()
+    }
+
+    fn visit_unit(&mut self) -> Result<(), T::Error> {
+        (**self).visit_unit()
+    }
+
+    fn visit_newtype<D>(&mut self) -> Result<D, T::Error>
+        where D: Deserialize,
+    {
+        (**self).visit_newtype()
+    }
+
+    fn visit_tuple<V>(&mut self,
+                      len: usize,
+                      visitor: V) -> Result<V::Value, T::Error>
+        where V: Visitor,
+    {
+        (**self).visit_tuple(len, visitor)
+    }
+
+    fn visit_struct<V>(&mut self,
+                    fields: &'static [&'static str],
+                    visitor: V) -> Result<V::Value, T::Error>
+        where V: Visitor,
+    {
+        (**self).visit_struct(fields, visitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait EnumSeqVisitor {
+    type Value;
+
+    fn visit<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
+        where V: SeqVisitor;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait EnumMapVisitor {
+    type Value;
+
+    fn visit<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
+        where V: MapVisitor;
+}

serde/src/de/value.rs

@@ -0,0 +1,471 @@
+use std::collections::{
+    BTreeMap,
+    BTreeSet,
+    HashMap,
+    HashSet,
+    btree_map,
+    btree_set,
+    hash_map,
+    hash_set,
+};
+use std::hash::Hash;
+use std::vec;
+
+use de;
+use bytes;
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub enum Error {
+    SyntaxError,
+    EndOfStreamError,
+    UnknownFieldError(String),
+    MissingFieldError(&'static str),
+}
+
+impl de::Error for Error {
+    fn syntax(_: &str) -> Self { Error::SyntaxError }
+    fn end_of_stream() -> Self { Error::EndOfStreamError }
+    fn unknown_field(field: &str) -> Self { Error::UnknownFieldError(String::from(field)) }
+    fn missing_field(field: &'static str) -> Self { Error::MissingFieldError(field) }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait ValueDeserializer {
+    type Deserializer: de::Deserializer<Error=Error>;
+
+    fn into_deserializer(self) -> Self::Deserializer;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl ValueDeserializer for () {
+    type Deserializer = UnitDeserializer;
+
+    fn into_deserializer(self) -> UnitDeserializer {
+        UnitDeserializer
+    }
+}
+
+/// A helper deserializer that deserializes a `()`.
+pub struct UnitDeserializer;
+
+impl de::Deserializer for UnitDeserializer {
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_unit()
+    }
+
+    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_none()
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+macro_rules! primitive_deserializer {
+    ($ty:ty, $name:ident, $method:ident) => {
+        pub struct $name(Option<$ty>);
+
+        impl ValueDeserializer for $ty {
+            type Deserializer = $name;
+
+            fn into_deserializer(self) -> $name {
+                $name(Some(self))
+            }
+        }
+
+        impl de::Deserializer for $name {
+            type Error = Error;
+
+            fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+                where V: de::Visitor,
+            {
+                match self.0.take() {
+                    Some(v) => visitor.$method(v),
+                    None => Err(de::Error::end_of_stream()),
+                }
+            }
+        }
+    }
+}
+
+primitive_deserializer!(bool, BoolDeserializer, visit_bool);
+primitive_deserializer!(i8, I8Deserializer, visit_i8);
+primitive_deserializer!(i16, I16Deserializer, visit_i16);
+primitive_deserializer!(i32, I32Deserializer, visit_i32);
+primitive_deserializer!(i64, I64Deserializer, visit_i64);
+primitive_deserializer!(isize, IsizeDeserializer, visit_isize);
+primitive_deserializer!(u8, U8Deserializer, visit_u8);
+primitive_deserializer!(u16, U16Deserializer, visit_u16);
+primitive_deserializer!(u32, U32Deserializer, visit_u32);
+primitive_deserializer!(u64, U64Deserializer, visit_u64);
+primitive_deserializer!(usize, UsizeDeserializer, visit_usize);
+primitive_deserializer!(f32, F32Deserializer, visit_f32);
+primitive_deserializer!(f64, F64Deserializer, visit_f64);
+primitive_deserializer!(char, CharDeserializer, visit_char);
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// A helper deserializer that deserializes a `&str`.
+pub struct StrDeserializer<'a>(Option<&'a str>);
+
+impl<'a> ValueDeserializer for &'a str {
+    type Deserializer = StrDeserializer<'a>;
+
+    fn into_deserializer(self) -> StrDeserializer<'a> {
+        StrDeserializer(Some(self))
+    }
+}
+
+impl<'a> de::Deserializer for StrDeserializer<'a> {
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.0.take() {
+            Some(v) => visitor.visit_str(v),
+            None => Err(de::Error::end_of_stream()),
+        }
+    }
+
+    fn visit_enum<V>(&mut self,
+                     _name: &str,
+                     _variants: &'static [&'static str],
+                     mut visitor: V) -> Result<V::Value, Error>
+        where V: de::EnumVisitor,
+    {
+        visitor.visit(self)
+    }
+}
+
+impl<'a> de::VariantVisitor for StrDeserializer<'a> {
+    type Error = Error;
+
+    fn visit_variant<T>(&mut self) -> Result<T, Error>
+        where T: de::Deserialize,
+    {
+        de::Deserialize::deserialize(self)
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Error> {
+        Ok(())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// A helper deserializer that deserializes a `String`.
+pub struct StringDeserializer(Option<String>);
+
+impl ValueDeserializer for String {
+    type Deserializer = StringDeserializer;
+
+    fn into_deserializer(self) -> StringDeserializer {
+        StringDeserializer(Some(self))
+    }
+}
+
+impl de::Deserializer for StringDeserializer {
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.0.take() {
+            Some(string) => visitor.visit_string(string),
+            None => Err(de::Error::end_of_stream()),
+        }
+    }
+
+    fn visit_enum<V>(&mut self,
+                     _name: &str,
+                     _variants: &'static [&'static str],
+                     mut visitor: V) -> Result<V::Value, Error>
+        where V: de::EnumVisitor,
+    {
+        visitor.visit(self)
+    }
+}
+
+impl<'a> de::VariantVisitor for StringDeserializer {
+    type Error = Error;
+
+    fn visit_variant<T>(&mut self) -> Result<T, Error>
+        where T: de::Deserialize,
+    {
+        de::Deserialize::deserialize(self)
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Error> {
+        Ok(())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct SeqDeserializer<I> {
+    iter: I,
+    len: usize,
+}
+
+impl<I> SeqDeserializer<I> {
+    pub fn new(iter: I, len: usize) -> Self {
+        SeqDeserializer {
+            iter: iter,
+            len: len,
+        }
+    }
+}
+
+impl<I, T> de::Deserializer for SeqDeserializer<I>
+    where I: Iterator<Item=T>,
+          T: ValueDeserializer,
+{
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_seq(self)
+    }
+}
+
+impl<I, T> de::SeqVisitor for SeqDeserializer<I>
+    where I: Iterator<Item=T>,
+          T: ValueDeserializer,
+{
+    type Error = Error;
+
+    fn visit<V>(&mut self) -> Result<Option<V>, Error>
+        where V: de::Deserialize
+    {
+        match self.iter.next() {
+            Some(value) => {
+                self.len -= 1;
+                let mut de = value.into_deserializer();
+                Ok(Some(try!(de::Deserialize::deserialize(&mut de))))
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        if self.len == 0 {
+            Ok(())
+        } else {
+            Err(de::Error::end_of_stream())
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len, Some(self.len))
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<T> ValueDeserializer for Vec<T>
+    where T: ValueDeserializer,
+{
+    type Deserializer = SeqDeserializer<vec::IntoIter<T>>;
+
+    fn into_deserializer(self) -> SeqDeserializer<vec::IntoIter<T>> {
+        let len = self.len();
+        SeqDeserializer::new(self.into_iter(), len)
+    }
+}
+
+impl<T> ValueDeserializer for BTreeSet<T>
+    where T: ValueDeserializer + Eq + Ord,
+{
+    type Deserializer = SeqDeserializer<btree_set::IntoIter<T>>;
+
+    fn into_deserializer(self) -> SeqDeserializer<btree_set::IntoIter<T>> {
+        let len = self.len();
+        SeqDeserializer::new(self.into_iter(), len)
+    }
+}
+
+impl<T> ValueDeserializer for HashSet<T>
+    where T: ValueDeserializer + Eq + Hash,
+{
+    type Deserializer = SeqDeserializer<hash_set::IntoIter<T>>;
+
+    fn into_deserializer(self) -> SeqDeserializer<hash_set::IntoIter<T>> {
+        let len = self.len();
+        SeqDeserializer::new(self.into_iter(), len)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct MapDeserializer<I, K, V>
+    where I: Iterator<Item=(K, V)>,
+          K: ValueDeserializer,
+          V: ValueDeserializer,
+{
+    iter: I,
+    value: Option<V>,
+    len: usize,
+}
+
+impl<I, K, V> MapDeserializer<I, K, V>
+    where I: Iterator<Item=(K, V)>,
+          K: ValueDeserializer,
+          V: ValueDeserializer,
+{
+    pub fn new(iter: I, len: usize) -> Self {
+        MapDeserializer {
+            iter: iter,
+            value: None,
+            len: len,
+        }
+    }
+}
+
+impl<I, K, V> de::Deserializer for MapDeserializer<I, K, V>
+    where I: Iterator<Item=(K, V)>,
+          K: ValueDeserializer,
+          V: ValueDeserializer,
+{
+    type Error = Error;
+
+    fn visit<V_>(&mut self, mut visitor: V_) -> Result<V_::Value, Error>
+        where V_: de::Visitor,
+    {
+        visitor.visit_map(self)
+    }
+}
+
+impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
+    where I: Iterator<Item=(K, V)>,
+          K: ValueDeserializer,
+          V: ValueDeserializer,
+{
+    type Error = Error;
+
+    fn visit_key<T>(&mut self) -> Result<Option<T>, Error>
+        where T: de::Deserialize,
+    {
+        match self.iter.next() {
+            Some((key, value)) => {
+                self.len -= 1;
+                self.value = Some(value);
+                let mut de = key.into_deserializer();
+                Ok(Some(try!(de::Deserialize::deserialize(&mut de))))
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn visit_value<T>(&mut self) -> Result<T, Error>
+        where T: de::Deserialize,
+    {
+        match self.value.take() {
+            Some(value) => {
+                let mut de = value.into_deserializer();
+                de::Deserialize::deserialize(&mut de)
+            }
+            None => Err(de::Error::syntax("expected a map value"))
+        }
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        if self.len == 0 {
+            Ok(())
+        } else {
+            Err(de::Error::end_of_stream())
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len, Some(self.len))
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<K, V> ValueDeserializer for BTreeMap<K, V>
+    where K: ValueDeserializer + Eq + Ord,
+          V: ValueDeserializer,
+{
+    type Deserializer = MapDeserializer<btree_map::IntoIter<K, V>, K, V>;
+
+    fn into_deserializer(self) -> MapDeserializer<btree_map::IntoIter<K, V>, K, V> {
+        let len = self.len();
+        MapDeserializer::new(self.into_iter(), len)
+    }
+}
+
+impl<K, V> ValueDeserializer for HashMap<K, V>
+    where K: ValueDeserializer + Eq + Hash,
+          V: ValueDeserializer,
+{
+    type Deserializer = MapDeserializer<hash_map::IntoIter<K, V>, K, V>;
+
+    fn into_deserializer(self) -> MapDeserializer<hash_map::IntoIter<K, V>, K, V> {
+        let len = self.len();
+        MapDeserializer::new(self.into_iter(), len)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<'a> ValueDeserializer for bytes::Bytes<'a>
+{
+    type Deserializer = BytesDeserializer<'a>;
+
+    fn into_deserializer(self) -> BytesDeserializer<'a> {
+        BytesDeserializer(Some(self.into()))
+    }
+}
+
+pub struct BytesDeserializer<'a> (Option<&'a [u8]>);
+
+impl<'a> de::Deserializer for BytesDeserializer<'a> {
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.0.take() {
+            Some(bytes) => visitor.visit_bytes(bytes),
+            None => Err(de::Error::end_of_stream()),
+        }
+    }
+}
+
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl ValueDeserializer for bytes::ByteBuf
+{
+    type Deserializer = ByteBufDeserializer;
+
+    fn into_deserializer(self) -> Self::Deserializer {
+        ByteBufDeserializer(Some(self.into()))
+    }
+}
+
+pub struct ByteBufDeserializer(Option<Vec<u8>>);
+
+impl de::Deserializer for ByteBufDeserializer {
+    type Error = Error;
+
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.0.take() {
+            Some(bytes) => visitor.visit_byte_buf(bytes),
+            None => Err(de::Error::end_of_stream()),
+        }
+    }
+}

serde/src/iter.rs

@@ -0,0 +1,57 @@
+use std::io;
+use std::iter::Peekable;
+
+pub struct LineColIterator<Iter: Iterator<Item=io::Result<u8>>> {
+    iter: Iter,
+    line: usize,
+    col: usize,
+}
+
+impl<Iter: Iterator<Item=io::Result<u8>>> LineColIterator<Iter> {
+    pub fn new(iter: Iter) -> LineColIterator<Iter> {
+        LineColIterator {
+            iter: iter,
+            line: 1,
+            col: 0,
+        }
+    }
+
+    /// Report the current line inside the iterator.
+    pub fn line(&self) -> usize { self.line }
+
+    /// Report the current column inside the iterator.
+    pub fn col(&self) -> usize { self.col }
+
+    /// Gets a reference to the underlying iterator.
+    pub fn get_ref(&self) -> &Iter { &self.iter }
+
+    /// Gets a mutable reference to the underlying iterator.
+    pub fn get_mut(&mut self) -> &mut Iter { &mut self.iter }
+
+    /// Unwraps this `LineColIterator`, returning the underlying iterator.
+    pub fn into_inner(self) -> Iter { self.iter }
+}
+
+impl<Iter: Iterator<Item=io::Result<u8>>> LineColIterator<Peekable<Iter>> {
+    /// peeks at the next value
+    pub fn peek(&mut self) -> Option<&io::Result<u8>> { self.iter.peek() }
+}
+
+impl<Iter: Iterator<Item=io::Result<u8>>> Iterator for LineColIterator<Iter> {
+    type Item = io::Result<u8>;
+    fn next(&mut self) -> Option<io::Result<u8>> {
+        match self.iter.next() {
+            None => None,
+            Some(Ok(b'\n')) => {
+                self.line += 1;
+                self.col = 0;
+                Some(Ok(b'\n'))
+            },
+            Some(Ok(c)) => {
+                self.col += 1;
+                Some(Ok(c))
+            },
+            Some(Err(e)) => Some(Err(e)),
+        }
+    }
+}

serde/src/lib.rs

@@ -0,0 +1,25 @@
+//! Serde Serialization Framework
+//!
+//! Serde is a powerful framework that enables serialization libraries to generically serialize
+//! Rust data structures without the overhead of runtime type information. In many situations, the
+//! handshake protocol between serializers and serializees can be completely optimized away,
+//! leaving serde to perform roughly the same speed as a hand written serializer for a specific
+//! type.
+#![doc(html_root_url="https://serde-rs.github.io/serde/serde")]
+#![cfg_attr(feature = "nightly", feature(collections, core, enumset, nonzero, step_trait, vecmap, zero_one))]
+
+extern crate num;
+
+#[cfg(feature = "nightly")]
+extern crate collections;
+
+#[cfg(feature = "nightly")]
+extern crate core;
+
+pub use ser::{Serialize, Serializer};
+pub use de::{Deserialize, Deserializer, Error};
+
+pub mod bytes;
+pub mod de;
+pub mod iter;
+pub mod ser;

serde/src/ser/impls.rs

@@ -0,0 +1,667 @@
+use std::borrow::Cow;
+use std::collections::{
+    BinaryHeap,
+    BTreeMap,
+    BTreeSet,
+    LinkedList,
+    HashMap,
+    HashSet,
+    VecDeque,
+};
+#[cfg(feature = "nightly")]
+use collections::enum_set::{CLike, EnumSet};
+#[cfg(feature = "nightly")]
+use std::collections::vec_map::VecMap;
+use std::hash::Hash;
+#[cfg(feature = "nightly")]
+use std::iter;
+#[cfg(feature = "nightly")]
+use std::num;
+#[cfg(feature = "nightly")]
+use std::ops;
+use std::path;
+use std::rc::Rc;
+use std::sync::Arc;
+
+#[cfg(feature = "nightly")]
+use core::nonzero::{NonZero, Zeroable};
+
+use super::{
+    Serialize,
+    Serializer,
+    SeqVisitor,
+    MapVisitor,
+};
+
+///////////////////////////////////////////////////////////////////////////////
+
+macro_rules! impl_visit {
+    ($ty:ty, $method:ident) => {
+        impl Serialize for $ty {
+            #[inline]
+            fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+                where S: Serializer,
+            {
+                serializer.$method(*self)
+            }
+        }
+    }
+}
+
+impl_visit!(bool, visit_bool);
+impl_visit!(isize, visit_isize);
+impl_visit!(i8, visit_i8);
+impl_visit!(i16, visit_i16);
+impl_visit!(i32, visit_i32);
+impl_visit!(i64, visit_i64);
+impl_visit!(usize, visit_usize);
+impl_visit!(u8, visit_u8);
+impl_visit!(u16, visit_u16);
+impl_visit!(u32, visit_u32);
+impl_visit!(u64, visit_u64);
+impl_visit!(f32, visit_f32);
+impl_visit!(f64, visit_f64);
+impl_visit!(char, visit_char);
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl Serialize for str {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_str(self)
+    }
+}
+
+impl Serialize for String {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (&self[..]).serialize(serializer)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<T> Serialize for Option<T> where T: Serialize {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        match *self {
+            Some(ref value) => serializer.visit_some(value),
+            None => serializer.visit_none(),
+        }
+    }
+}
+
+impl<T> SeqVisitor for Option<T> where T: Serialize {
+    #[inline]
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: Serializer,
+    {
+        match self.take() {
+            Some(value) => {
+                try!(serializer.visit_seq_elt(value));
+                Ok(Some(()))
+            }
+            None => Ok(None),
+        }
+    }
+
+    #[inline]
+    fn len(&self) -> Option<usize> {
+        Some(if self.is_some() { 1 } else { 0 })
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct SeqIteratorVisitor<Iter> {
+    iter: Iter,
+    len: Option<usize>,
+}
+
+impl<T, Iter> SeqIteratorVisitor<Iter>
+    where Iter: Iterator<Item=T>
+{
+    #[inline]
+    pub fn new(iter: Iter, len: Option<usize>) -> SeqIteratorVisitor<Iter> {
+        SeqIteratorVisitor {
+            iter: iter,
+            len: len,
+        }
+    }
+}
+
+impl<T, Iter> SeqVisitor for SeqIteratorVisitor<Iter>
+    where T: Serialize,
+          Iter: Iterator<Item=T>,
+{
+    #[inline]
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: Serializer,
+    {
+        match self.iter.next() {
+            Some(value) => {
+                try!(serializer.visit_seq_elt(value));
+                Ok(Some(()))
+            }
+            None => Ok(None),
+        }
+    }
+
+    #[inline]
+    fn len(&self) -> Option<usize> {
+        self.len
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<T> Serialize for [T]
+    where T: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+macro_rules! array_impls {
+    ($len:expr) => {
+        impl<T> Serialize for [T; $len] where T: Serialize {
+            #[inline]
+            fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+                where S: Serializer,
+            {
+                serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some($len)))
+            }
+        }
+    }
+}
+
+array_impls!(0);
+array_impls!(1);
+array_impls!(2);
+array_impls!(3);
+array_impls!(4);
+array_impls!(5);
+array_impls!(6);
+array_impls!(7);
+array_impls!(8);
+array_impls!(9);
+array_impls!(10);
+array_impls!(11);
+array_impls!(12);
+array_impls!(13);
+array_impls!(14);
+array_impls!(15);
+array_impls!(16);
+array_impls!(17);
+array_impls!(18);
+array_impls!(19);
+array_impls!(20);
+array_impls!(21);
+array_impls!(22);
+array_impls!(23);
+array_impls!(24);
+array_impls!(25);
+array_impls!(26);
+array_impls!(27);
+array_impls!(28);
+array_impls!(29);
+array_impls!(30);
+array_impls!(31);
+array_impls!(32);
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<T> Serialize for BinaryHeap<T>
+    where T: Serialize + Ord
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+impl<T> Serialize for BTreeSet<T>
+    where T: Serialize + Ord,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+#[cfg(feature = "nightly")]
+impl<T> Serialize for EnumSet<T>
+    where T: Serialize + CLike
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+impl<T> Serialize for HashSet<T>
+    where T: Serialize + Eq + Hash,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+impl<T> Serialize for LinkedList<T>
+    where T: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+#[cfg(feature = "nightly")]
+impl<A> Serialize for ops::Range<A>
+    where A: Serialize + Clone + iter::Step + num::One,
+          for<'a> &'a A: ops::Add<&'a A, Output = A>,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        let len = iter::Step::steps_between(&self.start, &self.end, &A::one());
+        serializer.visit_seq(SeqIteratorVisitor::new(self.clone(), len))
+    }
+}
+
+impl<T> Serialize for Vec<T> where T: Serialize {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (&self[..]).serialize(serializer)
+    }
+}
+
+impl<T> Serialize for VecDeque<T> where T: Serialize {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl Serialize for () {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_unit()
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// FIXME(rust #19630) Remove this work-around
+macro_rules! e {
+    ($e:expr) => { $e }
+}
+
+macro_rules! tuple_impls {
+    ($(
+        $TupleVisitor:ident ($len:expr, $($T:ident),+) {
+            $($state:pat => $idx:tt,)+
+        }
+    )+) => {
+        $(
+            pub struct $TupleVisitor<'a, $($T: 'a),+> {
+                tuple: &'a ($($T,)+),
+                state: u8,
+            }
+
+            impl<'a, $($T: 'a),+> $TupleVisitor<'a, $($T),+> {
+                pub fn new(tuple: &'a ($($T,)+)) -> $TupleVisitor<'a, $($T),+> {
+                    $TupleVisitor {
+                        tuple: tuple,
+                        state: 0,
+                    }
+                }
+            }
+
+            impl<'a, $($T),+> SeqVisitor for $TupleVisitor<'a, $($T),+>
+                where $($T: Serialize),+
+            {
+                fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+                    where S: Serializer,
+                {
+                    match self.state {
+                        $(
+                            $state => {
+                                self.state += 1;
+                                Ok(Some(try!(serializer.visit_tuple_elt(&e!(self.tuple.$idx)))))
+                            }
+                        )+
+                        _ => {
+                            Ok(None)
+                        }
+                    }
+                }
+
+                fn len(&self) -> Option<usize> {
+                    Some($len)
+                }
+            }
+
+            impl<$($T),+> Serialize for ($($T,)+)
+                where $($T: Serialize),+
+            {
+                #[inline]
+                fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
+                    serializer.visit_tuple($TupleVisitor::new(self))
+                }
+            }
+        )+
+    }
+}
+
+tuple_impls! {
+    TupleVisitor1 (1, T0) {
+        0 => 0,
+    }
+    TupleVisitor2 (2, T0, T1) {
+        0 => 0,
+        1 => 1,
+    }
+    TupleVisitor3 (3, T0, T1, T2) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+    }
+    TupleVisitor4 (4, T0, T1, T2, T3) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+    }
+    TupleVisitor5 (5, T0, T1, T2, T3, T4) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+    }
+    TupleVisitor6 (6, T0, T1, T2, T3, T4, T5) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+    }
+    TupleVisitor7 (7, T0, T1, T2, T3, T4, T5, T6) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+        6 => 6,
+    }
+    TupleVisitor8 (8, T0, T1, T2, T3, T4, T5, T6, T7) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+        6 => 6,
+        7 => 7,
+    }
+    TupleVisitor9 (9, T0, T1, T2, T3, T4, T5, T6, T7, T8) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+        6 => 6,
+        7 => 7,
+        8 => 8,
+    }
+    TupleVisitor10 (10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+        6 => 6,
+        7 => 7,
+        8 => 8,
+        9 => 9,
+    }
+    TupleVisitor11 (11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+        6 => 6,
+        7 => 7,
+        8 => 8,
+        9 => 9,
+        10 => 10,
+    }
+    TupleVisitor12 (12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {
+        0 => 0,
+        1 => 1,
+        2 => 2,
+        3 => 3,
+        4 => 4,
+        5 => 5,
+        6 => 6,
+        7 => 7,
+        8 => 8,
+        9 => 9,
+        10 => 10,
+        11 => 11,
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub struct MapIteratorVisitor<Iter> {
+    iter: Iter,
+    len: Option<usize>,
+}
+
+impl<K, V, Iter> MapIteratorVisitor<Iter>
+    where Iter: Iterator<Item=(K, V)>
+{
+    #[inline]
+    pub fn new(iter: Iter, len: Option<usize>) -> MapIteratorVisitor<Iter> {
+        MapIteratorVisitor {
+            iter: iter,
+            len: len,
+        }
+    }
+}
+
+impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
+    where K: Serialize,
+          V: Serialize,
+          I: Iterator<Item=(K, V)>,
+{
+    #[inline]
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: Serializer,
+    {
+        match self.iter.next() {
+            Some((key, value)) => {
+                let value = try!(serializer.visit_map_elt(key, value));
+                Ok(Some(value))
+            }
+            None => Ok(None)
+        }
+    }
+
+    #[inline]
+    fn len(&self) -> Option<usize> {
+        self.len
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<K, V> Serialize for BTreeMap<K, V>
+    where K: Serialize + Ord,
+          V: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+impl<K, V> Serialize for HashMap<K, V>
+    where K: Serialize + Eq + Hash,
+          V: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+#[cfg(feature = "nightly")]
+impl<V> Serialize for VecMap<V>
+    where V: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<'a, T: ?Sized> Serialize for &'a T where T: Serialize {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (**self).serialize(serializer)
+    }
+}
+
+impl<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (**self).serialize(serializer)
+    }
+}
+
+impl<T: ?Sized> Serialize for Box<T> where T: Serialize {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (**self).serialize(serializer)
+    }
+}
+
+impl<T> Serialize for Rc<T> where T: Serialize, {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (**self).serialize(serializer)
+    }
+}
+
+impl<T> Serialize for Arc<T> where T: Serialize, {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (**self).serialize(serializer)
+    }
+}
+
+impl<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned, {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        (**self).serialize(serializer)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<T, E> Serialize for Result<T, E> where T: Serialize, E: Serialize {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer {
+        match *self {
+            Result::Ok(ref value) => {
+                serializer.visit_newtype_variant("Result", 0, "Ok", value)
+            }
+            Result::Err(ref value) => {
+                serializer.visit_newtype_variant("Result", 1, "Err", value)
+            }
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl Serialize for path::Path {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_str().unwrap().serialize(serializer)
+    }
+}
+
+impl Serialize for path::PathBuf {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_str().unwrap().serialize(serializer)
+    }
+}
+
+#[cfg(feature = "nightly")]
+impl<T> Serialize for NonZero<T> where T: Serialize + Zeroable {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer {
+        (**self).serialize(serializer)
+    }
+}

serde/src/ser/mod.rs

@@ -0,0 +1,291 @@
+//! Generic serialization framework.
+
+pub mod impls;
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait Serialize {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+pub trait Serializer {
+    type Error;
+
+    /// `visit_bool` serializes a `bool` value.
+    fn visit_bool(&mut self, v: bool) -> Result<(), Self::Error>;
+
+    /// `visit_isize` serializes a `isize` value. By default it casts the value to a `i64` and
+    /// passes it to the `visit_i64` method.
+    #[inline]
+    fn visit_isize(&mut self, v: isize) -> Result<(), Self::Error> {
+        self.visit_i64(v as i64)
+    }
+
+    /// `visit_i8` serializes a `i8` value. By default it casts the value to a `i64` and
+    /// passes it to the `visit_i64` method.
+    #[inline]
+    fn visit_i8(&mut self, v: i8) -> Result<(), Self::Error> {
+        self.visit_i64(v as i64)
+    }
+
+    /// `visit_i16` serializes a `i16` value. By default it casts the value to a `i64` and
+    /// passes it to the `visit_i64` method.
+    #[inline]
+    fn visit_i16(&mut self, v: i16) -> Result<(), Self::Error> {
+        self.visit_i64(v as i64)
+    }
+
+    /// `visit_i32` serializes a `i32` value. By default it casts the value to a `i64` and
+    /// passes it to the `visit_i64` method.
+    #[inline]
+    fn visit_i32(&mut self, v: i32) -> Result<(), Self::Error> {
+        self.visit_i64(v as i64)
+    }
+
+    /// `visit_i64` serializes a `i64` value.
+    #[inline]
+    fn visit_i64(&mut self, v: i64) -> Result<(), Self::Error>;
+
+    /// `visit_usize` serializes a `usize` value. By default it casts the value to a `u64` and
+    /// passes it to the `visit_u64` method.
+    #[inline]
+    fn visit_usize(&mut self, v: usize) -> Result<(), Self::Error> {
+        self.visit_u64(v as u64)
+    }
+
+    /// `visit_u8` serializes a `u8` value. By default it casts the value to a `u64` and passes
+    /// it to the `visit_u64` method.
+    #[inline]
+    fn visit_u8(&mut self, v: u8) -> Result<(), Self::Error> {
+        self.visit_u64(v as u64)
+    }
+
+    /// `visit_u32` serializes a `u32` value. By default it casts the value to a `u64` and passes
+    /// it to the `visit_u64` method.
+    #[inline]
+    fn visit_u16(&mut self, v: u16) -> Result<(), Self::Error> {
+        self.visit_u64(v as u64)
+    }
+
+    /// `visit_u32` serializes a `u32` value. By default it casts the value to a `u64` and passes
+    /// it to the `visit_u64` method.
+    #[inline]
+    fn visit_u32(&mut self, v: u32) -> Result<(), Self::Error> {
+        self.visit_u64(v as u64)
+    }
+
+    /// `visit_u64` serializes a `u64` value.
+    #[inline]
+    fn visit_u64(&mut self, v: u64) -> Result<(), Self::Error>;
+
+    /// `visit_f32` serializes a `f32` value. By default it casts the value to a `f64` and passes
+    /// it to the `visit_f64` method.
+    #[inline]
+    fn visit_f32(&mut self, v: f32) -> Result<(), Self::Error> {
+        self.visit_f64(v as f64)
+    }
+
+    /// `visit_f64` serializes a `f64` value.
+    fn visit_f64(&mut self, v: f64) -> Result<(), Self::Error>;
+
+    /// `visit_char` serializes a character. By default it serializes it as a `&str` containing a
+    /// single character.
+    #[inline]
+    fn visit_char(&mut self, v: char) -> Result<(), Self::Error> {
+        // FIXME: this allocation is required in order to be compatible with stable rust, which
+        // doesn't support encoding a `char` into a stack buffer.
+        self.visit_str(&v.to_string())
+    }
+
+    /// `visit_str` serializes a `&str`.
+    fn visit_str(&mut self, value: &str) -> Result<(), Self::Error>;
+
+    /// `visit_bytes` is a hook that enables those serialization formats that support serializing
+    /// byte slices separately from generic arrays. By default it serializes as a regular array.
+    #[inline]
+    fn visit_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> {
+        self.visit_seq(impls::SeqIteratorVisitor::new(value.iter(), Some(value.len())))
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Self::Error>;
+
+    #[inline]
+    fn visit_unit_struct(&mut self, _name: &'static str) -> Result<(), Self::Error> {
+        self.visit_unit()
+    }
+
+    #[inline]
+    fn visit_unit_variant(&mut self,
+                          _name: &'static str,
+                          _variant_index: usize,
+                          _variant: &'static str) -> Result<(), Self::Error> {
+        self.visit_unit()
+    }
+
+    /// The `visit_newtype_struct` allows a tuple struct with a single element, also known as a
+    /// newtyped value, to be more efficiently serialized than a tuple struct with multiple items.
+    /// By default it just serializes the value as a tuple struct sequence.
+    #[inline]
+    fn visit_newtype_struct<T>(&mut self,
+                               name: &'static str,
+                               value: T) -> Result<(), Self::Error>
+        where T: Serialize,
+    {
+        self.visit_tuple_struct(name, Some(value))
+    }
+
+    /// The `visit_newtype_variant` allows a variant with a single item to be more efficiently
+    /// serialized than a variant with multiple items. By default it just serializes the value as a
+    /// tuple variant sequence.
+    #[inline]
+    fn visit_newtype_variant<T>(&mut self,
+                                name: &'static str,
+                                variant_index: usize,
+                                variant: &'static str,
+                                value: T) -> Result<(), Self::Error>
+        where T: Serialize,
+    {
+        self.visit_tuple_variant(
+            name,
+            variant_index,
+            variant,
+            Some(value))
+    }
+
+    fn visit_none(&mut self) -> Result<(), Self::Error>;
+
+    fn visit_some<V>(&mut self, value: V) -> Result<(), Self::Error>
+        where V: Serialize;
+
+    fn visit_seq<V>(&mut self, visitor: V) -> Result<(), Self::Error>
+        where V: SeqVisitor;
+
+    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+        where T: Serialize;
+
+    #[inline]
+    fn visit_tuple<V>(&mut self, visitor: V) -> Result<(), Self::Error>
+        where V: SeqVisitor,
+    {
+        self.visit_seq(visitor)
+    }
+
+    #[inline]
+    fn visit_tuple_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+        where T: Serialize
+    {
+        self.visit_seq_elt(value)
+    }
+
+    #[inline]
+    fn visit_tuple_struct<V>(&mut self,
+                             _name: &'static str,
+                             visitor: V) -> Result<(), Self::Error>
+        where V: SeqVisitor,
+    {
+        self.visit_tuple(visitor)
+    }
+
+    #[inline]
+    fn visit_tuple_struct_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+        where T: Serialize
+    {
+        self.visit_tuple_elt(value)
+    }
+
+    #[inline]
+    fn visit_tuple_variant<V>(&mut self,
+                              _name: &'static str,
+                              _variant_index: usize,
+                              variant: &'static str,
+                              visitor: V) -> Result<(), Self::Error>
+        where V: SeqVisitor,
+    {
+        self.visit_tuple_struct(variant, visitor)
+    }
+
+    #[inline]
+    fn visit_tuple_variant_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+        where T: Serialize
+    {
+        self.visit_tuple_struct_elt(value)
+    }
+
+    fn visit_map<V>(&mut self, visitor: V) -> Result<(), Self::Error>
+        where V: MapVisitor;
+
+    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error>
+        where K: Serialize,
+              V: Serialize;
+
+    #[inline]
+    fn visit_struct<V>(&mut self,
+                       _name: &'static str,
+                       visitor: V) -> Result<(), Self::Error>
+        where V: MapVisitor,
+    {
+        self.visit_map(visitor)
+    }
+
+    #[inline]
+    fn visit_struct_elt<V>(&mut self,
+                           key: &'static str,
+                           value: V) -> Result<(), Self::Error>
+        where V: Serialize,
+    {
+        self.visit_map_elt(key, value)
+    }
+
+    #[inline]
+    fn visit_struct_variant<V>(&mut self,
+                               _name: &'static str,
+                               _variant_index: usize,
+                               variant: &'static str,
+                               visitor: V) -> Result<(), Self::Error>
+        where V: MapVisitor,
+    {
+        self.visit_struct(variant, visitor)
+    }
+
+    #[inline]
+    fn visit_struct_variant_elt<V>(&mut self,
+                                   key: &'static str,
+                                   value: V) -> Result<(), Self::Error>
+        where V: Serialize,
+    {
+        self.visit_struct_elt(key, value)
+    }
+
+    /// Specify a format string for the serializer.
+    ///
+    /// The serializer format is used to determine which format
+    /// specific field attributes should be used with the serializer.
+    fn format() -> &'static str {
+        ""
+    }
+}
+
+pub trait SeqVisitor {
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: Serializer;
+
+    /// Return the length of the sequence if known.
+    #[inline]
+    fn len(&self) -> Option<usize> {
+        None
+    }
+}
+
+pub trait MapVisitor {
+    fn visit<S>(&mut self, serializer: &mut S) -> Result<Option<()>, S::Error>
+        where S: Serializer;
+
+    /// Return the length of the map if known.
+    #[inline]
+    fn len(&self) -> Option<usize> {
+        None
+    }
+}

serde_codegen/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "serde_codegen"
+version = "0.5.0"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+license = "MIT/Apache-2.0"
+description = "Macros to auto-generate implementations for the serde framework"
+repository = "https://github.com/serde-rs/serde"
+build = "build.rs"
+
+[features]
+default = ["with-syntex"]
+nightly = ["quasi_macros"]
+with-syntex = ["quasi/with-syntex", "quasi_codegen", "quasi_codegen/with-syntex", "syntex", "syntex_syntax"]
+
+[build-dependencies]
+quasi_codegen = { verision = "*", optional = true }
+syntex = { version = "*", optional = true }
+
+[dependencies]
+aster = { version = "*", default-features = false }
+quasi = { verision = "*", default-features = false }
+quasi_macros = { version = "*", optional = true }
+syntex = { version = "*", optional = true }
+syntex_syntax = { version = "*", optional = true }

serde_codegen/build.rs

@@ -0,0 +1,28 @@
+#[cfg(feature = "with-syntex")]
+mod inner {
+    extern crate syntex;
+    extern crate quasi_codegen;
+
+    use std::env;
+    use std::path::Path;
+
+    pub fn main() {
+        let out_dir = env::var_os("OUT_DIR").unwrap();
+        let mut registry = syntex::Registry::new();
+        quasi_codegen::register(&mut registry);
+
+        let src = Path::new("src/lib.rs.in");
+        let dst = Path::new(&out_dir).join("lib.rs");
+
+        registry.expand("", &src, &dst).unwrap();
+    }
+}
+
+#[cfg(not(feature = "with-syntex"))]
+mod inner {
+    pub fn main() {}
+}
+
+fn main() {
+    inner::main();
+}

serde_codegen/src/attr.rs

@@ -0,0 +1,120 @@
+use std::collections::HashMap;
+use std::collections::HashSet;
+
+use syntax::ast;
+use syntax::ext::base::ExtCtxt;
+use syntax::ptr::P;
+
+/// Represents field name information
+pub enum FieldNames {
+    Global(P<ast::Expr>),
+    Format{
+        formats: HashMap<P<ast::Expr>, P<ast::Expr>>,
+        default: P<ast::Expr>,
+    }
+}
+
+/// Represents field attribute information
+pub struct FieldAttrs {
+    skip_serializing_field: bool,
+    names: FieldNames,
+    use_default: bool,
+}
+
+impl FieldAttrs {
+    /// Create a FieldAttr with a single default field name
+    pub fn new(
+        skip_serializing_field: bool,
+        default_value: bool,
+        name: P<ast::Expr>,
+    ) -> FieldAttrs {
+        FieldAttrs {
+            skip_serializing_field: skip_serializing_field,
+            names: FieldNames::Global(name),
+            use_default: default_value,
+        }
+    }
+
+    /// Create a FieldAttr with format specific field names
+    pub fn new_with_formats(
+        skip_serializing_field: bool,
+        default_value: bool,
+        default_name: P<ast::Expr>,
+        formats: HashMap<P<ast::Expr>, P<ast::Expr>>,
+    ) -> FieldAttrs {
+        FieldAttrs {
+            skip_serializing_field: skip_serializing_field,
+            names: FieldNames::Format {
+                formats: formats,
+                default: default_name,
+            },
+            use_default: default_value,
+        }
+    }
+
+    /// Return a set of formats that the field has attributes for.
+    pub fn formats(&self) -> HashSet<P<ast::Expr>> {
+        match self.names {
+            FieldNames::Format{ref formats, default: _} => {
+                let mut set = HashSet::new();
+                for (fmt, _) in formats.iter() {
+                    set.insert(fmt.clone());
+                };
+                set
+            },
+            _ => HashSet::new()
+        }
+    }
+
+    /// Return an expression for the field key name for serialisation.
+    ///
+    /// The resulting expression assumes that `S` refers to a type
+    /// that implements `Serializer`.
+    pub fn serializer_key_expr(self, cx: &ExtCtxt) -> P<ast::Expr> {
+        match self.names {
+            FieldNames::Global(x) => x,
+            FieldNames::Format{formats, default} => {
+                let arms = formats.iter()
+                    .map(|(fmt, lit)| {
+                        quote_arm!(cx, $fmt => { $lit })
+                    })
+                    .collect::<Vec<_>>();
+                quote_expr!(cx,
+                            {
+                                match S::format() {
+                                    $arms
+                                    _ => { $default }
+                                }
+                            })
+            },
+        }
+    }
+
+    /// Return the default field name for the field.
+    pub fn default_key_expr(&self) -> &P<ast::Expr> {
+        match self.names {
+            FieldNames::Global(ref expr) => expr,
+            FieldNames::Format{formats: _, ref default} => default
+        }
+    }
+
+    /// Return the field name for the field in the specified format.
+    pub fn key_expr(&self, format: &P<ast::Expr>) -> &P<ast::Expr> {
+        match self.names {
+            FieldNames::Global(ref expr) =>
+                expr,
+            FieldNames::Format{ref formats, ref default} =>
+                formats.get(format).unwrap_or(default)
+        }
+    }
+
+    /// Predicate for using a field's default value
+    pub fn use_default(&self) -> bool {
+        self.use_default
+    }
+
+    /// Predicate for ignoring a field when serializing a value
+    pub fn skip_serializing_field(&self) -> bool {
+        self.skip_serializing_field
+    }
+}

serde_codegen/src/field.rs

@@ -0,0 +1,147 @@
+use std::collections::HashMap;
+
+use aster;
+
+use syntax::ast;
+use syntax::attr;
+use syntax::ext::base::ExtCtxt;
+use syntax::ptr::P;
+
+use attr::FieldAttrs;
+
+enum Rename<'a> {
+    None,
+    Global(&'a ast::Lit),
+    Format(HashMap<P<ast::Expr>, &'a ast::Lit>)
+}
+
+fn rename<'a>(
+    builder: &aster::AstBuilder,
+    mi: &'a ast::MetaItem,
+    ) -> Option<Rename<'a>>
+{
+    match mi.node {
+        ast::MetaNameValue(ref n, ref lit) => {
+            if n == &"rename" {
+                Some(Rename::Global(lit))
+            } else {
+                None
+            }
+        },
+        ast::MetaList(ref n, ref items) => {
+            if n == &"rename" {
+                let mut m = HashMap::new();
+                m.extend(
+                    items.iter()
+                        .filter_map(
+                            |item|
+                            match item.node {
+                                ast::MetaNameValue(ref n, ref lit) =>
+                                    Some((builder.expr().str(n),
+                                          lit)),
+                                _ => None
+                            }));
+                Some(Rename::Format(m))
+            } else {
+                None
+            }
+        },
+        _ => None
+    }
+}
+
+fn default_value(mi: &ast::MetaItem) -> bool {
+    if let ast::MetaItem_::MetaWord(ref n) = mi.node {
+        n == &"default"
+    } else {
+        false
+    }
+}
+
+fn skip_serializing_field(mi: &ast::MetaItem) -> bool {
+    if let ast::MetaItem_::MetaWord(ref n) = mi.node {
+        n == &"skip_serializing"
+    } else {
+        false
+    }
+}
+
+fn field_attrs<'a>(
+    builder: &aster::AstBuilder,
+    field: &'a ast::StructField,
+) -> (Rename<'a>, bool, bool) {
+    field.node.attrs.iter()
+        .find(|sa| {
+            if let ast::MetaList(ref n, _) = sa.node.value.node {
+                n == &"serde"
+            } else {
+                false
+            }
+        })
+        .and_then(|sa| {
+            if let ast::MetaList(_, ref vals) = sa.node.value.node {
+                attr::mark_used(&sa);
+                Some((
+                    vals.iter()
+                        .fold(None, |v, mi| v.or(rename(builder, mi)))
+                        .unwrap_or(Rename::None),
+                    vals.iter().any(|mi| default_value(mi)),
+                    vals.iter().any(|mi| skip_serializing_field(mi)),
+                ))
+            } else {
+                Some((Rename::None, false, false))
+            }
+        })
+        .unwrap_or((Rename::None, false, false))
+}
+
+pub fn struct_field_attrs(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    struct_def: &ast::StructDef,
+) -> Vec<FieldAttrs> {
+    struct_def.fields.iter()
+        .map(|field| {
+            match field_attrs(builder, field) {
+                (Rename::Global(rename), default_value, skip_serializing_field) =>
+                    FieldAttrs::new(
+                        skip_serializing_field,
+                        default_value,
+                        builder.expr().build_lit(P(rename.clone()))),
+                (Rename::Format(renames), default_value, skip_serializing_field) => {
+                    let mut res = HashMap::new();
+                    res.extend(
+                        renames.into_iter()
+                            .map(|(k,v)|
+                                 (k, builder.expr().build_lit(P(v.clone())))));
+                    FieldAttrs::new_with_formats(
+                        skip_serializing_field,
+                        default_value,
+                        default_field_name(cx, builder, field.node.kind),
+                        res)
+                },
+                (Rename::None, default_value, skip_serializing_field) => {
+                    FieldAttrs::new(
+                        skip_serializing_field,
+                        default_value,
+                        default_field_name(cx, builder, field.node.kind))
+                }
+            }
+        })
+        .collect()
+}
+
+fn default_field_name(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    kind: ast::StructFieldKind,
+) -> P<ast::Expr> {
+    match kind {
+        ast::NamedField(name, _) => {
+            builder.expr().str(name)
+        }
+        ast::UnnamedField(_) => {
+            cx.bug("struct has named and unnamed fields")
+        }
+    }
+}

serde_codegen/src/lib.rs

@@ -0,0 +1,73 @@
+#![cfg_attr(not(feature = "with-syntex"), feature(rustc_private, plugin))]
+#![cfg_attr(not(feature = "with-syntex"), plugin(quasi_macros))]
+
+extern crate aster;
+extern crate quasi;
+
+#[cfg(feature = "with-syntex")]
+extern crate syntex;
+
+#[cfg(feature = "with-syntex")]
+extern crate syntex_syntax as syntax;
+
+#[cfg(not(feature = "with-syntex"))]
+extern crate syntax;
+
+#[cfg(not(feature = "with-syntex"))]
+extern crate rustc;
+
+#[cfg(feature = "with-syntex")]
+include!(concat!(env!("OUT_DIR"), "/lib.rs"));
+
+#[cfg(not(feature = "with-syntex"))]
+include!("lib.rs.in");
+
+#[cfg(feature = "with-syntex")]
+pub fn register(reg: &mut syntex::Registry) {
+    use syntax::{ast, fold};
+
+    reg.add_attr("feature(custom_derive)");
+    reg.add_attr("feature(custom_attribute)");
+
+    reg.add_decorator("derive_Serialize", ser::expand_derive_serialize);
+    reg.add_decorator("derive_Deserialize", de::expand_derive_deserialize);
+
+    reg.add_post_expansion_pass(strip_attributes);
+
+    /// Strip the serde attributes from the crate.
+    #[cfg(feature = "with-syntex")]
+    fn strip_attributes(krate: ast::Crate) -> ast::Crate {
+        /// Helper folder that strips the serde attributes after the extensions have been expanded.
+        struct StripAttributeFolder;
+
+        impl fold::Folder for StripAttributeFolder {
+            fn fold_attribute(&mut self, attr: ast::Attribute) -> Option<ast::Attribute> {
+                match attr.node.value.node {
+                    ast::MetaList(ref n, _) if n == &"serde" => { return None; }
+                    _ => {}
+                }
+
+                Some(attr)
+            }
+
+            fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
+                fold::noop_fold_mac(mac, self)
+            }
+        }
+
+        fold::Folder::fold_crate(&mut StripAttributeFolder, krate)
+    }
+}
+
+#[cfg(not(feature = "with-syntex"))]
+pub fn register(reg: &mut rustc::plugin::Registry) {
+    reg.register_syntax_extension(
+        syntax::parse::token::intern("derive_Serialize"),
+        syntax::ext::base::MultiDecorator(
+            Box::new(ser::expand_derive_serialize)));
+
+    reg.register_syntax_extension(
+        syntax::parse::token::intern("derive_Deserialize"),
+        syntax::ext::base::MultiDecorator(
+            Box::new(de::expand_derive_deserialize)));
+}

serde_codegen/src/lib.rs.in

@@ -0,0 +1,4 @@
+mod attr;
+mod de;
+mod field;
+mod ser;

serde_codegen/src/ser.rs

@@ -0,0 +1,653 @@
+use aster;
+
+use syntax::ast::{
+    Ident,
+    MetaItem,
+    Item,
+    Expr,
+    StructDef,
+};
+use syntax::ast;
+use syntax::codemap::Span;
+use syntax::ext::base::{Annotatable, ExtCtxt};
+use syntax::ext::build::AstBuilder;
+use syntax::ptr::P;
+
+use field::struct_field_attrs;
+
+pub fn expand_derive_serialize(
+    cx: &mut ExtCtxt,
+    span: Span,
+    meta_item: &MetaItem,
+    annotatable: &Annotatable,
+    push: &mut FnMut(Annotatable)
+) {
+    let item = match *annotatable {
+        Annotatable::Item(ref item) => item,
+        _ => {
+            cx.span_err(
+                meta_item.span,
+                "`derive` may only be applied to structs and enums");
+            return;
+        }
+    };
+
+    let builder = aster::AstBuilder::new().span(span);
+
+    let generics = match item.node {
+        ast::ItemStruct(_, ref generics) => generics,
+        ast::ItemEnum(_, ref generics) => generics,
+        _ => cx.bug("expected ItemStruct or ItemEnum in #[derive(Serialize)]")
+    };
+
+    let impl_generics = builder.from_generics(generics.clone())
+        .add_ty_param_bound(
+            builder.path().global().ids(&["serde", "ser", "Serialize"]).build()
+        )
+        .build();
+
+    let ty = builder.ty().path()
+        .segment(item.ident).with_generics(impl_generics.clone()).build()
+        .build();
+
+    let body = serialize_body(
+        cx,
+        &builder,
+        &item,
+        &impl_generics,
+        ty.clone(),
+    );
+
+    let where_clause = &impl_generics.where_clause;
+
+    let impl_item = quote_item!(cx,
+        #[automatically_derived]
+        impl $impl_generics ::serde::ser::Serialize for $ty $where_clause {
+            fn serialize<__S>(&self, serializer: &mut __S) -> ::std::result::Result<(), __S::Error>
+                where __S: ::serde::ser::Serializer,
+            {
+                $body
+            }
+        }
+    ).unwrap();
+
+    push(Annotatable::Item(impl_item))
+}
+
+fn serialize_body(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    item: &Item,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+) -> P<ast::Expr> {
+    match item.node {
+        ast::ItemStruct(ref struct_def, _) => {
+            serialize_item_struct(
+                cx,
+                builder,
+                item,
+                impl_generics,
+                ty,
+                struct_def,
+            )
+        }
+        ast::ItemEnum(ref enum_def, _) => {
+            serialize_item_enum(
+                cx,
+                builder,
+                item.ident,
+                impl_generics,
+                ty,
+                enum_def,
+            )
+        }
+        _ => cx.bug("expected ItemStruct or ItemEnum in #[derive(Serialize)]")
+    }
+}
+
+fn serialize_item_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    item: &Item,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    struct_def: &ast::StructDef,
+) -> P<ast::Expr> {
+    let mut named_fields = vec![];
+    let mut unnamed_fields = 0;
+
+    for field in struct_def.fields.iter() {
+        match field.node.kind {
+            ast::NamedField(name, _) => { named_fields.push(name); }
+            ast::UnnamedField(_) => { unnamed_fields += 1; }
+        }
+    }
+
+    match (named_fields.is_empty(), unnamed_fields) {
+        (true, 0) => {
+            serialize_unit_struct(
+                cx,
+                &builder,
+                item.ident,
+            )
+        }
+        (true, 1) => {
+            serialize_newtype_struct(
+                cx,
+                &builder,
+                item.ident,
+            )
+        }
+        (true, _) => {
+            serialize_tuple_struct(
+                cx,
+                &builder,
+                item.ident,
+                impl_generics,
+                ty,
+                unnamed_fields,
+            )
+        }
+        (false, 0) => {
+            serialize_struct(
+                cx,
+                &builder,
+                item.ident,
+                impl_generics,
+                ty,
+                struct_def,
+                named_fields,
+            )
+        }
+        (false, _) => {
+            cx.bug("struct has named and unnamed fields")
+        }
+    }
+}
+
+fn serialize_unit_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident
+) -> P<ast::Expr> {
+    let type_name = builder.expr().str(type_ident);
+
+    quote_expr!(cx, serializer.visit_unit_struct($type_name))
+}
+
+fn serialize_newtype_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident
+) -> P<ast::Expr> {
+    let type_name = builder.expr().str(type_ident);
+
+    quote_expr!(cx, serializer.visit_newtype_struct($type_name, &self.0))
+}
+
+fn serialize_tuple_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    fields: usize,
+) -> P<ast::Expr> {
+    let (visitor_struct, visitor_impl) = serialize_tuple_struct_visitor(
+        cx,
+        builder,
+        ty.clone(),
+        builder.ty()
+            .ref_()
+            .lifetime("'__a")
+            .build_ty(ty.clone()),
+        fields,
+        impl_generics,
+    );
+
+    let type_name = builder.expr().str(type_ident);
+
+    quote_expr!(cx, {
+        $visitor_struct
+        $visitor_impl
+        serializer.visit_tuple_struct($type_name, Visitor {
+            value: self,
+            state: 0,
+            _structure_ty: ::std::marker::PhantomData::<&$ty>,
+        })
+    })
+}
+
+fn serialize_struct(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    struct_def: &StructDef,
+    fields: Vec<Ident>,
+) -> P<ast::Expr> {
+    let (visitor_struct, visitor_impl) = serialize_struct_visitor(
+        cx,
+        builder,
+        ty.clone(),
+        builder.ty()
+            .ref_()
+            .lifetime("'__a")
+            .build_ty(ty.clone()),
+        struct_def,
+        impl_generics,
+        fields.iter().map(|field| quote_expr!(cx, &self.value.$field)),
+    );
+
+    let type_name = builder.expr().str(type_ident);
+
+    quote_expr!(cx, {
+        $visitor_struct
+        $visitor_impl
+        serializer.visit_struct($type_name, Visitor {
+            value: self,
+            state: 0,
+            _structure_ty: ::std::marker::PhantomData::<&$ty>,
+        })
+    })
+}
+
+fn serialize_item_enum(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+    impl_generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    enum_def: &ast::EnumDef,
+) -> P<ast::Expr> {
+    let arms: Vec<ast::Arm> = enum_def.variants.iter()
+        .enumerate()
+        .map(|(variant_index, variant)| {
+            serialize_variant(
+                cx,
+                builder,
+                type_ident,
+                impl_generics,
+                ty.clone(),
+                variant,
+                variant_index,
+            )
+        })
+        .collect();
+
+    quote_expr!(cx,
+        match *self {
+            $arms
+        }
+    )
+}
+
+fn serialize_variant(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_ident: Ident,
+    generics: &ast::Generics,
+    ty: P<ast::Ty>,
+    variant: &ast::Variant,
+    variant_index: usize,
+) -> ast::Arm {
+    let type_name = builder.expr().str(type_ident);
+    let variant_ident = variant.node.name;
+    let variant_name = builder.expr().str(variant_ident);
+
+    match variant.node.kind {
+        ast::TupleVariantKind(ref args) if args.is_empty() => {
+            let pat = builder.pat().enum_()
+                .id(type_ident).id(variant_ident).build()
+                .build();
+
+            quote_arm!(cx,
+                $pat => {
+                    ::serde::ser::Serializer::visit_unit_variant(
+                        serializer,
+                        $type_name,
+                        $variant_index,
+                        $variant_name,
+                    )
+                }
+            )
+        },
+        ast::TupleVariantKind(ref args) if args.len() == 1 => {
+            let field = builder.id("__simple_value");
+            let field = builder.pat().ref_id(field);
+            let pat = builder.pat().enum_()
+                .id(type_ident).id(variant_ident).build()
+                .with_pats(Some(field).into_iter())
+                .build();
+            quote_arm!(cx,
+                $pat => {
+                    ::serde::ser::Serializer::visit_newtype_variant(
+                        serializer,
+                        $type_name,
+                        $variant_index,
+                        $variant_name,
+                        __simple_value,
+                    )
+                }
+            )
+        },
+        ast::TupleVariantKind(ref args) => {
+            let fields: Vec<ast::Ident> = (0 .. args.len())
+                .map(|i| builder.id(format!("__field{}", i)))
+                .collect();
+
+            let pat = builder.pat().enum_()
+                .id(type_ident).id(variant_ident).build()
+                .with_pats(fields.iter().map(|field| builder.pat().ref_id(field)))
+                .build();
+
+            let expr = serialize_tuple_variant(
+                cx,
+                builder,
+                type_name,
+                variant_index,
+                variant_name,
+                generics,
+                ty,
+                args,
+                fields,
+            );
+
+            quote_arm!(cx, $pat => { $expr })
+        }
+        ast::StructVariantKind(ref struct_def) => {
+            let fields: Vec<_> = (0 .. struct_def.fields.len())
+                .map(|i| builder.id(format!("__field{}", i)))
+                .collect();
+
+            let pat = builder.pat().struct_()
+                .id(type_ident).id(variant_ident).build()
+                .with_pats(
+                    fields.iter()
+                        .zip(struct_def.fields.iter())
+                        .map(|(id, field)| {
+                            let name = match field.node.kind {
+                                ast::NamedField(name, _) => name,
+                                ast::UnnamedField(_) => {
+                                    cx.bug("struct variant has unnamed fields")
+                                }
+                            };
+
+                            (name, builder.pat().ref_id(id))
+                        })
+                )
+                .build();
+
+            let expr = serialize_struct_variant(
+                cx,
+                builder,
+                type_name,
+                variant_index,
+                variant_name,
+                generics,
+                ty,
+                struct_def,
+                fields,
+            );
+
+            quote_arm!(cx, $pat => { $expr })
+        }
+    }
+}
+
+fn serialize_tuple_variant(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_name: P<ast::Expr>,
+    variant_index: usize,
+    variant_name: P<ast::Expr>,
+    generics: &ast::Generics,
+    structure_ty: P<ast::Ty>,
+    args: &[ast::VariantArg],
+    fields: Vec<Ident>,
+) -> P<ast::Expr> {
+    let variant_ty = builder.ty().tuple()
+        .with_tys(
+            args.iter().map(|arg| {
+                builder.ty()
+                    .ref_()
+                    .lifetime("'__a")
+                    .build_ty(arg.ty.clone())
+            })
+        )
+        .build();
+
+    let (visitor_struct, visitor_impl) = serialize_tuple_struct_visitor(
+        cx,
+        builder,
+        structure_ty.clone(),
+        variant_ty,
+        args.len(),
+        generics,
+    );
+
+    let value_expr = builder.expr().tuple()
+        .with_exprs(
+            fields.iter().map(|field| {
+                builder.expr().id(field)
+            })
+        )
+        .build();
+
+    quote_expr!(cx, {
+        $visitor_struct
+        $visitor_impl
+        serializer.visit_tuple_variant($type_name, $variant_index, $variant_name, Visitor {
+            value: $value_expr,
+            state: 0,
+            _structure_ty: ::std::marker::PhantomData::<&$structure_ty>,
+        })
+    })
+}
+
+fn serialize_struct_variant(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_name: P<ast::Expr>,
+    variant_index: usize,
+    variant_name: P<ast::Expr>,
+    generics: &ast::Generics,
+    structure_ty: P<ast::Ty>,
+    struct_def: &ast::StructDef,
+    fields: Vec<Ident>,
+) -> P<ast::Expr> {
+    let value_ty = builder.ty().tuple()
+        .with_tys(
+            struct_def.fields.iter().map(|field| {
+                builder.ty()
+                    .ref_()
+                    .lifetime("'__a")
+                    .build_ty(field.node.ty.clone())
+            })
+        )
+        .build();
+
+    let value_expr = builder.expr().tuple()
+        .with_exprs(
+            fields.iter().map(|field| {
+                builder.expr().id(field)
+            })
+        )
+        .build();
+
+    let (visitor_struct, visitor_impl) = serialize_struct_visitor(
+        cx,
+        builder,
+        structure_ty.clone(),
+        value_ty,
+        struct_def,
+        generics,
+        (0 .. fields.len()).map(|i| {
+            builder.expr()
+                .tup_field(i)
+                .field("value").self_()
+        })
+    );
+
+    quote_expr!(cx, {
+        $visitor_struct
+        $visitor_impl
+        serializer.visit_struct_variant($type_name, $variant_index, $variant_name, Visitor {
+            value: $value_expr,
+            state: 0,
+            _structure_ty: ::std::marker::PhantomData::<&$structure_ty>,
+        })
+    })
+}
+
+fn serialize_tuple_struct_visitor(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    structure_ty: P<ast::Ty>,
+    variant_ty: P<ast::Ty>,
+    fields: usize,
+    generics: &ast::Generics
+) -> (P<ast::Item>, P<ast::Item>) {
+    let arms: Vec<ast::Arm> = (0 .. fields)
+        .map(|i| {
+            let expr = builder.expr()
+                .tup_field(i)
+                .field("value").self_();
+
+            quote_arm!(cx,
+                $i => {
+                    self.state += 1;
+                    let v = try!(serializer.visit_tuple_struct_elt(&$expr));
+                    Ok(Some(v))
+                }
+            )
+        })
+        .collect();
+
+    let visitor_impl_generics = builder.from_generics(generics.clone())
+        .add_lifetime_bound("'__a")
+        .lifetime_name("'__a")
+        .build();
+
+    let where_clause = &visitor_impl_generics.where_clause;
+
+    let visitor_generics = builder.from_generics(visitor_impl_generics.clone())
+        .strip_bounds()
+        .build();
+
+    (
+        quote_item!(cx,
+            struct Visitor $visitor_impl_generics $where_clause {
+                state: usize,
+                value: $variant_ty,
+                _structure_ty: ::std::marker::PhantomData<&'__a $structure_ty>,
+            }
+        ).unwrap(),
+
+        quote_item!(cx,
+            impl $visitor_impl_generics ::serde::ser::SeqVisitor
+            for Visitor $visitor_generics
+            $where_clause {
+                #[inline]
+                fn visit<S>(&mut self, serializer: &mut S) -> ::std::result::Result<Option<()>, S::Error>
+                    where S: ::serde::ser::Serializer
+                {
+                    match self.state {
+                        $arms
+                        _ => Ok(None)
+                    }
+                }
+
+                #[inline]
+                fn len(&self) -> Option<usize> {
+                    Some($fields)
+                }
+            }
+        ).unwrap(),
+    )
+}
+
+fn serialize_struct_visitor<I>(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    structure_ty: P<ast::Ty>,
+    variant_ty: P<ast::Ty>,
+    struct_def: &StructDef,
+    generics: &ast::Generics,
+    value_exprs: I,
+) -> (P<ast::Item>, P<ast::Item>)
+    where I: Iterator<Item=P<ast::Expr>>,
+{
+    let len = struct_def.fields.len();
+
+    let field_attrs = struct_field_attrs(cx, builder, struct_def);
+
+    let arms: Vec<ast::Arm> = field_attrs.into_iter()
+        .zip(value_exprs)
+        .filter(|&(ref field, _)| !field.skip_serializing_field())
+        .enumerate()
+        .map(|(i, (field, value_expr))| {
+            let key_expr = field.serializer_key_expr(cx);
+            quote_arm!(cx,
+                $i => {
+                    self.state += 1;
+                    Ok(
+                        Some(
+                            try!(
+                                serializer.visit_struct_elt(
+                                    $key_expr,
+                                    $value_expr,
+                                )
+                            )
+                        )
+                    )
+                }
+            )
+        })
+        .collect();
+
+    let visitor_impl_generics = builder.from_generics(generics.clone())
+        .add_lifetime_bound("'__a")
+        .lifetime_name("'__a")
+        .build();
+
+    let where_clause = &visitor_impl_generics.where_clause;
+
+    let visitor_generics = builder.from_generics(visitor_impl_generics.clone())
+        .strip_bounds()
+        .build();
+
+    (
+        quote_item!(cx,
+            struct Visitor $visitor_impl_generics $where_clause {
+                state: usize,
+                value: $variant_ty,
+                _structure_ty: ::std::marker::PhantomData<&'__a $structure_ty>,
+            }
+        ).unwrap(),
+
+        quote_item!(cx,
+            impl $visitor_impl_generics
+            ::serde::ser::MapVisitor
+            for Visitor $visitor_generics
+            $where_clause {
+                #[inline]
+                fn visit<S>(&mut self, serializer: &mut S) -> ::std::result::Result<Option<()>, S::Error>
+                    where S: ::serde::ser::Serializer,
+                {
+                    match self.state {
+                        $arms
+                        _ => Ok(None)
+                    }
+                }
+
+                #[inline]
+                fn len(&self) -> Option<usize> {
+                    Some($len)
+                }
+            }
+        ).unwrap(),
+    )
+}

serde_json/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "serde_json"
+version = "0.5.0"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+license = "MIT/Apache-2.0"
+description = "A JSON serialization file format"
+repository = "https://github.com/serde-rs/serde"
+documentation = "http://serde-rs.github.io/serde/serde"
+readme = "../README.md"
+keywords = ["serialization", "json"]
+
+[dependencies]
+num = "*"
+serde = { version = "*", path = "../serde" }

serde_json/src/builder.rs

@@ -10,8 +10,9 @@
 
 use std::collections::BTreeMap;
 
-use ser::{self, Serialize};
-use json::value::{self, Value};
+use serde::ser::{self, Serialize};
+
+use value::{self, Value};
 
 pub struct ArrayBuilder {
     array: Vec<Value>,

serde_json/src/de.rs

@@ -0,0 +1,814 @@
+use std::char;
+use std::i32;
+use std::io;
+use std::str;
+
+use serde::de;
+use serde::iter::LineColIterator;
+
+use super::error::{Error, ErrorCode, Result};
+
+pub struct Deserializer<Iter: Iterator<Item=io::Result<u8>>> {
+    rdr: LineColIterator<Iter>,
+    ch: Option<u8>,
+    str_buf: Vec<u8>,
+}
+
+macro_rules! try_or_invalid {
+    ($self_:expr, $e:expr) => {
+        match $e {
+            Some(v) => v,
+            None => { return Err($self_.error(ErrorCode::InvalidNumber)); }
+        }
+    }
+}
+
+impl<Iter> Deserializer<Iter>
+    where Iter: Iterator<Item=io::Result<u8>>,
+{
+    /// Creates the JSON parser from an `std::iter::Iterator`.
+    #[inline]
+    pub fn new(rdr: Iter) -> Deserializer<Iter> {
+        Deserializer {
+            rdr: LineColIterator::new(rdr),
+            ch: None,
+            str_buf: Vec::with_capacity(128),
+        }
+    }
+
+    #[inline]
+    pub fn end(&mut self) -> Result<()> {
+        try!(self.parse_whitespace());
+        if try!(self.eof()) {
+            Ok(())
+        } else {
+            Err(self.error(ErrorCode::TrailingCharacters))
+        }
+    }
+
+    fn eof(&mut self) -> Result<bool> {
+        Ok(try!(self.peek()).is_none())
+    }
+
+    fn peek(&mut self) -> Result<Option<u8>> {
+        match self.ch {
+            Some(ch) => Ok(Some(ch)),
+            None => {
+                self.ch = try!(self.next_char());
+                Ok(self.ch)
+            }
+        }
+    }
+
+    fn peek_or_null(&mut self) -> Result<u8> {
+        Ok(try!(self.peek()).unwrap_or(b'\x00'))
+    }
+
+    fn eat_char(&mut self) {
+        self.ch = None;
+    }
+
+    fn next_char(&mut self) -> Result<Option<u8>> {
+        match self.ch.take() {
+            Some(ch) => Ok(Some(ch)),
+            None => {
+                match self.rdr.next() {
+                    Some(Err(err)) => Err(Error::IoError(err)),
+                    Some(Ok(ch)) => Ok(Some(ch)),
+                    None => Ok(None),
+                }
+            }
+        }
+    }
+
+    fn next_char_or_null(&mut self) -> Result<u8> {
+        Ok(try!(self.next_char()).unwrap_or(b'\x00'))
+    }
+
+    fn error(&mut self, reason: ErrorCode) -> Error {
+        Error::SyntaxError(reason, self.rdr.line(), self.rdr.col())
+    }
+
+    fn parse_whitespace(&mut self) -> Result<()> {
+        loop {
+            match try!(self.peek_or_null()) {
+                b' ' | b'\n' | b'\t' | b'\r' => {
+                    self.eat_char();
+                }
+                _ => { return Ok(()); }
+            }
+        }
+    }
+
+    fn parse_value<V>(&mut self, mut visitor: V) -> Result<V::Value>
+        where V: de::Visitor,
+    {
+        try!(self.parse_whitespace());
+
+        if try!(self.eof()) {
+            return Err(self.error(ErrorCode::EOFWhileParsingValue));
+        }
+
+        let value = match try!(self.peek_or_null()) {
+            b'n' => {
+                self.eat_char();
+                try!(self.parse_ident(b"ull"));
+                visitor.visit_unit()
+            }
+            b't' => {
+                self.eat_char();
+                try!(self.parse_ident(b"rue"));
+                visitor.visit_bool(true)
+            }
+            b'f' => {
+                self.eat_char();
+                try!(self.parse_ident(b"alse"));
+                visitor.visit_bool(false)
+            }
+            b'-' => {
+                self.eat_char();
+                self.parse_integer(false, visitor)
+            }
+            b'0' ... b'9' => {
+                self.parse_integer(true, visitor)
+            }
+            b'"' => {
+                self.eat_char();
+                try!(self.parse_string());
+                let s = str::from_utf8(&self.str_buf).unwrap();
+                visitor.visit_str(s)
+            }
+            b'[' => {
+                self.eat_char();
+                visitor.visit_seq(SeqVisitor::new(self))
+            }
+            b'{' => {
+                self.eat_char();
+                visitor.visit_map(MapVisitor::new(self))
+            }
+            _ => {
+                Err(self.error(ErrorCode::ExpectedSomeValue))
+            }
+        };
+
+        match value {
+            Ok(value) => Ok(value),
+            Err(Error::SyntaxError(code, _, _)) => Err(self.error(code)),
+            Err(err) => Err(err),
+        }
+    }
+
+    fn parse_ident(&mut self, ident: &[u8]) -> Result<()> {
+        for c in ident {
+            if Some(*c) != try!(self.next_char()) {
+                return Err(self.error(ErrorCode::ExpectedSomeIdent));
+            }
+        }
+
+        Ok(())
+    }
+
+    fn parse_integer<V>(&mut self, pos: bool, visitor: V) -> Result<V::Value>
+        where V: de::Visitor,
+    {
+        match try!(self.next_char_or_null()) {
+            b'0' => {
+                // There can be only one leading '0'.
+                match try!(self.peek_or_null()) {
+                    b'0' ... b'9' => {
+                        Err(self.error(ErrorCode::InvalidNumber))
+                    }
+                    _ => {
+                        self.parse_number(pos, 0, visitor)
+                    }
+                }
+            },
+            c @ b'1' ... b'9' => {
+                let mut res: u64 = (c as u64) - ('0' as u64);
+
+                loop {
+                    match try!(self.peek_or_null()) {
+                        c @ b'0' ... b'9' => {
+                            self.eat_char();
+
+                            let digit = (c as u64) - ('0' as u64);
+
+                            // We need to be careful with overflow. If we can, try to keep the
+                            // number as a `u64` until we grow too large. At that point, switch to
+                            // parsing the value as a `f64`.
+                            match res.checked_mul(10).and_then(|val| val.checked_add(digit)) {
+                                Some(res_) => { res = res_; }
+                                None => {
+                                    return self.parse_float(
+                                        pos,
+                                        (res as f64) * 10.0 + (digit as f64),
+                                        visitor);
+                                }
+                            }
+                        }
+                        _ => {
+                            return self.parse_number(pos, res, visitor);
+                        }
+                    }
+                }
+            }
+            _ => {
+                Err(self.error(ErrorCode::InvalidNumber))
+            }
+        }
+    }
+
+    fn parse_float<V>(&mut self,
+                      pos: bool,
+                      mut res: f64,
+                      mut visitor: V) -> Result<V::Value>
+        where V: de::Visitor,
+    {
+        loop {
+            match try!(self.next_char_or_null()) {
+                c @ b'0' ... b'9' => {
+                    let digit = (c as u64) - ('0' as u64);
+
+                    res *= 10.0;
+                    res += digit as f64;
+                }
+                _ => {
+                    match try!(self.peek_or_null()) {
+                        b'.' => {
+                            return self.parse_decimal(pos, res, visitor);
+                        }
+                        b'e' | b'E' => {
+                            return self.parse_exponent(pos, res, visitor);
+                        }
+                        _ => {
+                            if !pos {
+                                res = -res;
+                            }
+
+                            return visitor.visit_f64(res);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    fn parse_number<V>(&mut self,
+                       pos: bool,
+                       res: u64,
+                       mut visitor: V) -> Result<V::Value>
+        where V: de::Visitor,
+    {
+        match try!(self.peek_or_null()) {
+            b'.' => {
+                self.parse_decimal(pos, res as f64, visitor)
+            }
+            b'e' | b'E' => {
+                self.parse_exponent(pos, res as f64, visitor)
+            }
+            _ => {
+                if pos {
+                    visitor.visit_u64(res)
+                } else {
+                    // FIXME: `wrapping_neg` will be stable in Rust 1.2
+                    //let res_i64 = (res as i64).wrapping_neg();
+                    let res_i64 = (!res + 1) as i64;
+
+                    // Convert into a float if we underflow.
+                    if res_i64 > 0 {
+                        visitor.visit_f64(-(res as f64))
+                    } else {
+                        visitor.visit_i64(res_i64)
+                    }
+                }
+            }
+        }
+    }
+
+    fn parse_decimal<V>(&mut self,
+                        pos: bool,
+                        mut res: f64,
+                        mut visitor: V) -> Result<V::Value>
+        where V: de::Visitor,
+    {
+        self.eat_char();
+
+        let mut dec = 0.1;
+
+        // Make sure a digit follows the decimal place.
+        match try!(self.next_char_or_null()) {
+            c @ b'0' ... b'9' => {
+                res += (((c as u64) - (b'0' as u64)) as f64) * dec;
+            }
+             _ => { return Err(self.error(ErrorCode::InvalidNumber)); }
+        }
+
+        loop {
+            match try!(self.peek_or_null()) {
+                c @ b'0' ... b'9' => {
+                    self.eat_char();
+
+                    dec /= 10.0;
+                    res += (((c as u64) - (b'0' as u64)) as f64) * dec;
+                }
+                _ => { break; }
+            }
+        }
+
+        match try!(self.peek_or_null()) {
+            b'e' | b'E' => {
+                self.parse_exponent(pos, res, visitor)
+            }
+            _ => {
+                if pos {
+                    visitor.visit_f64(res)
+                } else {
+                    visitor.visit_f64(-res)
+                }
+            }
+        }
+
+    }
+
+    fn parse_exponent<V>(&mut self,
+                         pos: bool,
+                         mut res: f64,
+                         mut visitor: V) -> Result<V::Value>
+        where V: de::Visitor,
+    {
+        self.eat_char();
+
+        let pos_exp = match try!(self.peek_or_null()) {
+            b'+' => { self.eat_char(); true }
+            b'-' => { self.eat_char(); false }
+            _ => { true }
+        };
+
+        // Make sure a digit follows the exponent place.
+        let mut exp = match try!(self.next_char_or_null()) {
+            c @ b'0' ... b'9' => { (c as u64) - (b'0' as u64) }
+            _ => { return Err(self.error(ErrorCode::InvalidNumber)); }
+        };
+
+        loop {
+            match try!(self.peek_or_null()) {
+                c @ b'0' ... b'9' => {
+                    self.eat_char();
+
+                    exp = try_or_invalid!(self, exp.checked_mul(10));
+                    exp = try_or_invalid!(self, exp.checked_add((c as u64) - (b'0' as u64)));
+                }
+                _ => { break; }
+            }
+        }
+
+        let exp = if exp <= i32::MAX as u64 {
+            10_f64.powi(exp as i32)
+        } else {
+            return Err(self.error(ErrorCode::InvalidNumber));
+        };
+
+        if pos_exp {
+            res *= exp;
+        } else {
+            res /= exp;
+        }
+
+        if pos {
+            visitor.visit_f64(res)
+        } else {
+            visitor.visit_f64(-res)
+        }
+    }
+
+    fn decode_hex_escape(&mut self) -> Result<u16> {
+        let mut i = 0;
+        let mut n = 0u16;
+        while i < 4 && !try!(self.eof()) {
+            n = match try!(self.next_char_or_null()) {
+                c @ b'0' ... b'9' => n * 16_u16 + ((c as u16) - (b'0' as u16)),
+                b'a' | b'A' => n * 16_u16 + 10_u16,
+                b'b' | b'B' => n * 16_u16 + 11_u16,
+                b'c' | b'C' => n * 16_u16 + 12_u16,
+                b'd' | b'D' => n * 16_u16 + 13_u16,
+                b'e' | b'E' => n * 16_u16 + 14_u16,
+                b'f' | b'F' => n * 16_u16 + 15_u16,
+                _ => { return Err(self.error(ErrorCode::InvalidEscape)); }
+            };
+
+            i += 1;
+        }
+
+        // Error out if we didn't parse 4 digits.
+        if i != 4 {
+            return Err(self.error(ErrorCode::InvalidEscape));
+        }
+
+        Ok(n)
+    }
+
+    fn parse_string(&mut self) -> Result<()> {
+        self.str_buf.clear();
+
+        loop {
+            let ch = match try!(self.next_char()) {
+                Some(ch) => ch,
+                None => { return Err(self.error(ErrorCode::EOFWhileParsingString)); }
+            };
+
+            match ch {
+                b'"' => {
+                    return Ok(());
+                }
+                b'\\' => {
+                    let ch = match try!(self.next_char()) {
+                        Some(ch) => ch,
+                        None => { return Err(self.error(ErrorCode::EOFWhileParsingString)); }
+                    };
+
+                    match ch {
+                        b'"' => self.str_buf.push(b'"'),
+                        b'\\' => self.str_buf.push(b'\\'),
+                        b'/' => self.str_buf.push(b'/'),
+                        b'b' => self.str_buf.push(b'\x08'),
+                        b'f' => self.str_buf.push(b'\x0c'),
+                        b'n' => self.str_buf.push(b'\n'),
+                        b'r' => self.str_buf.push(b'\r'),
+                        b't' => self.str_buf.push(b'\t'),
+                        b'u' => {
+                            let c = match try!(self.decode_hex_escape()) {
+                                0xDC00 ... 0xDFFF => {
+                                    return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
+                                }
+
+                                // Non-BMP characters are encoded as a sequence of
+                                // two hex escapes, representing UTF-16 surrogates.
+                                n1 @ 0xD800 ... 0xDBFF => {
+                                    match (try!(self.next_char()), try!(self.next_char())) {
+                                        (Some(b'\\'), Some(b'u')) => (),
+                                        _ => {
+                                            return Err(self.error(ErrorCode::UnexpectedEndOfHexEscape));
+                                        }
+                                    }
+
+                                    let n2 = try!(self.decode_hex_escape());
+
+                                    if n2 < 0xDC00 || n2 > 0xDFFF {
+                                        return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
+                                    }
+
+                                    let n = (((n1 - 0xD800) as u32) << 10 |
+                                              (n2 - 0xDC00) as u32) + 0x1_0000;
+
+                                    match char::from_u32(n as u32) {
+                                        Some(c) => c,
+                                        None => {
+                                            return Err(self.error(ErrorCode::InvalidUnicodeCodePoint));
+                                        }
+                                    }
+                                }
+
+                                n => {
+                                    match char::from_u32(n as u32) {
+                                        Some(c) => c,
+                                        None => {
+                                            return Err(self.error(ErrorCode::InvalidUnicodeCodePoint));
+                                        }
+                                    }
+                                }
+                            };
+
+                            // FIXME: this allocation is required in order to be compatible with stable
+                            // rust, which doesn't support encoding a `char` into a stack buffer.
+                            let buf = c.to_string();
+                            self.str_buf.extend(buf.bytes());
+                        }
+                        _ => {
+                            return Err(self.error(ErrorCode::InvalidEscape));
+                        }
+                    }
+                }
+                ch => {
+                    self.str_buf.push(ch);
+                }
+            }
+        }
+    }
+
+    fn parse_object_colon(&mut self) -> Result<()> {
+        try!(self.parse_whitespace());
+
+        match try!(self.next_char()) {
+            Some(b':') => Ok(()),
+            Some(_) => Err(self.error(ErrorCode::ExpectedColon)),
+            None => Err(self.error(ErrorCode::EOFWhileParsingObject)),
+        }
+    }
+}
+
+impl<Iter> de::Deserializer for Deserializer<Iter>
+    where Iter: Iterator<Item=io::Result<u8>>,
+{
+    type Error = Error;
+
+    #[inline]
+    fn visit<V>(&mut self, visitor: V) -> Result<V::Value>
+        where V: de::Visitor,
+    {
+        self.parse_value(visitor)
+    }
+
+    /// Parses a `null` as a None, and any other values as a `Some(...)`.
+    #[inline]
+    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value>
+        where V: de::Visitor,
+    {
+        try!(self.parse_whitespace());
+
+        match try!(self.peek_or_null()) {
+            b'n' => {
+                self.eat_char();
+                try!(self.parse_ident(b"ull"));
+                visitor.visit_none()
+            }
+            _ => {
+                visitor.visit_some(self)
+            }
+        }
+    }
+
+    /// Parses a newtype struct as the underlying value.
+    #[inline]
+    fn visit_newtype_struct<V>(&mut self,
+                               _name: &str,
+                               mut visitor: V) -> Result<V::Value>
+        where V: de::Visitor,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    /// Parses an enum as an object like `{"$KEY":$VALUE}`, where $VALUE is either a straight
+    /// value, a `[..]`, or a `{..}`.
+    #[inline]
+    fn visit_enum<V>(&mut self,
+                     _name: &str,
+                     _variants: &'static [&'static str],
+                     mut visitor: V) -> Result<V::Value>
+        where V: de::EnumVisitor,
+    {
+        try!(self.parse_whitespace());
+
+        match try!(self.next_char_or_null()) {
+            b'{' => {
+                try!(self.parse_whitespace());
+
+                let value = {
+                    try!(visitor.visit(&mut *self))
+                };
+
+                try!(self.parse_whitespace());
+
+                match try!(self.next_char_or_null()) {
+                    b'}' => {
+                        Ok(value)
+                    }
+                    _ => {
+                        Err(self.error(ErrorCode::ExpectedSomeValue))
+                    }
+                }
+            }
+            _ => {
+                Err(self.error(ErrorCode::ExpectedSomeValue))
+            }
+        }
+    }
+
+    #[inline]
+    fn format() -> &'static str {
+        "json"
+    }
+}
+
+struct SeqVisitor<'a, Iter: 'a + Iterator<Item=io::Result<u8>>> {
+    de: &'a mut Deserializer<Iter>,
+    first: bool,
+}
+
+impl<'a, Iter: Iterator<Item=io::Result<u8>>> SeqVisitor<'a, Iter> {
+    fn new(de: &'a mut Deserializer<Iter>) -> Self {
+        SeqVisitor {
+            de: de,
+            first: true,
+        }
+    }
+}
+
+impl<'a, Iter> de::SeqVisitor for SeqVisitor<'a, Iter>
+    where Iter: Iterator<Item=io::Result<u8>>,
+{
+    type Error = Error;
+
+    fn visit<T>(&mut self) -> Result<Option<T>>
+        where T: de::Deserialize,
+    {
+        try!(self.de.parse_whitespace());
+
+        match try!(self.de.peek()) {
+            Some(b']') => {
+                return Ok(None);
+            }
+            Some(b',') if !self.first => {
+                self.de.eat_char();
+            }
+            Some(_) => {
+                if self.first {
+                    self.first = false;
+                } else {
+                    return Err(self.de.error(ErrorCode::ExpectedListCommaOrEnd));
+                }
+            }
+            None => {
+                return Err(self.de.error(ErrorCode::EOFWhileParsingList));
+            }
+        }
+
+        let value = try!(de::Deserialize::deserialize(self.de));
+        Ok(Some(value))
+    }
+
+    fn end(&mut self) -> Result<()> {
+        try!(self.de.parse_whitespace());
+
+        match try!(self.de.next_char()) {
+            Some(b']') => { Ok(()) }
+            Some(_) => {
+                Err(self.de.error(ErrorCode::TrailingCharacters))
+            }
+            None => {
+                Err(self.de.error(ErrorCode::EOFWhileParsingList))
+            }
+        }
+    }
+}
+
+struct MapVisitor<'a, Iter: 'a + Iterator<Item=io::Result<u8>>> {
+    de: &'a mut Deserializer<Iter>,
+    first: bool,
+}
+
+impl<'a, Iter: Iterator<Item=io::Result<u8>>> MapVisitor<'a, Iter> {
+    fn new(de: &'a mut Deserializer<Iter>) -> Self {
+        MapVisitor {
+            de: de,
+            first: true,
+        }
+    }
+}
+
+impl<'a, Iter> de::MapVisitor for MapVisitor<'a, Iter>
+    where Iter: Iterator<Item=io::Result<u8>>
+{
+    type Error = Error;
+
+    fn visit_key<K>(&mut self) -> Result<Option<K>>
+        where K: de::Deserialize,
+    {
+        try!(self.de.parse_whitespace());
+
+        match try!(self.de.peek()) {
+            Some(b'}') => {
+                return Ok(None);
+            }
+            Some(b',') if !self.first => {
+                self.de.eat_char();
+                try!(self.de.parse_whitespace());
+            }
+            Some(_) => {
+                if self.first {
+                    self.first = false;
+                } else {
+                    return Err(self.de.error(ErrorCode::ExpectedObjectCommaOrEnd));
+                }
+            }
+            None => {
+                return Err(self.de.error(ErrorCode::EOFWhileParsingObject));
+            }
+        }
+
+        match try!(self.de.peek()) {
+            Some(b'"') => {
+                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+            }
+            Some(_) => {
+                Err(self.de.error(ErrorCode::KeyMustBeAString))
+            }
+            None => {
+                Err(self.de.error(ErrorCode::EOFWhileParsingValue))
+            }
+        }
+    }
+
+    fn visit_value<V>(&mut self) -> Result<V>
+        where V: de::Deserialize,
+    {
+        try!(self.de.parse_object_colon());
+
+        Ok(try!(de::Deserialize::deserialize(self.de)))
+    }
+
+    fn end(&mut self) -> Result<()> {
+        try!(self.de.parse_whitespace());
+
+        match try!(self.de.next_char()) {
+            Some(b'}') => { Ok(()) }
+            Some(_) => {
+                Err(self.de.error(ErrorCode::TrailingCharacters))
+            }
+            None => {
+                Err(self.de.error(ErrorCode::EOFWhileParsingObject))
+            }
+        }
+    }
+
+    fn missing_field<V>(&mut self, _field: &'static str) -> Result<V>
+        where V: de::Deserialize,
+    {
+        let mut de = de::value::ValueDeserializer::into_deserializer(());
+        Ok(try!(de::Deserialize::deserialize(&mut de)))
+    }
+}
+
+impl<Iter> de::VariantVisitor for Deserializer<Iter>
+    where Iter: Iterator<Item=io::Result<u8>>,
+{
+    type Error = Error;
+
+    fn visit_variant<V>(&mut self) -> Result<V>
+        where V: de::Deserialize
+    {
+        let val = try!(de::Deserialize::deserialize(self));
+        try!(self.parse_object_colon());
+        Ok(val)
+    }
+
+    fn visit_unit(&mut self) -> Result<()> {
+        de::Deserialize::deserialize(self)
+    }
+
+    fn visit_newtype<T>(&mut self) -> Result<T>
+        where T: de::Deserialize,
+    {
+        de::Deserialize::deserialize(self)
+    }
+
+    fn visit_tuple<V>(&mut self,
+                      _len: usize,
+                      visitor: V) -> Result<V::Value>
+        where V: de::Visitor,
+    {
+        de::Deserializer::visit(self, visitor)
+    }
+
+    fn visit_struct<V>(&mut self,
+                       _fields: &'static [&'static str],
+                       visitor: V) -> Result<V::Value>
+        where V: de::Visitor,
+    {
+        de::Deserializer::visit(self, visitor)
+    }
+}
+
+/// Decodes a json value from a `std::io::Read`.
+pub fn from_iter<I, T>(iter: I) -> Result<T>
+    where I: Iterator<Item=io::Result<u8>>,
+          T: de::Deserialize,
+{
+    let mut de = Deserializer::new(iter);
+    let value = try!(de::Deserialize::deserialize(&mut de));
+
+    // Make sure the whole stream has been consumed.
+    try!(de.end());
+    Ok(value)
+}
+
+/// Decodes a json value from a `std::io::Read`.
+pub fn from_reader<R, T>(rdr: R) -> Result<T>
+    where R: io::Read,
+          T: de::Deserialize,
+{
+    from_iter(rdr.bytes())
+}
+
+/// Decodes a json value from a `&str`.
+pub fn from_slice<T>(v: &[u8]) -> Result<T>
+    where T: de::Deserialize
+{
+    from_iter(v.iter().map(|byte| Ok(*byte)))
+}
+
+/// Decodes a json value from a `&str`.
+pub fn from_str<T>(s: &str) -> Result<T>
+    where T: de::Deserialize
+{
+    from_slice(s.as_bytes())
+}

serde_json/src/error.rs

@@ -1,11 +1,12 @@
 use std::error;
 use std::fmt;
 use std::io;
+use std::result;
 
-use de;
+use serde::de;
 
 /// The errors that can arise while parsing a JSON stream.
-#[derive(Copy, Clone, PartialEq)]
+#[derive(Clone, PartialEq)]
 pub enum ErrorCode {
     EOFWhileParsingList,
     EOFWhileParsingObject,
@@ -28,6 +29,7 @@ pub enum ErrorCode {
     InvalidUnicodeCodePoint,
     KeyMustBeAString,
     LoneLeadingSurrogateInHexEscape,
+    UnknownField(String),
     MissingField(&'static str),
     NotFourDigit,
     NotUtf8,
@@ -65,6 +67,7 @@ impl fmt::Debug for ErrorCode {
             ErrorCode::InvalidUnicodeCodePoint => "invalid unicode code point".fmt(f),
             ErrorCode::KeyMustBeAString => "key must be a string".fmt(f),
             ErrorCode::LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape".fmt(f),
+            ErrorCode::UnknownField(ref field) => write!(f, "unknown field \"{}\"", field),
             ErrorCode::MissingField(ref field) => write!(f, "missing field \"{}\"", field),
             ErrorCode::NotFourDigit => "invalid \\u escape (not four digits)".fmt(f),
             ErrorCode::NotUtf8 => "contents not utf-8".fmt(f),
@@ -77,7 +80,7 @@ impl fmt::Debug for ErrorCode {
     }
 }
 
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Debug)]
 pub enum Error {
     /// msg, line, col
     SyntaxError(ErrorCode, usize, usize),
@@ -95,7 +98,7 @@ impl error::Error for Error {
     fn description(&self) -> &str {
         match *self {
             Error::SyntaxError(..) => "syntax error",
-            Error::IoError(ref error) => error.description(),
+            Error::IoError(ref error) => error::Error::description(error),
             /*
             Error::ExpectedError(ref expected, _) => &expected,
             */
@@ -139,22 +142,48 @@ impl fmt::Display for Error {
     }
 }
 
-impl error::FromError<io::Error> for Error {
-    fn from_error(error: io::Error) -> Error {
+impl From<io::Error> for Error {
+    fn from(error: io::Error) -> Error {
         Error::IoError(error)
     }
 }
 
+impl From<de::value::Error> for Error {
+    fn from(error: de::value::Error) -> Error {
+        match error {
+            de::value::Error::SyntaxError => {
+                Error::SyntaxError(ErrorCode::ExpectedSomeValue, 0, 0)
+            }
+            de::value::Error::EndOfStreamError => {
+                de::Error::end_of_stream()
+            }
+            de::value::Error::UnknownFieldError(field) => {
+                Error::SyntaxError(ErrorCode::UnknownField(field), 0, 0)
+            }
+            de::value::Error::MissingFieldError(field) => {
+                de::Error::missing_field(field)
+            }
+        }
+    }
+}
+
 impl de::Error for Error {
-    fn syntax_error() -> Error {
+    fn syntax(_: &str) -> Error {
         Error::SyntaxError(ErrorCode::ExpectedSomeValue, 0, 0)
     }
 
-    fn end_of_stream_error() -> Error {
+    fn end_of_stream() -> Error {
         Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 0, 0)
     }
 
-    fn missing_field_error(field: &'static str) -> Error {
+    fn unknown_field(field: &str) -> Error {
+        Error::SyntaxError(ErrorCode::UnknownField(field.to_string()), 0, 0)
+    }
+
+    fn missing_field(field: &'static str) -> Error {
         Error::MissingFieldError(field)
     }
 }
+
+/// Helper alias for `Result` objects that return a JSON `Error`.
+pub type Result<T> = result::Result<T, Error>;

serde_json/src/lib.rs

@@ -0,0 +1,116 @@
+//! JSON and serialization
+//!
+//! # What is JSON?
+//!
+//! JSON (JavaScript Object Notation) is a way to write data in JavaScript.  Like XML, it allows to
+//! encode structured data in a text format that can be easily read by humans.  Its simple syntax
+//! and native compatibility with JavaScript have made it a widely used format.
+//!
+//! Data types that can be encoded are JavaScript types (see the `serde_json:Value` enum for more
+//! details):
+//!
+//! * `Boolean`: equivalent to rust's `bool`
+//! * `I64`: equivalent to rust's `i64`
+//! * `U64`: equivalent to rust's `u64`
+//! * `F64`: equivalent to rust's `i64`
+//! * `String`: equivalent to rust's `String`
+//! * `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of different types in the
+//!    same array
+//! * `Object`: equivalent to rust's `BTreeMap<String, serde_json::Value>`
+//! * `Null`
+//!
+//! An object is a series of string keys mapping to values, in `"key": value` format.  Arrays are
+//! enclosed in square brackets ([ ... ]) and objects in curly brackets ({ ... }).  A simple JSON
+//! document encoding a person, his/her age, address and phone numbers could look like
+//!
+//! ```ignore
+//! {
+//!     "FirstName": "John",
+//!     "LastName": "Doe",
+//!     "Age": 43,
+//!     "Address": {
+//!         "Street": "Downing Street 10",
+//!         "City": "London",
+//!         "Country": "Great Britain"
+//!     },
+//!     "PhoneNumbers": [
+//!         "+44 1234567",
+//!         "+44 2345678"
+//!     ]
+//! }
+//! ```
+//!
+//! # Type-based Serialization and Deserialization
+//!
+//! Serde provides a mechanism for low boilerplate serialization & deserialization of values to and
+//! from JSON via the serialization API.  To be able to serialize a piece of data, it must implement
+//! the `serde::Serialize` trait.  To be able to deserialize a piece of data, it must implement the
+//! `serde::Deserialize` trait.  Serde provides provides an annotation to automatically generate
+//! the code for these traits: `#[derive(Serialize, Deserialize)]`.
+//!
+//! The JSON API also provides an enum `serde_json::Value` and a method `to_value` to serialize
+//! objects.  A `serde_json::Value` value can be serialized as a string or buffer using the
+//! functions described above.  You can also use the `json::Serializer` object, which implements the
+//! `Serializer` trait.
+//!
+//! # Examples of use
+//!
+//! ## Parsing a `str` to `Value` and reading the result
+//!
+//! ```rust
+//! //#![feature(custom_derive, plugin)]
+//! //#![plugin(serde_macros)]
+//!
+//! extern crate serde_json;
+//!
+//! use serde_json::Value;
+//!
+//! fn main() {
+//!     let data: Value = serde_json::from_str("{\"foo\": 13, \"bar\": \"baz\"}").unwrap();
+//!     println!("data: {:?}", data);
+//!     // data: {"bar":"baz","foo":13}
+//!     println!("object? {}", data.is_object());
+//!     // object? true
+//!
+//!     let obj = data.as_object().unwrap();
+//!     let foo = obj.get("foo").unwrap();
+//!
+//!     println!("array? {:?}", foo.as_array());
+//!     // array? None
+//!     println!("u64? {:?}", foo.as_u64());
+//!     // u64? Some(13u64)
+//!
+//!     for (key, value) in obj.iter() {
+//!         println!("{}: {}", key, match *value {
+//!             Value::U64(v) => format!("{} (u64)", v),
+//!             Value::String(ref v) => format!("{} (string)", v),
+//!             _ => format!("other")
+//!         });
+//!     }
+//!     // bar: baz (string)
+//!     // foo: 13 (u64)
+//! }
+//! ```
+
+extern crate num;
+extern crate serde;
+
+pub use self::de::{Deserializer, from_str};
+pub use self::error::{Error, ErrorCode, Result};
+pub use self::ser::{
+    Serializer,
+    to_writer,
+    to_writer_pretty,
+    to_vec,
+    to_vec_pretty,
+    to_string,
+    to_string_pretty,
+    escape_str,
+};
+pub use self::value::{Value, to_value, from_value};
+
+pub mod builder;
+pub mod de;
+pub mod error;
+pub mod ser;
+pub mod value;

serde_json/src/ser.rs

@@ -0,0 +1,556 @@
+use std::io;
+use std::num::FpCategory;
+use std::string::FromUtf8Error;
+
+use serde::ser;
+
+/// A structure for implementing serialization to JSON.
+pub struct Serializer<W, F=CompactFormatter> {
+    writer: W,
+    formatter: F,
+
+    /// `first` is used to signify if we should print a comma when we are walking through a
+    /// sequence.
+    first: bool,
+}
+
+impl<W> Serializer<W>
+    where W: io::Write,
+{
+    /// Creates a new JSON serializer.
+    #[inline]
+    pub fn new(writer: W) -> Self {
+        Serializer::with_formatter(writer, CompactFormatter)
+    }
+}
+
+impl<'a, W> Serializer<W, PrettyFormatter<'a>>
+    where W: io::Write,
+{
+    /// Creates a new JSON pretty print serializer.
+    #[inline]
+    pub fn pretty(writer: W) -> Self {
+        Serializer::with_formatter(writer, PrettyFormatter::new())
+    }
+}
+
+impl<W, F> Serializer<W, F>
+    where W: io::Write,
+          F: Formatter,
+{
+    /// Creates a new JSON visitor whose output will be written to the writer
+    /// specified.
+    #[inline]
+    pub fn with_formatter(writer: W, formatter: F) -> Self {
+        Serializer {
+            writer: writer,
+            formatter: formatter,
+            first: false,
+        }
+    }
+
+    /// Unwrap the `Writer` from the `Serializer`.
+    #[inline]
+    pub fn into_inner(self) -> W {
+        self.writer
+    }
+}
+
+impl<W, F> ser::Serializer for Serializer<W, F>
+    where W: io::Write,
+          F: Formatter,
+{
+    type Error = io::Error;
+
+    #[inline]
+    fn visit_bool(&mut self, value: bool) -> io::Result<()> {
+        if value {
+            self.writer.write_all(b"true")
+        } else {
+            self.writer.write_all(b"false")
+        }
+    }
+
+    #[inline]
+    fn visit_isize(&mut self, value: isize) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_i8(&mut self, value: i8) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_i16(&mut self, value: i16) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_i32(&mut self, value: i32) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_i64(&mut self, value: i64) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_usize(&mut self, value: usize) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_u8(&mut self, value: u8) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_u16(&mut self, value: u16) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_u32(&mut self, value: u32) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_u64(&mut self, value: u64) -> io::Result<()> {
+        write!(&mut self.writer, "{}", value)
+    }
+
+    #[inline]
+    fn visit_f32(&mut self, value: f32) -> io::Result<()> {
+        fmt_f32_or_null(&mut self.writer, value)
+    }
+
+    #[inline]
+    fn visit_f64(&mut self, value: f64) -> io::Result<()> {
+        fmt_f64_or_null(&mut self.writer, value)
+    }
+
+    #[inline]
+    fn visit_char(&mut self, value: char) -> io::Result<()> {
+        escape_char(&mut self.writer, value)
+    }
+
+    #[inline]
+    fn visit_str(&mut self, value: &str) -> io::Result<()> {
+        escape_str(&mut self.writer, value)
+    }
+
+    #[inline]
+    fn visit_none(&mut self) -> io::Result<()> {
+        self.visit_unit()
+    }
+
+    #[inline]
+    fn visit_some<V>(&mut self, value: V) -> io::Result<()>
+        where V: ser::Serialize
+    {
+        value.serialize(self)
+    }
+
+    #[inline]
+    fn visit_unit(&mut self) -> io::Result<()> {
+        self.writer.write_all(b"null")
+    }
+
+    /// Override `visit_newtype_struct` to serialize newtypes without an object wrapper.
+    #[inline]
+    fn visit_newtype_struct<T>(&mut self,
+                               _name: &'static str,
+                               value: T) -> Result<(), Self::Error>
+        where T: ser::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    #[inline]
+    fn visit_unit_variant(&mut self,
+                          _name: &str,
+                          _variant_index: usize,
+                          variant: &str) -> io::Result<()> {
+        try!(self.formatter.open(&mut self.writer, b'{'));
+        try!(self.formatter.comma(&mut self.writer, true));
+        try!(self.visit_str(variant));
+        try!(self.formatter.colon(&mut self.writer));
+        try!(self.writer.write_all(b"[]"));
+        self.formatter.close(&mut self.writer, b'}')
+    }
+
+    #[inline]
+    fn visit_newtype_variant<T>(&mut self,
+                                _name: &str,
+                                _variant_index: usize,
+                                variant: &str,
+                                value: T) -> io::Result<()>
+        where T: ser::Serialize,
+    {
+        try!(self.formatter.open(&mut self.writer, b'{'));
+        try!(self.formatter.comma(&mut self.writer, true));
+        try!(self.visit_str(variant));
+        try!(self.formatter.colon(&mut self.writer));
+        try!(value.serialize(self));
+        self.formatter.close(&mut self.writer, b'}')
+    }
+
+    #[inline]
+    fn visit_seq<V>(&mut self, mut visitor: V) -> io::Result<()>
+        where V: ser::SeqVisitor,
+    {
+        match visitor.len() {
+            Some(len) if len == 0 => {
+                self.writer.write_all(b"[]")
+            }
+            _ => {
+                try!(self.formatter.open(&mut self.writer, b'['));
+
+                self.first = true;
+
+                while let Some(()) = try!(visitor.visit(self)) { }
+
+                self.formatter.close(&mut self.writer, b']')
+            }
+        }
+
+    }
+
+    #[inline]
+    fn visit_tuple_variant<V>(&mut self,
+                              _name: &str,
+                              _variant_index: usize,
+                              variant: &str,
+                              visitor: V) -> io::Result<()>
+        where V: ser::SeqVisitor,
+    {
+        try!(self.formatter.open(&mut self.writer, b'{'));
+        try!(self.formatter.comma(&mut self.writer, true));
+        try!(self.visit_str(variant));
+        try!(self.formatter.colon(&mut self.writer));
+        try!(self.visit_seq(visitor));
+        self.formatter.close(&mut self.writer, b'}')
+    }
+
+    #[inline]
+    fn visit_seq_elt<T>(&mut self, value: T) -> io::Result<()>
+        where T: ser::Serialize,
+    {
+        try!(self.formatter.comma(&mut self.writer, self.first));
+        try!(value.serialize(self));
+
+        self.first = false;
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_map<V>(&mut self, mut visitor: V) -> io::Result<()>
+        where V: ser::MapVisitor,
+    {
+        match visitor.len() {
+            Some(len) if len == 0 => {
+                self.writer.write_all(b"{}")
+            }
+            _ => {
+                try!(self.formatter.open(&mut self.writer, b'{'));
+
+                self.first = true;
+
+                while let Some(()) = try!(visitor.visit(self)) { }
+
+                self.formatter.close(&mut self.writer, b'}')
+            }
+        }
+    }
+
+    #[inline]
+    fn visit_struct_variant<V>(&mut self,
+                               _name: &str,
+                               _variant_index: usize,
+                               variant: &str,
+                               visitor: V) -> io::Result<()>
+        where V: ser::MapVisitor,
+    {
+        try!(self.formatter.open(&mut self.writer, b'{'));
+        try!(self.formatter.comma(&mut self.writer, true));
+        try!(self.visit_str(variant));
+        try!(self.formatter.colon(&mut self.writer));
+        try!(self.visit_map(visitor));
+
+        self.formatter.close(&mut self.writer, b'}')
+    }
+
+    #[inline]
+    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> io::Result<()>
+        where K: ser::Serialize,
+              V: ser::Serialize,
+    {
+        try!(self.formatter.comma(&mut self.writer, self.first));
+
+        try!(key.serialize(self));
+        try!(self.formatter.colon(&mut self.writer));
+        try!(value.serialize(self));
+
+        self.first = false;
+
+        Ok(())
+    }
+
+    #[inline]
+    fn format() -> &'static str {
+        "json"
+    }
+}
+
+pub trait Formatter {
+    fn open<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
+        where W: io::Write;
+
+    fn comma<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
+        where W: io::Write;
+
+    fn colon<W>(&mut self, writer: &mut W) -> io::Result<()>
+        where W: io::Write;
+
+    fn close<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
+        where W: io::Write;
+}
+
+pub struct CompactFormatter;
+
+impl Formatter for CompactFormatter {
+    fn open<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
+        where W: io::Write,
+    {
+        writer.write_all(&[ch])
+    }
+
+    fn comma<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
+        where W: io::Write,
+    {
+        if first {
+            Ok(())
+        } else {
+            writer.write_all(b",")
+        }
+    }
+
+    fn colon<W>(&mut self, writer: &mut W) -> io::Result<()>
+        where W: io::Write,
+    {
+        writer.write_all(b":")
+    }
+
+    fn close<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
+        where W: io::Write,
+    {
+        writer.write_all(&[ch])
+    }
+}
+
+pub struct PrettyFormatter<'a> {
+    current_indent: usize,
+    indent: &'a [u8],
+}
+
+impl<'a> PrettyFormatter<'a> {
+    fn new() -> Self {
+        PrettyFormatter::with_indent(b"  ")
+    }
+
+    fn with_indent(indent: &'a [u8]) -> Self {
+        PrettyFormatter {
+            current_indent: 0,
+            indent: indent,
+        }
+    }
+}
+
+impl<'a> Formatter for PrettyFormatter<'a> {
+    fn open<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
+        where W: io::Write,
+    {
+        self.current_indent += 1;
+        writer.write_all(&[ch])
+    }
+
+    fn comma<W>(&mut self, writer: &mut W, first: bool) -> io::Result<()>
+        where W: io::Write,
+    {
+        if first {
+            try!(writer.write_all(b"\n"));
+        } else {
+            try!(writer.write_all(b",\n"));
+        }
+
+        indent(writer, self.current_indent, self.indent)
+    }
+
+    fn colon<W>(&mut self, writer: &mut W) -> io::Result<()>
+        where W: io::Write,
+    {
+        writer.write_all(b": ")
+    }
+
+    fn close<W>(&mut self, writer: &mut W, ch: u8) -> io::Result<()>
+        where W: io::Write,
+    {
+        self.current_indent -= 1;
+        try!(writer.write(b"\n"));
+        try!(indent(writer, self.current_indent, self.indent));
+
+        writer.write_all(&[ch])
+    }
+}
+
+#[inline]
+pub fn escape_bytes<W>(wr: &mut W, bytes: &[u8]) -> io::Result<()>
+    where W: io::Write
+{
+    try!(wr.write_all(b"\""));
+
+    let mut start = 0;
+
+    for (i, byte) in bytes.iter().enumerate() {
+        let escaped = match *byte {
+            b'"' => b"\\\"",
+            b'\\' => b"\\\\",
+            b'\x08' => b"\\b",
+            b'\x0c' => b"\\f",
+            b'\n' => b"\\n",
+            b'\r' => b"\\r",
+            b'\t' => b"\\t",
+            _ => { continue; }
+        };
+
+        if start < i {
+            try!(wr.write_all(&bytes[start..i]));
+        }
+
+        try!(wr.write_all(escaped));
+
+        start = i + 1;
+    }
+
+    if start != bytes.len() {
+        try!(wr.write_all(&bytes[start..]));
+    }
+
+    try!(wr.write_all(b"\""));
+    Ok(())
+}
+
+#[inline]
+pub fn escape_str<W>(wr: &mut W, value: &str) -> io::Result<()>
+    where W: io::Write
+{
+    escape_bytes(wr, value.as_bytes())
+}
+
+#[inline]
+fn escape_char<W>(wr: &mut W, value: char) -> io::Result<()>
+    where W: io::Write
+{
+    // FIXME: this allocation is required in order to be compatible with stable
+    // rust, which doesn't support encoding a `char` into a stack buffer.
+    escape_bytes(wr, value.to_string().as_bytes())
+}
+
+fn fmt_f32_or_null<W>(wr: &mut W, value: f32) -> io::Result<()>
+    where W: io::Write
+{
+    match value.classify() {
+        FpCategory::Nan | FpCategory::Infinite => wr.write_all(b"null"),
+        _ => {
+            write!(wr, "{:?}", value)
+        }
+    }
+}
+
+fn fmt_f64_or_null<W>(wr: &mut W, value: f64) -> io::Result<()>
+    where W: io::Write
+{
+    match value.classify() {
+        FpCategory::Nan | FpCategory::Infinite => wr.write_all(b"null"),
+        _ => {
+            write!(wr, "{:?}", value)
+        }
+    }
+}
+
+/// Encode the specified struct into a json `[u8]` writer.
+#[inline]
+pub fn to_writer<W, T>(writer: &mut W, value: &T) -> io::Result<()>
+    where W: io::Write,
+          T: ser::Serialize,
+{
+    let mut ser = Serializer::new(writer);
+    try!(value.serialize(&mut ser));
+    Ok(())
+}
+
+/// Encode the specified struct into a json `[u8]` writer.
+#[inline]
+pub fn to_writer_pretty<W, T>(writer: &mut W, value: &T) -> io::Result<()>
+    where W: io::Write,
+          T: ser::Serialize,
+{
+    let mut ser = Serializer::pretty(writer);
+    try!(value.serialize(&mut ser));
+    Ok(())
+}
+
+/// Encode the specified struct into a json `[u8]` buffer.
+#[inline]
+pub fn to_vec<T>(value: &T) -> Vec<u8>
+    where T: ser::Serialize,
+{
+    // We are writing to a Vec, which doesn't fail. So we can ignore
+    // the error.
+    let mut writer = Vec::with_capacity(128);
+    to_writer(&mut writer, value).unwrap();
+    writer
+}
+
+/// Encode the specified struct into a json `[u8]` buffer.
+#[inline]
+pub fn to_vec_pretty<T>(value: &T) -> Vec<u8>
+    where T: ser::Serialize,
+{
+    // We are writing to a Vec, which doesn't fail. So we can ignore
+    // the error.
+    let mut writer = Vec::with_capacity(128);
+    to_writer_pretty(&mut writer, value).unwrap();
+    writer
+}
+
+/// Encode the specified struct into a json `String` buffer.
+#[inline]
+pub fn to_string<T>(value: &T) -> Result<String, FromUtf8Error>
+    where T: ser::Serialize
+{
+    let vec = to_vec(value);
+    String::from_utf8(vec)
+}
+
+/// Encode the specified struct into a json `String` buffer.
+#[inline]
+pub fn to_string_pretty<T>(value: &T) -> Result<String, FromUtf8Error>
+    where T: ser::Serialize
+{
+    let vec = to_vec_pretty(value);
+    String::from_utf8(vec)
+}
+
+fn indent<W>(wr: &mut W, n: usize, s: &[u8]) -> io::Result<()>
+    where W: io::Write,
+{
+    for _ in 0 .. n {
+        try!(wr.write_all(s));
+    }
+
+    Ok(())
+}

serde_json/src/value.rs

@@ -0,0 +1,951 @@
+use std::collections::{BTreeMap, btree_map};
+use std::fmt;
+use std::io;
+use std::str;
+use std::vec;
+
+use num::NumCast;
+
+use serde::de;
+use serde::ser;
+
+use error::Error;
+
+#[derive(Clone, PartialEq)]
+pub enum Value {
+    Null,
+    Bool(bool),
+    I64(i64),
+    U64(u64),
+    F64(f64),
+    String(String),
+    Array(Vec<Value>),
+    Object(BTreeMap<String, Value>),
+}
+
+impl Value {
+    /// If the `Value` is an Object, returns the value associated with the provided key.
+    /// Otherwise, returns None.
+    pub fn find<'a>(&'a self, key: &str) -> Option<&'a Value>{
+        match self {
+            &Value::Object(ref map) => map.get(key),
+            _ => None
+        }
+    }
+
+    /// Attempts to get a nested Value Object for each key in `keys`.
+    /// If any key is found not to exist, find_path will return None.
+    /// Otherwise, it will return the `Value` associated with the final key.
+    pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Value>{
+        let mut target = self;
+        for key in keys {
+            match target.find(key) {
+                Some(t) => { target = t; },
+                None => return None
+            }
+        }
+        Some(target)
+    }
+
+    /// Looks up a value by path.
+    ///
+    /// This is a convenience method that splits the path by `'.'`
+    /// and then feeds the sequence of keys into the `find_path`
+    /// method.
+    ///
+    /// ``` ignore
+    /// let obj: Value = json::from_str(r#"{"x": {"a": 1}}"#).unwrap();
+    ///
+    /// assert!(obj.lookup("x.a").unwrap() == &Value::U64(1));
+    /// ```
+    pub fn lookup<'a>(&'a self, path: &str) -> Option<&'a Value> {
+        let mut target = self;
+        for key in path.split('.') {
+            match target.find(key) {
+                Some(t) => { target = t; },
+                None => return None
+            }
+        }
+        Some(target)
+    }
+
+    /// If the `Value` is an Object, performs a depth-first search until
+    /// a value associated with the provided key is found. If no value is found
+    /// or the `Value` is not an Object, returns None.
+    pub fn search<'a>(&'a self, key: &str) -> Option<&'a Value> {
+        match self {
+            &Value::Object(ref map) => {
+                match map.get(key) {
+                    Some(json_value) => Some(json_value),
+                    None => {
+                        for (_, v) in map.iter() {
+                            match v.search(key) {
+                                x if x.is_some() => return x,
+                                _ => ()
+                            }
+                        }
+                        None
+                    }
+                }
+            },
+            _ => None
+        }
+    }
+
+    /// Returns true if the `Value` is an Object. Returns false otherwise.
+    pub fn is_object<'a>(&'a self) -> bool {
+        self.as_object().is_some()
+    }
+
+    /// If the `Value` is an Object, returns the associated BTreeMap.
+    /// Returns None otherwise.
+    pub fn as_object<'a>(&'a self) -> Option<&'a BTreeMap<String, Value>> {
+        match self {
+            &Value::Object(ref map) => Some(map),
+            _ => None
+        }
+    }
+
+    /// If the `Value` is an Object, returns the associated mutable BTreeMap.
+    /// Returns None otherwise.
+    pub fn as_object_mut<'a>(&'a mut self) -> Option<&'a mut BTreeMap<String, Value>> {
+        match self {
+            &mut Value::Object(ref mut map) => Some(map),
+            _ => None
+        }
+    }
+
+    /// Returns true if the `Value` is an Array. Returns false otherwise.
+    pub fn is_array<'a>(&'a self) -> bool {
+        self.as_array().is_some()
+    }
+
+    /// If the `Value` is an Array, returns the associated vector.
+    /// Returns None otherwise.
+    pub fn as_array<'a>(&'a self) -> Option<&'a Vec<Value>> {
+        match self {
+            &Value::Array(ref array) => Some(&*array),
+            _ => None
+        }
+    }
+
+    /// If the `Value` is an Array, returns the associated mutable vector.
+    /// Returns None otherwise.
+    pub fn as_array_mut<'a>(&'a mut self) -> Option<&'a mut Vec<Value>> {
+        match self {
+            &mut Value::Array(ref mut list) => Some(list),
+            _ => None
+        }
+    }
+
+    /// Returns true if the `Value` is a String. Returns false otherwise.
+    pub fn is_string<'a>(&'a self) -> bool {
+        self.as_string().is_some()
+    }
+
+    /// If the `Value` is a String, returns the associated str.
+    /// Returns None otherwise.
+    pub fn as_string<'a>(&'a self) -> Option<&'a str> {
+        match *self {
+            Value::String(ref s) => Some(&s),
+            _ => None
+        }
+    }
+
+    /// Returns true if the `Value` is a Number. Returns false otherwise.
+    pub fn is_number(&self) -> bool {
+        match *self {
+            Value::I64(_) | Value::U64(_) | Value::F64(_) => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if the `Value` is a i64. Returns false otherwise.
+    pub fn is_i64(&self) -> bool {
+        match *self {
+            Value::I64(_) => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if the `Value` is a u64. Returns false otherwise.
+    pub fn is_u64(&self) -> bool {
+        match *self {
+            Value::U64(_) => true,
+            _ => false,
+        }
+    }
+
+    /// Returns true if the `Value` is a f64. Returns false otherwise.
+    pub fn is_f64(&self) -> bool {
+        match *self {
+            Value::F64(_) => true,
+            _ => false,
+        }
+    }
+
+    /// If the `Value` is a number, return or cast it to a i64.
+    /// Returns None otherwise.
+    pub fn as_i64(&self) -> Option<i64> {
+        match *self {
+            Value::I64(n) => Some(n),
+            Value::U64(n) => NumCast::from(n),
+            _ => None
+        }
+    }
+
+    /// If the `Value` is a number, return or cast it to a u64.
+    /// Returns None otherwise.
+    pub fn as_u64(&self) -> Option<u64> {
+        match *self {
+            Value::I64(n) => NumCast::from(n),
+            Value::U64(n) => Some(n),
+            _ => None
+        }
+    }
+
+    /// If the `Value` is a number, return or cast it to a f64.
+    /// Returns None otherwise.
+    pub fn as_f64(&self) -> Option<f64> {
+        match *self {
+            Value::I64(n) => NumCast::from(n),
+            Value::U64(n) => NumCast::from(n),
+            Value::F64(n) => Some(n),
+            _ => None
+        }
+    }
+
+    /// Returns true if the `Value` is a Boolean. Returns false otherwise.
+    pub fn is_boolean(&self) -> bool {
+        self.as_boolean().is_some()
+    }
+
+    /// If the `Value` is a Boolean, returns the associated bool.
+    /// Returns None otherwise.
+    pub fn as_boolean(&self) -> Option<bool> {
+        match self {
+            &Value::Bool(b) => Some(b),
+            _ => None
+        }
+    }
+
+    /// Returns true if the `Value` is a Null. Returns false otherwise.
+    pub fn is_null(&self) -> bool {
+        self.as_null().is_some()
+    }
+
+    /// If the `Value` is a Null, returns ().
+    /// Returns None otherwise.
+    pub fn as_null(&self) -> Option<()> {
+        match self {
+            &Value::Null => Some(()),
+            _ => None
+        }
+    }
+}
+
+impl ser::Serialize for Value {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer,
+    {
+        match *self {
+            Value::Null => serializer.visit_unit(),
+            Value::Bool(v) => serializer.visit_bool(v),
+            Value::I64(v) => serializer.visit_i64(v),
+            Value::U64(v) => serializer.visit_u64(v),
+            Value::F64(v) => serializer.visit_f64(v),
+            Value::String(ref v) => serializer.visit_str(&v),
+            Value::Array(ref v) => v.serialize(serializer),
+            Value::Object(ref v) => v.serialize(serializer),
+        }
+    }
+}
+
+impl de::Deserialize for Value {
+    #[inline]
+    fn deserialize<D>(deserializer: &mut D) -> Result<Value, D::Error>
+        where D: de::Deserializer,
+    {
+        struct ValueVisitor;
+
+        impl de::Visitor for ValueVisitor {
+            type Value = Value;
+
+            #[inline]
+            fn visit_bool<E>(&mut self, value: bool) -> Result<Value, E> {
+                Ok(Value::Bool(value))
+            }
+
+            #[inline]
+            fn visit_i64<E>(&mut self, value: i64) -> Result<Value, E> {
+                if value < 0 {
+                    Ok(Value::I64(value))
+                } else {
+                    Ok(Value::U64(value as u64))
+                }
+            }
+
+            #[inline]
+            fn visit_u64<E>(&mut self, value: u64) -> Result<Value, E> {
+                Ok(Value::U64(value))
+            }
+
+            #[inline]
+            fn visit_f64<E>(&mut self, value: f64) -> Result<Value, E> {
+                Ok(Value::F64(value))
+            }
+
+            #[inline]
+            fn visit_str<E>(&mut self, value: &str) -> Result<Value, E>
+                where E: de::Error,
+            {
+                self.visit_string(value.to_string())
+            }
+
+            #[inline]
+            fn visit_string<E>(&mut self, value: String) -> Result<Value, E> {
+                Ok(Value::String(value))
+            }
+
+            #[inline]
+            fn visit_none<E>(&mut self) -> Result<Value, E> {
+                Ok(Value::Null)
+            }
+
+            #[inline]
+            fn visit_some<D>(&mut self, deserializer: &mut D) -> Result<Value, D::Error>
+                where D: de::Deserializer,
+            {
+                de::Deserialize::deserialize(deserializer)
+            }
+
+            #[inline]
+            fn visit_unit<E>(&mut self) -> Result<Value, E> {
+                Ok(Value::Null)
+            }
+
+            #[inline]
+            fn visit_seq<V>(&mut self, visitor: V) -> Result<Value, V::Error>
+                where V: de::SeqVisitor,
+            {
+                let values = try!(de::impls::VecVisitor::new().visit_seq(visitor));
+                Ok(Value::Array(values))
+            }
+
+            #[inline]
+            fn visit_map<V>(&mut self, visitor: V) -> Result<Value, V::Error>
+                where V: de::MapVisitor,
+            {
+                let values = try!(de::impls::BTreeMapVisitor::new().visit_map(visitor));
+                Ok(Value::Object(values))
+            }
+        }
+
+        deserializer.visit(ValueVisitor)
+    }
+}
+
+struct WriterFormatter<'a, 'b: 'a> {
+    inner: &'a mut fmt::Formatter<'b>,
+}
+
+impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        match self.inner.write_str(str::from_utf8(buf).unwrap()) {
+            Ok(_) => Ok(buf.len()),
+            Err(_) => Err(io::Error::last_os_error()),
+        }
+    }
+
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+impl fmt::Debug for Value {
+    /// Serializes a json value into a string
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let mut wr = WriterFormatter { inner: f };
+        super::ser::to_writer(&mut wr, self).map_err(|_| fmt::Error)
+    }
+}
+
+#[derive(Debug)]
+enum State {
+    Value(Value),
+    Array(Vec<Value>),
+    Object(BTreeMap<String, Value>),
+}
+
+pub struct Serializer {
+    state: Vec<State>,
+}
+
+impl Serializer {
+    pub fn new() -> Serializer {
+        Serializer {
+            state: Vec::with_capacity(4),
+        }
+    }
+
+    pub fn unwrap(mut self) -> Value {
+        match self.state.pop().unwrap() {
+            State::Value(value) => value,
+            state => panic!("expected value, found {:?}", state),
+        }
+    }
+}
+
+impl ser::Serializer for Serializer {
+    type Error = ();
+
+    #[inline]
+    fn visit_bool(&mut self, value: bool) -> Result<(), ()> {
+        self.state.push(State::Value(Value::Bool(value)));
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_i64(&mut self, value: i64) -> Result<(), ()> {
+        if value < 0 {
+            self.state.push(State::Value(Value::I64(value)));
+        } else {
+            self.state.push(State::Value(Value::U64(value as u64)));
+        }
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_u64(&mut self, value: u64) -> Result<(), ()> {
+        self.state.push(State::Value(Value::U64(value)));
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_f64(&mut self, value: f64) -> Result<(), ()> {
+        self.state.push(State::Value(Value::F64(value as f64)));
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_char(&mut self, value: char) -> Result<(), ()> {
+        self.state.push(State::Value(Value::String(value.to_string())));
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_str(&mut self, value: &str) -> Result<(), ()> {
+        self.state.push(State::Value(Value::String(value.to_string())));
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_none(&mut self) -> Result<(), ()> {
+        self.visit_unit()
+    }
+
+    #[inline]
+    fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
+        where V: ser::Serialize,
+    {
+        value.serialize(self)
+    }
+
+    #[inline]
+    fn visit_unit(&mut self) -> Result<(), ()> {
+        self.state.push(State::Value(Value::Null));
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_unit_variant(&mut self,
+                          _name: &str,
+                          _variant_index: usize,
+                          variant: &str) -> Result<(), ()> {
+        let mut values = BTreeMap::new();
+        values.insert(variant.to_string(), Value::Array(vec![]));
+
+        self.state.push(State::Value(Value::Object(values)));
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_newtype_variant<T>(&mut self,
+                                _name: &str,
+                                _variant_index: usize,
+                                variant: &str,
+                                value: T) -> Result<(), ()>
+        where T: ser::Serialize,
+    {
+        let mut values = BTreeMap::new();
+        values.insert(variant.to_string(), to_value(&value));
+
+        self.state.push(State::Value(Value::Object(values)));
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<(), ()>
+        where V: ser::SeqVisitor,
+    {
+        let len = visitor.len().unwrap_or(0);
+        let values = Vec::with_capacity(len);
+
+        self.state.push(State::Array(values));
+
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        let values = match self.state.pop().unwrap() {
+            State::Array(values) => values,
+            state => panic!("Expected array, found {:?}", state),
+        };
+
+        self.state.push(State::Value(Value::Array(values)));
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_tuple_variant<V>(&mut self,
+                              _name: &str,
+                              _variant_index: usize,
+                              variant: &str,
+                              visitor: V) -> Result<(), ()>
+        where V: ser::SeqVisitor,
+    {
+        try!(self.visit_seq(visitor));
+
+        let value = match self.state.pop().unwrap() {
+            State::Value(value) => value,
+            state => panic!("expected value, found {:?}", state),
+        };
+
+        let mut object = BTreeMap::new();
+
+        object.insert(variant.to_string(), value);
+
+        self.state.push(State::Value(Value::Object(object)));
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), ()>
+        where T: ser::Serialize,
+    {
+        try!(value.serialize(self));
+
+        let value = match self.state.pop().unwrap() {
+            State::Value(value) => value,
+            state => panic!("expected value, found {:?}", state),
+        };
+
+        match *self.state.last_mut().unwrap() {
+            State::Array(ref mut values) => { values.push(value); }
+            ref state => panic!("expected array, found {:?}", state),
+        }
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_map<V>(&mut self, mut visitor: V) -> Result<(), ()>
+        where V: ser::MapVisitor,
+    {
+        let values = BTreeMap::new();
+
+        self.state.push(State::Object(values));
+
+        while let Some(()) = try!(visitor.visit(self)) { }
+
+        let values = match self.state.pop().unwrap() {
+            State::Object(values) => values,
+            state => panic!("expected object, found {:?}", state),
+        };
+
+        self.state.push(State::Value(Value::Object(values)));
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_struct_variant<V>(&mut self,
+                               _name: &str,
+                               _variant_index: usize,
+                               variant: &str,
+                               visitor: V) -> Result<(), ()>
+        where V: ser::MapVisitor,
+    {
+        try!(self.visit_map(visitor));
+
+        let value = match self.state.pop().unwrap() {
+            State::Value(value) => value,
+            state => panic!("expected value, found {:?}", state),
+        };
+
+        let mut object = BTreeMap::new();
+
+        object.insert(variant.to_string(), value);
+
+        self.state.push(State::Value(Value::Object(object)));
+
+        Ok(())
+    }
+
+    #[inline]
+    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), ()>
+        where K: ser::Serialize,
+              V: ser::Serialize,
+    {
+        try!(key.serialize(self));
+
+        let key = match self.state.pop().unwrap() {
+            State::Value(Value::String(value)) => value,
+            state => panic!("expected key, found {:?}", state),
+        };
+
+        try!(value.serialize(self));
+
+        let value = match self.state.pop().unwrap() {
+            State::Value(value) => value,
+            state => panic!("expected value, found {:?}", state),
+        };
+
+        match *self.state.last_mut().unwrap() {
+            State::Object(ref mut values) => { values.insert(key, value); }
+            ref state => panic!("expected object, found {:?}", state),
+        }
+
+        Ok(())
+    }
+
+    #[inline]
+    fn format() -> &'static str {
+        "json"
+    }
+}
+
+pub struct Deserializer {
+    value: Option<Value>,
+}
+
+impl Deserializer {
+    /// Creates a new deserializer instance for deserializing the specified JSON value.
+    pub fn new(value: Value) -> Deserializer {
+        Deserializer {
+            value: Some(value),
+        }
+    }
+}
+
+impl de::Deserializer for Deserializer {
+    type Error = Error;
+
+    #[inline]
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        let value = match self.value.take() {
+            Some(value) => value,
+            None => { return Err(de::Error::end_of_stream()); }
+        };
+
+        match value {
+            Value::Null => visitor.visit_unit(),
+            Value::Bool(v) => visitor.visit_bool(v),
+            Value::I64(v) => visitor.visit_i64(v),
+            Value::U64(v) => visitor.visit_u64(v),
+            Value::F64(v) => visitor.visit_f64(v),
+            Value::String(v) => visitor.visit_string(v),
+            Value::Array(v) => {
+                let len = v.len();
+                visitor.visit_seq(SeqDeserializer {
+                    de: self,
+                    iter: v.into_iter(),
+                    len: len,
+                })
+            }
+            Value::Object(v) => {
+                let len = v.len();
+                visitor.visit_map(MapDeserializer {
+                    de: self,
+                    iter: v.into_iter(),
+                    value: None,
+                    len: len,
+                })
+            }
+        }
+    }
+
+    #[inline]
+    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.value {
+            Some(Value::Null) => visitor.visit_none(),
+            Some(_) => visitor.visit_some(self),
+            None => Err(de::Error::end_of_stream()),
+        }
+    }
+
+    #[inline]
+    fn visit_enum<V>(&mut self,
+                     _name: &str,
+                     _variants: &'static [&'static str],
+                     mut visitor: V) -> Result<V::Value, Error>
+        where V: de::EnumVisitor,
+    {
+        let value = match self.value.take() {
+            Some(Value::Object(value)) => value,
+            Some(_) => { return Err(de::Error::syntax("expected an enum")); }
+            None => { return Err(de::Error::end_of_stream()); }
+        };
+
+        let mut iter = value.into_iter();
+
+        let (variant, value) = match iter.next() {
+            Some(v) => v,
+            None => return Err(de::Error::syntax("expected a variant name")),
+        };
+
+        // enums are encoded in json as maps with a single key:value pair
+        match iter.next() {
+            Some(_) => Err(de::Error::syntax("expected map")),
+            None => visitor.visit(VariantDeserializer {
+                de: self,
+                val: Some(value),
+                variant: Some(Value::String(variant)),
+            }),
+        }
+    }
+
+    #[inline]
+    fn visit_newtype_struct<V>(&mut self,
+                               _name: &'static str,
+                               mut visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    #[inline]
+    fn format() -> &'static str {
+        "json"
+    }
+}
+
+struct VariantDeserializer<'a> {
+    de: &'a mut Deserializer,
+    val: Option<Value>,
+    variant: Option<Value>,
+}
+
+impl<'a> de::VariantVisitor for VariantDeserializer<'a> {
+    type Error = Error;
+
+    fn visit_variant<V>(&mut self) -> Result<V, Error>
+        where V: de::Deserialize,
+    {
+        de::Deserialize::deserialize(&mut Deserializer::new(self.variant.take().unwrap()))
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Error> {
+        de::Deserialize::deserialize(&mut Deserializer::new(self.val.take().unwrap()))
+    }
+
+    fn visit_newtype<T>(&mut self) -> Result<T, Error>
+        where T: de::Deserialize,
+    {
+        de::Deserialize::deserialize(&mut Deserializer::new(self.val.take().unwrap()))
+    }
+
+    fn visit_tuple<V>(&mut self,
+                      _len: usize,
+                      visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        if let Value::Array(fields) = self.val.take().unwrap() {
+            de::Deserializer::visit(
+                &mut SeqDeserializer {
+                    de: self.de,
+                    len: fields.len(),
+                    iter: fields.into_iter(),
+                },
+                visitor,
+            )
+        } else {
+            Err(de::Error::syntax("expected a tuple"))
+        }
+    }
+
+    fn visit_struct<V>(&mut self,
+                       _fields: &'static[&'static str],
+                       visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        if let Value::Object(fields) = self.val.take().unwrap() {
+            de::Deserializer::visit(
+                &mut MapDeserializer {
+                    de: self.de,
+                    len: fields.len(),
+                    iter: fields.into_iter(),
+                    value: None,
+                },
+                visitor,
+            )
+        } else {
+            Err(de::Error::syntax("expected a struct"))
+        }
+    }
+}
+
+struct SeqDeserializer<'a> {
+    de: &'a mut Deserializer,
+    iter: vec::IntoIter<Value>,
+    len: usize,
+}
+
+impl<'a> de::Deserializer for SeqDeserializer<'a> {
+    type Error = Error;
+
+    #[inline]
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        if self.len == 0 {
+            visitor.visit_unit()
+        } else {
+            visitor.visit_seq(self)
+        }
+    }
+}
+
+impl<'a> de::SeqVisitor for SeqDeserializer<'a> {
+    type Error = Error;
+
+    fn visit<T>(&mut self) -> Result<Option<T>, Error>
+        where T: de::Deserialize
+    {
+        match self.iter.next() {
+            Some(value) => {
+                self.len -= 1;
+                self.de.value = Some(value);
+                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        if self.len == 0 {
+            Ok(())
+        } else {
+            Err(de::Error::end_of_stream())
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len, Some(self.len))
+    }
+}
+
+struct MapDeserializer<'a> {
+    de: &'a mut Deserializer,
+    iter: btree_map::IntoIter<String, Value>,
+    value: Option<Value>,
+    len: usize,
+}
+
+impl<'a> de::MapVisitor for MapDeserializer<'a> {
+    type Error = Error;
+
+    fn visit_key<T>(&mut self) -> Result<Option<T>, Error>
+        where T: de::Deserialize
+    {
+        match self.iter.next() {
+            Some((key, value)) => {
+                self.len -= 1;
+                self.value = Some(value);
+                self.de.value = Some(Value::String(key));
+                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn visit_value<T>(&mut self) -> Result<T, Error>
+        where T: de::Deserialize
+    {
+        let value = self.value.take().unwrap();
+        self.de.value = Some(value);
+        Ok(try!(de::Deserialize::deserialize(self.de)))
+    }
+
+    fn end(&mut self) -> Result<(), Error> {
+        if self.len == 0 {
+            Ok(())
+        } else {
+            Err(de::Error::end_of_stream())
+        }
+    }
+
+    fn missing_field<V>(&mut self, _field: &'static str) -> Result<V, Error>
+        where V: de::Deserialize,
+    {
+        // See if the type can deserialize from a unit.
+        struct UnitDeserializer;
+
+        impl de::Deserializer for UnitDeserializer {
+            type Error = Error;
+
+            fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+                where V: de::Visitor,
+            {
+                visitor.visit_unit()
+            }
+
+            fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+                where V: de::Visitor,
+            {
+                visitor.visit_none()
+            }
+        }
+
+        Ok(try!(de::Deserialize::deserialize(&mut UnitDeserializer)))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (self.len, Some(self.len))
+    }
+}
+
+impl<'a> de::Deserializer for MapDeserializer<'a> {
+    type Error = Error;
+
+    #[inline]
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_map(self)
+    }
+}
+
+/// Shortcut function to encode a `T` into a JSON `Value`
+pub fn to_value<T>(value: &T) -> Value
+    where T: ser::Serialize
+{
+    let mut ser = Serializer::new();
+    value.serialize(&mut ser).ok().unwrap();
+    ser.unwrap()
+}
+
+/// Shortcut function to decode a JSON `Value` into a `T`
+pub fn from_value<T>(value: Value) -> Result<T, Error>
+    where T: de::Deserialize
+{
+    let mut de = Deserializer::new(value);
+    de::Deserialize::deserialize(&mut de)
+}

serde_macros/Cargo.toml

@@ -1,16 +1,20 @@
 [package]
 name = "serde_macros"
-version = "0.2.0"
+version = "0.5.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
-description = "A quasi-quoting macro system"
-repository = "https://github.com/erickt/rust-quasi"
+description = "Macros to auto-generate implementations for the serde framework"
+repository = "https://github.com/serde-rs/serde"
 
 [lib]
 name = "serde_macros"
 plugin = true
 
 [dependencies]
-quasi = "0.1.3"
-quasi_macros = "0.1.3"
-aster = "0.1.3"
+serde_codegen = { version = "*", path = "../serde_codegen", default-features = false, features = ["nightly"] }
+
+[dev-dependencies]
+num = "*"
+rustc-serialize = "*"
+serde = { version = "*", path = "../serde", features = ["nightly"] }
+serde_json = { version = "*", path = "../serde_json" }

serde_macros/benches/bench.rs

@@ -0,0 +1,10 @@
+#![feature(custom_attribute, custom_derive, plugin, test)]
+#![plugin(serde_macros)]
+
+extern crate num;
+extern crate rustc_serialize;
+extern crate serde;
+extern crate serde_json;
+extern crate test;
+
+include!("../../serde_tests/benches/bench.rs.in");

serde_macros/examples/json.rs

@@ -0,0 +1,66 @@
+#![feature(custom_derive, plugin)]
+#![plugin(serde_macros)]
+
+extern crate serde;
+extern crate serde_json;
+
+use std::collections::BTreeMap;
+
+// Creating serializable types with serde is quite simple with `serde_macros`. It implements a
+// syntax extension that automatically generates the necessary serde trait implementations.
+#[derive(Debug, Serialize, Deserialize)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn main() {
+    let point = Point { x: 5, y: 6 };
+
+    // Serializing to JSON is pretty simple by using the `to_string` method:
+    let serialized_point = serde_json::to_string(&point).unwrap();
+
+    println!("{}", serialized_point);
+    // prints:
+    //
+    // {"x":5,"y":6}
+
+    // There is also support for pretty printing using `to_string_pretty`:
+    let serialized_point = serde_json::to_string_pretty(&point).unwrap();
+
+    println!("{}", serialized_point);
+    // prints:
+    //
+    // {
+    //   "x":5,
+    //   "y":6
+    // }
+
+    // Values can also be deserialized with the same style using `from_str`:
+    let deserialized_point: Point = serde_json::from_str(&serialized_point).unwrap();
+
+    println!("{:?}", deserialized_point);
+    // prints:
+    //
+    // Point { x: 5, y: 6 }
+
+    // `Point`s aren't the only type that can be serialized to. Because `Point` members have the
+    // same type, they can be also serialized into a map. Also, 
+    let deserialized_map: BTreeMap<String, i64> =
+        serde_json::from_str(&serialized_point).unwrap();
+
+    println!("{:?}", deserialized_map);
+    // prints:
+    //
+    // {"x": 5, "y": 6}
+
+    // If you need to accept arbitrary data, you can also deserialize into `serde_json::Value`,
+    // which can represent all JSON values.
+    let deserialized_value: serde_json::Value =
+        serde_json::from_str(&serialized_point).unwrap();
+
+    println!("{:?}", deserialized_value);
+    // prints:
+    //
+    // {"x":5,"y":6}
+}

serde_macros/tests/test.rs

@@ -0,0 +1,8 @@
+#![feature(test, custom_attribute, custom_derive, plugin)]
+#![plugin(serde_macros)]
+
+extern crate serde;
+extern crate serde_json;
+extern crate test;
+
+include!("../../serde_tests/tests/test.rs.in");

serde_tests/Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "serde_tests"
+version = "0.5.0"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+license = "MIT/Apache-2.0"
+description = "A generic serialization/deserialization framework"
+repository = "https://github.com/serde-rs/serde"
+documentation = "http://serde-rs.github.io/serde/serde"
+readme = "README.md"
+keywords = ["serialization"]
+build = "build.rs"
+
+[build-dependencies]
+syntex = { version = "*" }
+syntex_syntax = { version = "*" }
+serde_codegen = { version = "*", path = "../serde_codegen", features = ["with-syntex"] }
+
+[dev-dependencies]
+num = "*"
+rustc-serialize = "*"
+serde = { version = "*", path = "../serde" }
+serde_json = { version = "*", path = "../serde_json" }
+syntex = "*"
+
+[[test]]
+name = "test"
+path = "tests/test.rs"
+
+[[bench]]
+name = "bench"
+path = "benches/bench.rs"

serde_tests/benches/bench.rs

@@ -0,0 +1,9 @@
+#![feature(test)]
+
+extern crate num;
+extern crate rustc_serialize;
+extern crate serde;
+extern crate serde_json;
+extern crate test;
+
+include!(concat!(env!("OUT_DIR"), "/bench.rs"));

serde_tests/benches/bench.rs.in

@@ -0,0 +1,5 @@
+mod bench_enum;
+mod bench_log;
+mod bench_map;
+mod bench_struct;
+mod bench_vec;

serde_tests/benches/bench_enum.rs

@@ -1,23 +1,12 @@
-#![feature(custom_derive, plugin, test)]
-#![plugin(serde_macros)]
-
-extern crate serde;
-extern crate "rustc-serialize" as rustc_serialize;
-extern crate test;
-
 use test::Bencher;
-
 use rustc_serialize::{Decoder, Decodable};
-
+use serde;
 use serde::de::{Deserializer, Deserialize};
 
-use Animal::{Dog, Frog};
-
 //////////////////////////////////////////////////////////////////////////////
 
-#[derive(Clone, PartialEq, Debug, RustcDecodable)]
-#[derive_deserialize]
-enum Animal {
+#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)]
+pub enum Animal {
     Dog,
     Frog(String, isize)
 }
@@ -31,11 +20,13 @@ pub enum Error {
 }
 
 impl serde::de::Error for Error {
-    fn syntax_error() -> Error { Error::SyntaxError }
+    fn syntax(_: &str) -> Error { Error::SyntaxError }
 
-    fn end_of_stream_error() -> Error { Error::EndOfStreamError }
+    fn end_of_stream() -> Error { Error::EndOfStreamError }
 
-    fn missing_field_error(_: &'static str) -> Error { Error::SyntaxError }
+    fn unknown_field(_: &str) -> Error { Error::SyntaxError }
+
+    fn missing_field(_: &'static str) -> Error { Error::SyntaxError }
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -245,9 +236,11 @@ mod deserializer {
 
     use serde::de;
 
+    #[derive(Debug)]
     enum State {
         AnimalState(Animal),
         IsizeState(isize),
+        StrState(&'static str),
         StringState(String),
         UnitState,
     }
@@ -273,29 +266,54 @@ mod deserializer {
             where V: de::Visitor,
         {
             match self.stack.pop() {
-                Some(State::AnimalState(Animal::Dog)) => {
-                    self.stack.push(State::UnitState);
-                    visitor.visit_enum("Animal", "Dog", DogVisitor {
-                        de: self,
-                    })
-                }
-                Some(State::AnimalState(Animal::Frog(x0, x1))) => {
-                    self.stack.push(State::IsizeState(x1));
-                    self.stack.push(State::StringState(x0));
-                    visitor.visit_enum("Animal", "Frog", FrogVisitor {
-                        de: self,
-                        state: 0,
-                    })
-                }
                 Some(State::IsizeState(value)) => {
                     visitor.visit_isize(value)
                 }
                 Some(State::StringState(value)) => {
                     visitor.visit_string(value)
                 }
+                Some(State::StrState(value)) => {
+                    visitor.visit_str(value)
+                }
                 Some(State::UnitState) => {
                     visitor.visit_unit()
                 }
+                Some(_) => {
+                    Err(Error::SyntaxError)
+                }
+                None => {
+                    Err(Error::EndOfStreamError)
+                }
+            }
+        }
+
+        #[inline]
+        fn visit_enum<V>(&mut self,
+                         _name: &str,
+                         _variants: &[&str],
+                         mut visitor: V) -> Result<V::Value, Error>
+            where V: de::EnumVisitor,
+        {
+            match self.stack.pop() {
+                Some(State::AnimalState(Animal::Dog)) => {
+                    self.stack.push(State::UnitState);
+                    self.stack.push(State::StrState("Dog"));
+                    visitor.visit(DogVisitor {
+                        de: self,
+                    })
+                }
+                Some(State::AnimalState(Animal::Frog(x0, x1))) => {
+                    self.stack.push(State::IsizeState(x1));
+                    self.stack.push(State::StringState(x0));
+                    self.stack.push(State::StrState("Frog"));
+                    visitor.visit(FrogVisitor {
+                        de: self,
+                        state: 0,
+                    })
+                }
+                Some(_) => {
+                    Err(Error::SyntaxError)
+                }
                 None => {
                     Err(Error::EndOfStreamError)
                 }
@@ -307,9 +325,15 @@ mod deserializer {
         de: &'a mut AnimalDeserializer,
     }
 
-    impl<'a> de::EnumVisitor for DogVisitor<'a> {
+    impl<'a> de::VariantVisitor for DogVisitor<'a> {
         type Error = Error;
 
+        fn visit_variant<V>(&mut self) -> Result<V, Error>
+            where V: de::Deserialize
+        {
+            de::Deserialize::deserialize(self.de)
+        }
+
         fn visit_unit(&mut self) -> Result<(), Error> {
             de::Deserialize::deserialize(self.de)
         }
@@ -320,13 +344,21 @@ mod deserializer {
         state: usize,
     }
 
-    impl<'a> de::EnumVisitor for FrogVisitor<'a> {
+    impl<'a> de::VariantVisitor for FrogVisitor<'a> {
         type Error = Error;
 
-        fn visit_seq<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-            where V: de::EnumSeqVisitor,
+        fn visit_variant<V>(&mut self) -> Result<V, Error>
+            where V: de::Deserialize
         {
-            visitor.visit(self)
+            de::Deserialize::deserialize(self.de)
+        }
+
+        fn visit_tuple<V>(&mut self,
+                          _len: usize,
+                          mut visitor: V) -> Result<V::Value, Error>
+            where V: de::Visitor,
+        {
+            visitor.visit_seq(self)
         }
     }
 
@@ -371,7 +403,7 @@ mod deserializer {
 #[bench]
 fn bench_decoder_dog(b: &mut Bencher) {
     b.iter(|| {
-        let animal = Dog;
+        let animal = Animal::Dog;
 
         let mut d = decoder::AnimalDecoder::new(animal.clone());
         let value: Animal = Decodable::decode(&mut d).unwrap();
@@ -383,7 +415,7 @@ fn bench_decoder_dog(b: &mut Bencher) {
 #[bench]
 fn bench_decoder_frog(b: &mut Bencher) {
     b.iter(|| {
-        let animal = Frog("Henry".to_string(), 349);
+        let animal = Animal::Frog("Henry".to_string(), 349);
 
         let mut d = decoder::AnimalDecoder::new(animal.clone());
         let value: Animal = Decodable::decode(&mut d).unwrap();
@@ -395,7 +427,7 @@ fn bench_decoder_frog(b: &mut Bencher) {
 #[bench]
 fn bench_deserializer_dog(b: &mut Bencher) {
     b.iter(|| {
-        let animal = Dog;
+        let animal = Animal::Dog;
 
         let mut d = deserializer::AnimalDeserializer::new(animal.clone());
         let value: Animal = Deserialize::deserialize(&mut d).unwrap();
@@ -407,7 +439,7 @@ fn bench_deserializer_dog(b: &mut Bencher) {
 #[bench]
 fn bench_deserializer_frog(b: &mut Bencher) {
     b.iter(|| {
-        let animal = Frog("Henry".to_string(), 349);
+        let animal = Animal::Frog("Henry".to_string(), 349);
 
         let mut d = deserializer::AnimalDeserializer::new(animal.clone());
         let value: Animal = Deserialize::deserialize(&mut d).unwrap();

serde_tests/benches/bench_log.rs

@@ -1,25 +1,18 @@
-#![feature(custom_derive, collections, core, io, plugin, test)]
-#![allow(non_camel_case_types)]
-#![plugin(serde_macros)]
-
-extern crate serde;
-extern crate "rustc-serialize" as rustc_serialize;
-extern crate test;
-
-use std::io::{self, ReadExt, WriteExt};
-use std::num::FromPrimitive;
+use std::io::{self, Read, Write};
+use num::FromPrimitive;
 use test::Bencher;
 
+use rustc_serialize;
+
 use serde::de::{self, Deserialize, Deserializer};
-use serde::json::ser::escape_str;
-use serde::json;
 use serde::ser::{self, Serialize, Serializer};
+use serde_json::ser::escape_str;
+use serde_json;
+use std::str::FromStr;
 
 use rustc_serialize::Encodable;
 
-#[derive(Debug, PartialEq, RustcEncodable, RustcDecodable)]
-#[derive_serialize]
-#[derive_deserialize]
+#[derive(Debug, PartialEq, RustcEncodable, RustcDecodable, Serialize, Deserialize)]
 struct Http {
     protocol: HttpProtocol,
     status: u32,
@@ -32,7 +25,8 @@ struct Http {
     request_uri: String,
 }
 
-#[derive(Copy, Debug, PartialEq, FromPrimitive)]
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 enum HttpProtocol {
     HTTP_PROTOCOL_UNKNOWN,
     HTTP10,
@@ -54,12 +48,32 @@ impl rustc_serialize::Decodable for HttpProtocol {
     }
 }
 
+impl FromStr for HttpProtocol {
+    type Err = ();
+    fn from_str(_s: &str) -> Result<HttpProtocol, ()> { unimplemented!() }
+}
+
+impl FromPrimitive for HttpProtocol {
+    fn from_i64(i: i64) -> Option<HttpProtocol> {
+        FromPrimitive::from_u64(i as u64)
+    }
+
+    fn from_u64(n: u64) -> Option<HttpProtocol> {
+        match n {
+            0 => Some(HttpProtocol::HTTP_PROTOCOL_UNKNOWN),
+            1 => Some(HttpProtocol::HTTP10),
+            2 => Some(HttpProtocol::HTTP11),
+            _ => None,
+        }
+    }
+}
+
 impl ser::Serialize for HttpProtocol {
     #[inline]
-    fn visit<
-        V: ser::Visitor,
-    >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
-        visitor.visit_u8(*self as u8)
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer,
+    {
+        serializer.visit_u8(*self as u8)
     }
 }
 
@@ -68,11 +82,12 @@ impl de::Deserialize for HttpProtocol {
     fn deserialize<
         S: Deserializer,
     >(state: &mut S) -> Result<HttpProtocol, S::Error> {
-        state.visit(de::PrimitiveVisitor::new())
+        state.visit(de::impls::PrimitiveVisitor::new())
     }
 }
 
-#[derive(Copy, Debug, PartialEq, FromPrimitive)]
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 enum HttpMethod {
     METHOD_UNKNOWN,
     GET,
@@ -87,6 +102,34 @@ enum HttpMethod {
     PATCH,
 }
 
+impl FromStr for HttpMethod {
+    type Err = ();
+    fn from_str(_s: &str) -> Result<HttpMethod, ()> { unimplemented!() }
+}
+
+impl FromPrimitive for HttpMethod {
+    fn from_i64(i: i64) -> Option<HttpMethod> {
+        FromPrimitive::from_u64(i as u64)
+    }
+
+    fn from_u64(n: u64) -> Option<HttpMethod> {
+        match n {
+            0 => Some(HttpMethod::METHOD_UNKNOWN),
+            1 => Some(HttpMethod::GET),
+            2 => Some(HttpMethod::POST),
+            3 => Some(HttpMethod::DELETE),
+            4 => Some(HttpMethod::PUT),
+            5 => Some(HttpMethod::HEAD),
+            6 => Some(HttpMethod::PURGE),
+            7 => Some(HttpMethod::OPTIONS),
+            8 => Some(HttpMethod::PROPFIND),
+            9 => Some(HttpMethod::MKCOL),
+            10 => Some(HttpMethod::PATCH),
+            _ => None,
+        }
+    }
+}
+
 impl rustc_serialize::Encodable for HttpMethod {
     fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         (*self as usize).encode(s)
@@ -104,10 +147,10 @@ impl rustc_serialize::Decodable for HttpMethod {
 
 impl ser::Serialize for HttpMethod {
     #[inline]
-    fn visit<
-        V: ser::Visitor,
-    >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
-        visitor.visit_u8(*self as u8)
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer,
+    {
+        serializer.visit_u8(*self as u8)
     }
 }
 
@@ -116,11 +159,12 @@ impl de::Deserialize for HttpMethod {
     fn deserialize<
         S: de::Deserializer,
     >(state: &mut S) -> Result<HttpMethod, S::Error> {
-        state.visit(de::PrimitiveVisitor::new())
+        state.visit(de::impls::PrimitiveVisitor::new())
     }
 }
 
-#[derive(Copy, Debug, PartialEq, FromPrimitive)]
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 enum CacheStatus {
     CACHESTATUS_UNKNOWN,
     Miss,
@@ -128,6 +172,27 @@ enum CacheStatus {
     Hit,
 }
 
+impl FromStr for CacheStatus {
+    type Err = ();
+    fn from_str(_s: &str) -> Result<CacheStatus, ()> { unimplemented!() }
+}
+
+impl FromPrimitive for CacheStatus {
+    fn from_i64(i: i64) -> Option<CacheStatus> {
+        FromPrimitive::from_u64(i as u64)
+    }
+
+    fn from_u64(n: u64) -> Option<CacheStatus> {
+        match n {
+            0 => Some(CacheStatus::CACHESTATUS_UNKNOWN),
+            1 => Some(CacheStatus::Miss),
+            2 => Some(CacheStatus::Expired),
+            3 => Some(CacheStatus::Hit),
+            _ => None,
+        }
+    }
+}
+
 impl rustc_serialize::Encodable for CacheStatus {
     fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         (*self as u8).encode(s)
@@ -145,10 +210,10 @@ impl rustc_serialize::Decodable for CacheStatus {
 
 impl ser::Serialize for CacheStatus {
     #[inline]
-    fn visit<
-        V: ser::Visitor,
-    >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
-        visitor.visit_u8(*self as u8)
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer,
+    {
+        serializer.visit_u8(*self as u8)
     }
 }
 
@@ -157,13 +222,11 @@ impl de::Deserialize for CacheStatus {
     fn deserialize<
         S: de::Deserializer,
     >(state: &mut S) -> Result<CacheStatus, S::Error> {
-        state.visit(de::PrimitiveVisitor::new())
+        state.visit(de::impls::PrimitiveVisitor::new())
     }
 }
 
-#[derive(Debug, PartialEq, RustcEncodable, RustcDecodable)]
-#[derive_serialize]
-#[derive_deserialize]
+#[derive(Debug, PartialEq, RustcEncodable, RustcDecodable, Serialize, Deserialize)]
 struct Origin {
     ip: String,
     port: u32,
@@ -171,13 +234,34 @@ struct Origin {
     protocol: OriginProtocol,
 }
 
-#[derive(Copy, Debug, PartialEq, FromPrimitive)]
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 enum OriginProtocol {
     ORIGIN_PROTOCOL_UNKNOWN,
     HTTP,
     HTTPS,
 }
 
+impl FromStr for OriginProtocol {
+    type Err = ();
+    fn from_str(_s: &str) -> Result<OriginProtocol, ()> { unimplemented!() }
+}
+
+impl FromPrimitive for OriginProtocol {
+    fn from_i64(i: i64) -> Option<OriginProtocol> {
+        FromPrimitive::from_u64(i as u64)
+    }
+
+    fn from_u64(n: u64) -> Option<OriginProtocol> {
+        match n {
+            0 => Some(OriginProtocol::ORIGIN_PROTOCOL_UNKNOWN),
+            1 => Some(OriginProtocol::HTTP),
+            2 => Some(OriginProtocol::HTTPS),
+            _ => None,
+        }
+    }
+}
+
 impl rustc_serialize::Encodable for OriginProtocol {
     fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         (*self as u8).encode(s)
@@ -195,10 +279,10 @@ impl rustc_serialize::Decodable for OriginProtocol {
 
 impl ser::Serialize for OriginProtocol {
     #[inline]
-    fn visit<
-        V: ser::Visitor,
-    >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
-        visitor.visit_u8(*self as u8)
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer,
+    {
+        serializer.visit_u8(*self as u8)
     }
 }
 
@@ -207,11 +291,12 @@ impl de::Deserialize for OriginProtocol {
     fn deserialize<
         S: de::Deserializer,
     >(state: &mut S) -> Result<OriginProtocol, S::Error> {
-        state.visit(de::PrimitiveVisitor::new())
+        state.visit(de::impls::PrimitiveVisitor::new())
     }
 }
 
-#[derive(Copy, Debug, PartialEq, FromPrimitive)]
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 enum ZonePlan {
     ZONEPLAN_UNKNOWN,
     FREE,
@@ -220,6 +305,28 @@ enum ZonePlan {
     ENT,
 }
 
+impl FromStr for ZonePlan {
+    type Err = ();
+    fn from_str(_s: &str) -> Result<ZonePlan, ()> { unimplemented!() }
+}
+
+impl FromPrimitive for ZonePlan {
+    fn from_i64(i: i64) -> Option<ZonePlan> {
+        FromPrimitive::from_u64(i as u64)
+    }
+
+    fn from_u64(n: u64) -> Option<ZonePlan> {
+        match n {
+            0 => Some(ZonePlan::ZONEPLAN_UNKNOWN),
+            1 => Some(ZonePlan::FREE),
+            2 => Some(ZonePlan::PRO),
+            3 => Some(ZonePlan::BIZ),
+            4 => Some(ZonePlan::ENT),
+            _ => None,
+        }
+    }
+}
+
 impl rustc_serialize::Encodable for ZonePlan {
     fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         (*self as u8).encode(s)
@@ -237,10 +344,10 @@ impl rustc_serialize::Decodable for ZonePlan {
 
 impl ser::Serialize for ZonePlan {
     #[inline]
-    fn visit<
-        V: ser::Visitor,
-    >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
-        visitor.visit_u8(*self as u8)
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer,
+    {
+        serializer.visit_u8(*self as u8)
     }
 }
 
@@ -249,11 +356,11 @@ impl de::Deserialize for ZonePlan {
     fn deserialize<
         S: de::Deserializer,
     >(state: &mut S) -> Result<ZonePlan, S::Error> {
-        state.visit(de::PrimitiveVisitor::new())
+        state.visit(de::impls::PrimitiveVisitor::new())
     }
 }
 
-#[derive(Copy, Debug, PartialEq, FromPrimitive)]
+#[derive(Copy, Clone, Debug, PartialEq)]
 enum Country {
 	UNKNOWN,
 	A1,
@@ -513,6 +620,279 @@ enum Country {
 	ZW,
 }
 
+impl FromStr for Country {
+    type Err = ();
+    fn from_str(_s: &str) -> Result<Country, ()> { unimplemented!() }
+}
+
+impl FromPrimitive for Country {
+    fn from_i64(i: i64) -> Option<Country> {
+        FromPrimitive::from_u64(i as u64)
+    }
+
+    fn from_u64(n: u64) -> Option<Country> {
+        match n {
+            0 => Some(Country::UNKNOWN),
+            1 => Some(Country::A1),
+            2 => Some(Country::A2),
+            3 => Some(Country::O1),
+            4 => Some(Country::AD),
+            5 => Some(Country::AE),
+            6 => Some(Country::AF),
+            7 => Some(Country::AG),
+            8 => Some(Country::AI),
+            9 => Some(Country::AL),
+            10 => Some(Country::AM),
+            11 => Some(Country::AO),
+            12 => Some(Country::AP),
+            13 => Some(Country::AQ),
+            14 => Some(Country::AR),
+            15 => Some(Country::AS),
+            16 => Some(Country::AT),
+            17 => Some(Country::AU),
+            18 => Some(Country::AW),
+            19 => Some(Country::AX),
+            20 => Some(Country::AZ),
+            21 => Some(Country::BA),
+            22 => Some(Country::BB),
+            23 => Some(Country::BD),
+            24 => Some(Country::BE),
+            25 => Some(Country::BF),
+            26 => Some(Country::BG),
+            27 => Some(Country::BH),
+            28 => Some(Country::BI),
+            29 => Some(Country::BJ),
+            30 => Some(Country::BL),
+            31 => Some(Country::BM),
+            32 => Some(Country::BN),
+            33 => Some(Country::BO),
+            34 => Some(Country::BQ),
+            35 => Some(Country::BR),
+            36 => Some(Country::BS),
+            37 => Some(Country::BT),
+            38 => Some(Country::BV),
+            39 => Some(Country::BW),
+            40 => Some(Country::BY),
+            41 => Some(Country::BZ),
+            42 => Some(Country::CA),
+            43 => Some(Country::CC),
+            44 => Some(Country::CD),
+            45 => Some(Country::CF),
+            46 => Some(Country::CG),
+            47 => Some(Country::CH),
+            48 => Some(Country::CI),
+            49 => Some(Country::CK),
+            50 => Some(Country::CL),
+            51 => Some(Country::CM),
+            52 => Some(Country::CN),
+            53 => Some(Country::CO),
+            54 => Some(Country::CR),
+            55 => Some(Country::CU),
+            56 => Some(Country::CV),
+            57 => Some(Country::CW),
+            58 => Some(Country::CX),
+            59 => Some(Country::CY),
+            60 => Some(Country::CZ),
+            61 => Some(Country::DE),
+            62 => Some(Country::DJ),
+            63 => Some(Country::DK),
+            64 => Some(Country::DM),
+            65 => Some(Country::DO),
+            66 => Some(Country::DZ),
+            67 => Some(Country::EC),
+            68 => Some(Country::EE),
+            69 => Some(Country::EG),
+            70 => Some(Country::EH),
+            71 => Some(Country::ER),
+            72 => Some(Country::ES),
+            73 => Some(Country::ET),
+            74 => Some(Country::EU),
+            75 => Some(Country::FI),
+            76 => Some(Country::FJ),
+            77 => Some(Country::FK),
+            78 => Some(Country::FM),
+            79 => Some(Country::FO),
+            80 => Some(Country::FR),
+            81 => Some(Country::GA),
+            82 => Some(Country::GB),
+            83 => Some(Country::GD),
+            84 => Some(Country::GE),
+            85 => Some(Country::GF),
+            86 => Some(Country::GG),
+            87 => Some(Country::GH),
+            88 => Some(Country::GI),
+            89 => Some(Country::GL),
+            90 => Some(Country::GM),
+            91 => Some(Country::GN),
+            92 => Some(Country::GP),
+            93 => Some(Country::GQ),
+            94 => Some(Country::GR),
+            95 => Some(Country::GS),
+            96 => Some(Country::GT),
+            97 => Some(Country::GU),
+            98 => Some(Country::GW),
+            99 => Some(Country::GY),
+            100 => Some(Country::HK),
+            101 => Some(Country::HM),
+            102 => Some(Country::HN),
+            103 => Some(Country::HR),
+            104 => Some(Country::HT),
+            105 => Some(Country::HU),
+            106 => Some(Country::ID),
+            107 => Some(Country::IE),
+            108 => Some(Country::IL),
+            109 => Some(Country::IM),
+            110 => Some(Country::IN),
+            111 => Some(Country::IO),
+            112 => Some(Country::IQ),
+            113 => Some(Country::IR),
+            114 => Some(Country::IS),
+            115 => Some(Country::IT),
+            116 => Some(Country::JE),
+            117 => Some(Country::JM),
+            118 => Some(Country::JO),
+            119 => Some(Country::JP),
+            120 => Some(Country::KE),
+            121 => Some(Country::KG),
+            122 => Some(Country::KH),
+            123 => Some(Country::KI),
+            124 => Some(Country::KM),
+            125 => Some(Country::KN),
+            126 => Some(Country::KP),
+            127 => Some(Country::KR),
+            128 => Some(Country::KW),
+            129 => Some(Country::KY),
+            130 => Some(Country::KZ),
+            131 => Some(Country::LA),
+            132 => Some(Country::LB),
+            133 => Some(Country::LC),
+            134 => Some(Country::LI),
+            135 => Some(Country::LK),
+            136 => Some(Country::LR),
+            137 => Some(Country::LS),
+            138 => Some(Country::LT),
+            139 => Some(Country::LU),
+            140 => Some(Country::LV),
+            141 => Some(Country::LY),
+            142 => Some(Country::MA),
+            143 => Some(Country::MC),
+            144 => Some(Country::MD),
+            145 => Some(Country::ME),
+            146 => Some(Country::MF),
+            147 => Some(Country::MG),
+            148 => Some(Country::MH),
+            149 => Some(Country::MK),
+            150 => Some(Country::ML),
+            151 => Some(Country::MM),
+            152 => Some(Country::MN),
+            153 => Some(Country::MO),
+            154 => Some(Country::MP),
+            155 => Some(Country::MQ),
+            156 => Some(Country::MR),
+            157 => Some(Country::MS),
+            158 => Some(Country::MT),
+            159 => Some(Country::MU),
+            160 => Some(Country::MV),
+            161 => Some(Country::MW),
+            162 => Some(Country::MX),
+            163 => Some(Country::MY),
+            164 => Some(Country::MZ),
+            165 => Some(Country::NA),
+            166 => Some(Country::NC),
+            167 => Some(Country::NE),
+            168 => Some(Country::NF),
+            169 => Some(Country::NG),
+            170 => Some(Country::NI),
+            171 => Some(Country::NL),
+            172 => Some(Country::NO),
+            173 => Some(Country::NP),
+            174 => Some(Country::NR),
+            175 => Some(Country::NU),
+            176 => Some(Country::NZ),
+            177 => Some(Country::OM),
+            178 => Some(Country::PA),
+            179 => Some(Country::PE),
+            180 => Some(Country::PF),
+            181 => Some(Country::PG),
+            182 => Some(Country::PH),
+            183 => Some(Country::PK),
+            184 => Some(Country::PL),
+            185 => Some(Country::PM),
+            186 => Some(Country::PN),
+            187 => Some(Country::PR),
+            188 => Some(Country::PS),
+            189 => Some(Country::PT),
+            190 => Some(Country::PW),
+            191 => Some(Country::PY),
+            192 => Some(Country::QA),
+            193 => Some(Country::RE),
+            194 => Some(Country::RO),
+            195 => Some(Country::RS),
+            196 => Some(Country::RU),
+            197 => Some(Country::RW),
+            198 => Some(Country::SA),
+            199 => Some(Country::SB),
+            200 => Some(Country::SC),
+            201 => Some(Country::SD),
+            202 => Some(Country::SE),
+            203 => Some(Country::SG),
+            204 => Some(Country::SH),
+            205 => Some(Country::SI),
+            206 => Some(Country::SJ),
+            207 => Some(Country::SK),
+            208 => Some(Country::SL),
+            209 => Some(Country::SM),
+            210 => Some(Country::SN),
+            211 => Some(Country::SO),
+            212 => Some(Country::SR),
+            213 => Some(Country::SS),
+            214 => Some(Country::ST),
+            215 => Some(Country::SV),
+            216 => Some(Country::SX),
+            217 => Some(Country::SY),
+            218 => Some(Country::SZ),
+            219 => Some(Country::TC),
+            220 => Some(Country::TD),
+            221 => Some(Country::TF),
+            222 => Some(Country::TG),
+            223 => Some(Country::TH),
+            224 => Some(Country::TJ),
+            225 => Some(Country::TK),
+            226 => Some(Country::TL),
+            227 => Some(Country::TM),
+            228 => Some(Country::TN),
+            229 => Some(Country::TO),
+            230 => Some(Country::TR),
+            231 => Some(Country::TT),
+            232 => Some(Country::TV),
+            233 => Some(Country::TW),
+            234 => Some(Country::TZ),
+            235 => Some(Country::UA),
+            236 => Some(Country::UG),
+            237 => Some(Country::UM),
+            238 => Some(Country::US),
+            239 => Some(Country::UY),
+            240 => Some(Country::UZ),
+            241 => Some(Country::VA),
+            242 => Some(Country::VC),
+            243 => Some(Country::VE),
+            244 => Some(Country::VG),
+            245 => Some(Country::VI),
+            246 => Some(Country::VN),
+            247 => Some(Country::VU),
+            248 => Some(Country::WF),
+            249 => Some(Country::WS),
+            250 => Some(Country::XX),
+            251 => Some(Country::YE),
+            252 => Some(Country::YT),
+            253 => Some(Country::ZA),
+            254 => Some(Country::ZM),
+            255 => Some(Country::ZW),
+            _ => None,
+        }
+    }
+}
+
 impl rustc_serialize::Encodable for Country {
     fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         (*self as u8).encode(s)
@@ -530,10 +910,10 @@ impl rustc_serialize::Decodable for Country {
 
 impl ser::Serialize for Country {
     #[inline]
-    fn visit<
-        V: ser::Visitor,
-    >(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
-        visitor.visit_u8(*self as u8)
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer,
+    {
+        serializer.visit_u8(*self as u8)
     }
 }
 
@@ -542,13 +922,11 @@ impl de::Deserialize for Country {
     fn deserialize<
         S: de::Deserializer,
     >(state: &mut S) -> Result<Country, S::Error> {
-        state.visit(de::PrimitiveVisitor::new())
+        state.visit(de::impls::PrimitiveVisitor::new())
     }
 }
 
-#[derive(Debug, PartialEq, RustcEncodable, RustcDecodable)]
-#[derive_serialize]
-#[derive_deserialize]
+#[derive(Debug, PartialEq, RustcEncodable, RustcDecodable, Serialize, Deserialize)]
 struct Log {
     timestamp: i64,
     zone_id: u32,
@@ -637,13 +1015,21 @@ impl MyMemWriter0 {
 }
 
 
-impl io::Write for MyMemWriter0 {
+impl Write for MyMemWriter0 {
+    #[cfg(feature = "nightly")]
     #[inline]
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.buf.push_all(buf);
         Ok(buf.len())
     }
 
+    #[cfg(not(feature = "nightly"))]
+    #[inline]
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.buf.extend(buf.iter().cloned());
+        Ok(buf.len())
+    }
+
     #[inline]
     fn flush(&mut self) -> io::Result<()> {
         Ok(())
@@ -676,13 +1062,13 @@ fn push_all_bytes(dst: &mut Vec<u8>, src: &[u8]) {
         dst.set_len(dst_len + src_len);
 
         ::std::ptr::copy_nonoverlapping(
-            dst.as_mut_ptr().offset(dst_len as isize),
             src.as_ptr(),
+            dst.as_mut_ptr().offset(dst_len as isize),
             src_len);
     }
 }
 
-impl io::Write for MyMemWriter1 {
+impl Write for MyMemWriter1 {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         push_all_bytes(&mut self.buf, buf);
@@ -737,18 +1123,18 @@ fn bench_encoder(b: &mut Bencher) {
 #[test]
 fn test_serializer() {
     let log = Log::new();
-    let json = json::to_vec(&log);
+    let json = serde_json::to_vec(&log);
     assert_eq!(json, JSON_STR.as_bytes());
 }
 
 #[bench]
 fn bench_serializer(b: &mut Bencher) {
     let log = Log::new();
-    let json = json::to_vec(&log);
+    let json = serde_json::to_vec(&log);
     b.bytes = json.len() as u64;
 
     b.iter(|| {
-        let _ = json::to_vec(&log);
+        let _ = serde_json::to_vec(&log);
     });
 }
 
@@ -756,8 +1142,8 @@ fn bench_serializer(b: &mut Bencher) {
 fn test_serializer_vec() {
     let log = Log::new();
     let wr = Vec::with_capacity(1024);
-    let mut serializer = json::Serializer::new(wr);
-    serializer.visit(&log).unwrap();
+    let mut serializer = serde_json::Serializer::new(wr);
+    log.serialize(&mut serializer).unwrap();
 
     let json = serializer.into_inner();
     assert_eq!(&json, &JSON_STR.as_bytes());
@@ -766,7 +1152,7 @@ fn test_serializer_vec() {
 #[bench]
 fn bench_serializer_vec(b: &mut Bencher) {
     let log = Log::new();
-    let json = json::to_vec(&log);
+    let json = serde_json::to_vec(&log);
     b.bytes = json.len() as u64;
 
     let mut wr = Vec::with_capacity(1024);
@@ -774,8 +1160,8 @@ fn bench_serializer_vec(b: &mut Bencher) {
     b.iter(|| {
         wr.clear();
 
-        let mut serializer = json::Serializer::new(wr.by_ref());
-        serializer.visit(&log).unwrap();
+        let mut serializer = serde_json::Serializer::new(wr.by_ref());
+        log.serialize(&mut serializer).unwrap();
         let _json = serializer.into_inner();
     });
 }
@@ -783,7 +1169,7 @@ fn bench_serializer_vec(b: &mut Bencher) {
 #[bench]
 fn bench_serializer_slice(b: &mut Bencher) {
     let log = Log::new();
-    let json = json::to_vec(&log);
+    let json = serde_json::to_vec(&log);
     b.bytes = json.len() as u64;
 
     let mut buf = [0; 1024];
@@ -792,8 +1178,8 @@ fn bench_serializer_slice(b: &mut Bencher) {
         for item in buf.iter_mut(){ *item = 0; }
         let mut wr = &mut buf[..];
 
-        let mut serializer = json::Serializer::new(wr.by_ref());
-        serializer.visit(&log).unwrap();
+        let mut serializer = serde_json::Serializer::new(wr.by_ref());
+        log.serialize(&mut serializer).unwrap();
         let _json = serializer.into_inner();
     });
 }
@@ -805,8 +1191,8 @@ fn test_serializer_my_mem_writer0() {
     let mut wr = MyMemWriter0::with_capacity(1024);
 
     {
-        let mut serializer = json::Serializer::new(wr.by_ref());
-        serializer.visit(&log).unwrap();
+        let mut serializer = serde_json::Serializer::new(wr.by_ref());
+        log.serialize(&mut serializer).unwrap();
         let _json = serializer.into_inner();
     }
 
@@ -816,7 +1202,7 @@ fn test_serializer_my_mem_writer0() {
 #[bench]
 fn bench_serializer_my_mem_writer0(b: &mut Bencher) {
     let log = Log::new();
-    let json = json::to_vec(&log);
+    let json = serde_json::to_vec(&log);
     b.bytes = json.len() as u64;
 
     let mut wr = MyMemWriter0::with_capacity(1024);
@@ -824,8 +1210,8 @@ fn bench_serializer_my_mem_writer0(b: &mut Bencher) {
     b.iter(|| {
         wr.buf.clear();
 
-        let mut serializer = json::Serializer::new(wr.by_ref());
-        serializer.visit(&log).unwrap();
+        let mut serializer = serde_json::Serializer::new(wr.by_ref());
+        log.serialize(&mut serializer).unwrap();
         let _json = serializer.into_inner();
     });
 }
@@ -837,8 +1223,8 @@ fn test_serializer_my_mem_writer1() {
     let mut wr = MyMemWriter1::with_capacity(1024);
 
     {
-        let mut serializer = json::Serializer::new(wr.by_ref());
-        serializer.visit(&log).unwrap();
+        let mut serializer = serde_json::Serializer::new(wr.by_ref());
+        log.serialize(&mut serializer).unwrap();
         let _json = serializer.into_inner();
     }
 
@@ -848,7 +1234,7 @@ fn test_serializer_my_mem_writer1() {
 #[bench]
 fn bench_serializer_my_mem_writer1(b: &mut Bencher) {
     let log = Log::new();
-    let json = json::to_vec(&log);
+    let json = serde_json::to_vec(&log);
     b.bytes = json.len() as u64;
 
     let mut wr = MyMemWriter1::with_capacity(1024);
@@ -856,8 +1242,8 @@ fn bench_serializer_my_mem_writer1(b: &mut Bencher) {
     b.iter(|| {
         wr.buf.clear();
 
-        let mut serializer = json::Serializer::new(wr.by_ref());
-        serializer.visit(&log).unwrap();
+        let mut serializer = serde_json::Serializer::new(wr.by_ref());
+        log.serialize(&mut serializer).unwrap();
         let _json = serializer.into_inner();
     });
 }
@@ -872,7 +1258,7 @@ fn bench_copy(b: &mut Bencher) {
     });
 }
 
-fn manual_serialize_no_escape<W: io::Write>(wr: &mut W, log: &Log) {
+fn manual_serialize_no_escape<W: Write>(wr: &mut W, log: &Log) {
     wr.write(b"{\"timestamp\":").unwrap();
     (write!(wr, "{}", log.timestamp)).unwrap();
     wr.write(b",\"zone_id\":").unwrap();
@@ -929,7 +1315,7 @@ fn manual_serialize_no_escape<W: io::Write>(wr: &mut W, log: &Log) {
     wr.write(b"}").unwrap();
 }
 
-fn manual_serialize_escape<W: io::Write>(wr: &mut W, log: &Log) {
+fn manual_serialize_escape<W: Write>(wr: &mut W, log: &Log) {
     wr.write_all(b"{").unwrap();
     escape_str(wr, "timestamp").unwrap();
     wr.write_all(b":").unwrap();
@@ -1207,6 +1593,6 @@ fn bench_deserializer(b: &mut Bencher) {
     b.bytes = JSON_STR.len() as u64;
 
     b.iter(|| {
-        let _log: Log = json::from_str(JSON_STR).unwrap();
+        let _log: Log = serde_json::from_str(JSON_STR).unwrap();
     });
 }

serde_tests/benches/bench_map.rs

@@ -1,16 +1,10 @@
-#![feature(custom_derive, core, plugin, test)]
-#![plugin(serde_macros)]
-
-extern crate serde;
-extern crate "rustc-serialize" as rustc_serialize;
-extern crate test;
-
 use std::fmt::Debug;
 use std::collections::HashMap;
 use test::Bencher;
 
 use rustc_serialize::{Decoder, Decodable};
 
+use serde;
 use serde::de::{Deserializer, Deserialize};
 
 //////////////////////////////////////////////////////////////////////////////
@@ -23,11 +17,13 @@ pub enum Error {
 }
 
 impl serde::de::Error for Error {
-    fn syntax_error() -> Error { Error::SyntaxError }
+    fn syntax(_: &str) -> Error { Error::SyntaxError }
 
-    fn end_of_stream_error() -> Error { Error::EndOfStream }
+    fn end_of_stream() -> Error { Error::EndOfStream }
 
-    fn missing_field_error(_: &'static str) -> Error {
+    fn unknown_field(_: &str) -> Error { Error::SyntaxError }
+
+    fn missing_field(_: &'static str) -> Error {
         Error::MissingField
     }
 }
@@ -351,17 +347,17 @@ mod deserializer {
 
     impl de::Deserializer<Error> for IsizeDeserializer {
         #[inline]
-        fn end_of_stream_error(&mut self) -> Error {
+        fn end_of_stream(&mut self) -> Error {
             EndOfStream
         }
 
         #[inline]
-        fn syntax_error(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
+        fn syntax(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
             SyntaxError
         }
 
         #[inline]
-        fn unexpected_name_error(&mut self, _token: de::Token) -> Error {
+        fn unexpected_name(&mut self, _token: de::Token) -> Error {
             SyntaxError
         }
 
@@ -403,7 +399,7 @@ fn bench_decoder_000(b: &mut Bencher) {
 fn bench_decoder_003(b: &mut Bencher) {
     b.iter(|| {
         let mut m: HashMap<String, isize> = HashMap::new();
-        for i in range(0, 3) {
+        for i in (0 .. 3) {
             m.insert(i.to_string(), i);
         }
         run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
@@ -414,7 +410,7 @@ fn bench_decoder_003(b: &mut Bencher) {
 fn bench_decoder_100(b: &mut Bencher) {
     b.iter(|| {
         let mut m: HashMap<String, isize> = HashMap::new();
-        for i in range(0, 100) {
+        for i in (0 .. 100) {
             m.insert(i.to_string(), i);
         }
         run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
@@ -443,7 +439,7 @@ fn bench_deserializer_000(b: &mut Bencher) {
 fn bench_deserializer_003(b: &mut Bencher) {
     b.iter(|| {
         let mut m: HashMap<String, isize> = HashMap::new();
-        for i in range(0, 3) {
+        for i in (0 .. 3) {
             m.insert(i.to_string(), i);
         }
         run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
@@ -454,7 +450,7 @@ fn bench_deserializer_003(b: &mut Bencher) {
 fn bench_deserializer_100(b: &mut Bencher) {
     b.iter(|| {
         let mut m: HashMap<String, isize> = HashMap::new();
-        for i in range(0, 100) {
+        for i in (0 .. 100) {
             m.insert(i.to_string(), i);
         }
         run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)

serde_tests/benches/bench_struct.rs

@@ -1,22 +1,15 @@
-#![feature(custom_derive, plugin, test)]
-#![plugin(serde_macros)]
-
-extern crate serde;
-extern crate "rustc-serialize" as rustc_serialize;
-extern crate test;
-
 use std::collections::HashMap;
 use test::Bencher;
 
 use rustc_serialize::{Decoder, Decodable};
 
+use serde;
 use serde::de::{Deserializer, Deserialize};
 
 //////////////////////////////////////////////////////////////////////////////
 
-#[derive(Clone, PartialEq, Debug, RustcDecodable)]
-#[derive_deserialize]
-struct Inner {
+#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)]
+pub struct Inner {
     a: (),
     b: usize,
     c: HashMap<String, Option<char>>,
@@ -24,30 +17,29 @@ struct Inner {
 
 //////////////////////////////////////////////////////////////////////////////
 
-#[derive(Clone, PartialEq, Debug, RustcDecodable)]
-#[derive_deserialize]
-struct Outer {
+#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)]
+pub struct Outer {
     inner: Vec<Inner>,
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
-#[derive(Debug)]
+#[derive(Debug, PartialEq)]
 pub enum Error {
     EndOfStream,
     SyntaxError,
-    UnexpectedName,
-    ConversionError,
     MissingField,
     OtherError,
 }
 
 impl serde::de::Error for Error {
-    fn syntax_error() -> Error { Error::SyntaxError }
+    fn syntax(_: &str) -> Error { Error::SyntaxError }
 
-    fn end_of_stream_error() -> Error { Error::EndOfStream }
+    fn end_of_stream() -> Error { Error::EndOfStream }
 
-    fn missing_field_error(_: &'static str) -> Error {
+    fn unknown_field(_: &str) -> Error { Error::SyntaxError }
+
+    fn missing_field(_: &'static str) -> Error {
         Error::MissingField
     }
 }
@@ -368,30 +360,6 @@ mod deserializer {
             where V: de::Visitor,
         {
             match self.stack.pop() {
-                Some(State::OuterState(Outer { inner })) => {
-                    self.stack.push(State::VecState(inner));
-                    self.stack.push(State::StrState("inner"));
-
-                    visitor.visit_named_map("Outer", OuterMapVisitor {
-                        de: self,
-                        state: 0,
-                    })
-                }
-                Some(State::InnerState(Inner { a: (), b, c })) => {
-                    self.stack.push(State::MapState(c));
-                    self.stack.push(State::StrState("c"));
-
-                    self.stack.push(State::UsizeState(b));
-                    self.stack.push(State::StrState("b"));
-
-                    self.stack.push(State::NullState);
-                    self.stack.push(State::StrState("a"));
-
-                    visitor.visit_named_map("Inner", InnerMapVisitor {
-                        de: self,
-                        state: 0,
-                    })
-                }
                 Some(State::VecState(value)) => {
                     visitor.visit_seq(OuterSeqVisitor {
                         de: self,
@@ -425,9 +393,55 @@ mod deserializer {
                 Some(State::OptionState(true)) => {
                     visitor.visit_some(self)
                 }
+                Some(_) => Err(Error::SyntaxError),
                 None => Err(Error::EndOfStream),
             }
         }
+
+        fn visit_struct<V>(&mut self,
+                           name: &str,
+                           _fields: &'static [&'static str],
+                           mut visitor: V) -> Result<V::Value, Error>
+            where V: de::Visitor,
+        {
+            match self.stack.pop() {
+                Some(State::OuterState(Outer { inner })) => {
+                    if name != "Outer" {
+                        return Err(Error::SyntaxError);
+                    }
+
+                    self.stack.push(State::VecState(inner));
+                    self.stack.push(State::StrState("inner"));
+
+                    visitor.visit_map(OuterMapVisitor {
+                        de: self,
+                        state: 0,
+                    })
+                }
+                Some(State::InnerState(Inner { a: (), b, c })) => {
+                    if name != "Inner" {
+                        return Err(Error::SyntaxError);
+                    }
+
+                    self.stack.push(State::MapState(c));
+                    self.stack.push(State::StrState("c"));
+
+                    self.stack.push(State::UsizeState(b));
+                    self.stack.push(State::StrState("b"));
+
+                    self.stack.push(State::NullState);
+                    self.stack.push(State::StrState("a"));
+
+                    visitor.visit_map(InnerMapVisitor {
+                        de: self,
+                        state: 0,
+                    })
+                }
+                _ => {
+                    Err(Error::SyntaxError)
+                }
+            }
+        }
     }
 
     struct OuterMapVisitor<'a> {
@@ -535,7 +549,7 @@ mod deserializer {
         }
 
         fn end(&mut self) -> Result<(), Error> {
-            if self.state == 1 {
+            if self.state == 3 {
                 Ok(())
             } else {
                 Err(Error::SyntaxError)
@@ -607,9 +621,9 @@ fn bench_decoder_0_0(b: &mut Bencher) {
         };
 
         let mut d = decoder::OuterDecoder::new(outer.clone());
-        let value: Outer = Decodable::decode(&mut d).unwrap();
+        let value: Result<Outer, Error> = Decodable::decode(&mut d);
 
-        assert_eq!(value, outer);
+        assert_eq!(value, Ok(outer));
     })
 }
 
@@ -629,9 +643,9 @@ fn bench_decoder_1_0(b: &mut Bencher) {
         };
 
         let mut d = decoder::OuterDecoder::new(outer.clone());
-        let value: Outer = Decodable::decode(&mut d).unwrap();
+        let value: Result<Outer, Error> = Decodable::decode(&mut d);
 
-        assert_eq!(value, outer);
+        assert_eq!(value, Ok(outer));
     })
 }
 
@@ -656,9 +670,9 @@ fn bench_decoder_1_5(b: &mut Bencher) {
         };
 
         let mut d = decoder::OuterDecoder::new(outer.clone());
-        let value: Outer = Decodable::decode(&mut d).unwrap();
+        let value: Result<Outer, Error> = Decodable::decode(&mut d);
 
-        assert_eq!(value, outer);
+        assert_eq!(value, Ok(outer));
     })
 }
 
@@ -670,9 +684,9 @@ fn bench_deserializer_0_0(b: &mut Bencher) {
         };
 
         let mut d = deserializer::OuterDeserializer::new(outer.clone());
-        let value: Outer = Deserialize::deserialize(&mut d).unwrap();
+        let value: Result<Outer, Error> = Deserialize::deserialize(&mut d);
 
-        assert_eq!(value, outer);
+        assert_eq!(value, Ok(outer));
     })
 }
 
@@ -692,9 +706,9 @@ fn bench_deserializer_1_0(b: &mut Bencher) {
         };
 
         let mut d = deserializer::OuterDeserializer::new(outer.clone());
-        let value: Outer = Deserialize::deserialize(&mut d).unwrap();
+        let value: Result<Outer, Error> = Deserialize::deserialize(&mut d);
 
-        assert_eq!(value, outer);
+        assert_eq!(value, Ok(outer));
     })
 }
 
@@ -719,8 +733,8 @@ fn bench_deserializer_1_5(b: &mut Bencher) {
         };
 
         let mut d = deserializer::OuterDeserializer::new(outer.clone());
-        let value: Outer = Deserialize::deserialize(&mut d).unwrap();
+        let value: Result<Outer, Error> = Deserialize::deserialize(&mut d);
 
-        assert_eq!(value, outer);
+        assert_eq!(value, Ok(outer));
     })
 }

serde_tests/benches/bench_vec.rs

@@ -1,15 +1,9 @@
-#![feature(core, plugin, test)]
-#![plugin(serde_macros)]
-
-extern crate serde;
-extern crate "rustc-serialize" as rustc_serialize;
-extern crate test;
-
 use std::fmt::Debug;
 use test::Bencher;
 
 use rustc_serialize::{Decoder, Decodable};
 
+use serde;
 use serde::de::{Deserializer, Deserialize};
 
 //////////////////////////////////////////////////////////////////////////////
@@ -21,11 +15,13 @@ pub enum Error {
 }
 
 impl serde::de::Error for Error {
-    fn syntax_error() -> Error { Error::SyntaxError }
+    fn syntax(_: &str) -> Error { Error::SyntaxError }
 
-    fn end_of_stream_error() -> Error { Error::EndOfStreamError }
+    fn end_of_stream() -> Error { Error::EndOfStreamError }
 
-    fn missing_field_error(_: &'static str) -> Error { Error::SyntaxError }
+    fn unknown_field(_: &str) -> Error { Error::SyntaxError }
+
+    fn missing_field(_: &'static str) -> Error { Error::SyntaxError }
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -537,7 +533,7 @@ fn bench_decoder_usize_003(b: &mut Bencher) {
 #[bench]
 fn bench_decoder_usize_100(b: &mut Bencher) {
     b.iter(|| {
-        let v: Vec<usize> = range(0, 100).collect();
+        let v: Vec<usize> = (0 .. 100).collect();
         run_decoder(decoder::UsizeDecoder::new(v.clone()), v)
     })
 }
@@ -561,7 +557,7 @@ fn bench_decoder_u8_003(b: &mut Bencher) {
 #[bench]
 fn bench_decoder_u8_100(b: &mut Bencher) {
     b.iter(|| {
-        let v: Vec<u8> = range(0u8, 100).collect();
+        let v: Vec<u8> = (0 .. 100).collect();
         run_decoder(decoder::U8Decoder::new(v.clone()), v)
     })
 }
@@ -585,7 +581,7 @@ fn bench_deserializer_usize_003(b: &mut Bencher) {
 #[bench]
 fn bench_deserializer_usize_100(b: &mut Bencher) {
     b.iter(|| {
-        let v: Vec<usize> = range(0, 100).collect();
+        let v: Vec<usize> = (0 .. 100).collect();
         run_deserializer(deserializer::Deserializer::new(v.clone()), v)
     })
 }
@@ -609,7 +605,7 @@ fn bench_deserializer_u8_003(b: &mut Bencher) {
 #[bench]
 fn bench_deserializer_u8_100(b: &mut Bencher) {
     b.iter(|| {
-        let v: Vec<u8> = range(0u8, 100).collect();
+        let v: Vec<u8> = (0 .. 100).collect();
         run_deserializer(deserializer::Deserializer::new(v.clone()), v)
     })
 }

serde_tests/build.rs

@@ -0,0 +1,22 @@
+extern crate syntex;
+extern crate serde_codegen;
+
+use std::env;
+use std::path::Path;
+
+fn main() {
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+
+    for &(src, dst) in &[
+        ("tests/test.rs.in", "test.rs"),
+        ("benches/bench.rs.in", "bench.rs"),
+    ] {
+        let src = Path::new(src);
+        let dst = Path::new(&out_dir).join(dst);
+
+        let mut registry = syntex::Registry::new();
+
+        serde_codegen::register(&mut registry);
+        registry.expand("", &src, &dst).unwrap();
+    }
+}

serde_tests/tests/test.rs

@@ -0,0 +1,4 @@
+extern crate serde;
+extern crate serde_json;
+
+include!(concat!(env!("OUT_DIR"), "/test.rs"));

serde_tests/tests/test.rs.in

@@ -0,0 +1,7 @@
+mod test_annotations;
+mod test_bytes;
+mod test_de;
+mod test_json;
+mod test_json_builder;
+mod test_macros;
+mod test_ser;

serde_tests/tests/test_annotations.rs

@@ -0,0 +1,90 @@
+use std::default;
+use serde_json;
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct Default {
+    a1: i32,
+    #[serde(default)]
+    a2: i32,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct Rename {
+    a1: i32,
+    #[serde(rename="a3")]
+    a2: i32,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct FormatRename {
+    a1: i32,
+    #[serde(rename(xml= "a4", json="a5"))]
+    a2: i32,
+}
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+enum SerEnum<A> {
+    Map {
+        a: i8,
+        #[serde(rename(xml= "c", json="d"))]
+        b: A,
+    },
+}
+
+#[derive(Debug, PartialEq, Deserialize, Serialize)]
+struct SkipSerializingFields<A: default::Default> {
+    a: i8,
+    #[serde(skip_serializing, default)]
+    b: A,
+}
+
+#[test]
+fn test_default() {
+    let deserialized_value: Default = serde_json::from_str(&"{\"a1\":1,\"a2\":2}").unwrap();
+    assert_eq!(deserialized_value, Default { a1: 1, a2: 2 });
+
+    let deserialized_value: Default = serde_json::from_str(&"{\"a1\":1}").unwrap();
+    assert_eq!(deserialized_value, Default { a1: 1, a2: 0 });
+}
+
+#[test]
+fn test_rename() {
+    let value = Rename { a1: 1, a2: 2 };
+    let serialized_value = serde_json::to_string(&value).unwrap();
+    assert_eq!(serialized_value, "{\"a1\":1,\"a3\":2}");
+
+    let deserialized_value: Rename = serde_json::from_str(&serialized_value).unwrap();
+    assert_eq!(value, deserialized_value);
+}
+
+#[test]
+fn test_format_rename() {
+    let value = FormatRename { a1: 1, a2: 2 };
+    let serialized_value = serde_json::to_string(&value).unwrap();
+    assert_eq!(serialized_value, "{\"a1\":1,\"a5\":2}");
+
+    let deserialized_value = serde_json::from_str("{\"a1\":1,\"a5\":2}").unwrap();
+    assert_eq!(value, deserialized_value);
+}
+
+#[test]
+fn test_enum_format_rename() {
+    let s1 = String::new();
+    let value = SerEnum::Map { a: 0i8, b: s1 };
+    let serialized_value = serde_json::to_string(&value).unwrap();
+    let ans = "{\"Map\":{\"a\":0,\"d\":\"\"}}";
+    assert_eq!(serialized_value, ans);
+
+    let deserialized_value = serde_json::from_str(ans).unwrap();
+    assert_eq!(value, deserialized_value);
+}
+
+#[test]
+fn test_skip_serializing_fields() {
+    let value = SkipSerializingFields { a: 1, b: 2 };
+    let serialized_value = serde_json::to_string(&value).unwrap();
+    assert_eq!(serialized_value, "{\"a\":1}");
+
+    let deserialized_value: SkipSerializingFields<_> = serde_json::from_str(&serialized_value).unwrap();
+    assert_eq!(SkipSerializingFields { a: 1, b: 0 }, deserialized_value);
+}

serde_tests/tests/test_bytes.rs

@@ -0,0 +1,209 @@
+use serde;
+use serde::Serialize;
+use serde::bytes::{ByteBuf, Bytes};
+use serde_json;
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[derive(Debug, PartialEq)]
+struct Error;
+
+impl serde::de::Error for Error {
+    fn syntax(_: &str) -> Error { Error }
+
+    fn end_of_stream() -> Error { Error }
+
+    fn unknown_field(_field: &str) -> Error { Error }
+
+    fn missing_field(_field: &'static str) -> Error { Error }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct BytesSerializer {
+    bytes: Vec<u8>,
+}
+
+impl BytesSerializer {
+    fn new(bytes: Vec<u8>) -> Self {
+        BytesSerializer {
+            bytes: bytes,
+        }
+    }
+}
+
+impl serde::Serializer for BytesSerializer {
+    type Error = Error;
+
+    fn visit_unit(&mut self) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn visit_bool(&mut self, _v: bool) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn visit_i64(&mut self, _v: i64) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn visit_u64(&mut self, _v: u64) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn visit_f32(&mut self, _v: f32) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn visit_f64(&mut self, _v: f64) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn visit_char(&mut self, _v: char) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn visit_str(&mut self, _v: &str) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn visit_none(&mut self) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn visit_some<V>(&mut self, _value: V) -> Result<(), Error>
+        where V: serde::Serialize,
+    {
+        Err(Error)
+    }
+
+    fn visit_seq<V>(&mut self, _visitor: V) -> Result<(), Error>
+        where V: serde::ser::SeqVisitor,
+    {
+        Err(Error)
+    }
+
+    fn visit_seq_elt<T>(&mut self, _value: T) -> Result<(), Error>
+        where T: serde::Serialize
+    {
+        Err(Error)
+    }
+
+    fn visit_map<V>(&mut self, _visitor: V) -> Result<(), Error>
+        where V: serde::ser::MapVisitor,
+    {
+        Err(Error)
+    }
+
+    fn visit_map_elt<K, V>(&mut self, _key: K, _value: V) -> Result<(), Error>
+        where K: serde::Serialize,
+              V: serde::Serialize,
+    {
+        Err(Error)
+    }
+
+    fn visit_bytes(&mut self, bytes: &[u8]) -> Result<(), Error> {
+        assert_eq!(self.bytes, bytes);
+        Ok(())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+struct BytesDeserializer {
+    bytes: Option<Vec<u8>>,
+}
+
+impl BytesDeserializer {
+    fn new(bytes: Vec<u8>) -> Self {
+        BytesDeserializer {
+            bytes: Some(bytes),
+        }
+    }
+}
+
+impl serde::Deserializer for BytesDeserializer {
+    type Error = Error;
+
+    fn visit<V>(&mut self, _visitor: V) -> Result<V::Value, Error>
+        where V: serde::de::Visitor,
+    {
+        Err(Error)
+    }
+
+    fn visit_bytes<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: serde::de::Visitor,
+    {
+        visitor.visit_byte_buf(self.bytes.take().unwrap())
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[test]
+fn test_bytes_ser_json() {
+    let buf = vec![];
+    let bytes = Bytes::from(&buf);
+    assert_eq!(serde_json::to_string(&bytes).unwrap(), "[]".to_string());
+
+    let buf = vec![1, 2, 3];
+    let bytes = Bytes::from(&buf);
+    assert_eq!(serde_json::to_string(&bytes).unwrap(), "[1,2,3]".to_string());
+}
+
+#[test]
+fn test_bytes_ser_bytes() {
+    let buf = vec![];
+    let bytes = Bytes::from(&buf);
+    let mut ser = BytesSerializer::new(vec![]);
+    bytes.serialize(&mut ser).unwrap();
+
+    let buf = vec![1, 2, 3];
+    let bytes = Bytes::from(&buf);
+    let mut ser = BytesSerializer::new(vec![1, 2, 3]);
+    bytes.serialize(&mut ser).unwrap();
+}
+
+#[test]
+fn test_byte_buf_ser_json() {
+    let bytes = ByteBuf::new();
+    assert_eq!(serde_json::to_string(&bytes).unwrap(), "[]".to_string());
+
+    let bytes = ByteBuf::from(vec![1, 2, 3]);
+    assert_eq!(serde_json::to_string(&bytes).unwrap(), "[1,2,3]".to_string());
+}
+
+#[test]
+fn test_byte_buf_ser_bytes() {
+    let bytes = ByteBuf::new();
+    let mut ser = BytesSerializer::new(vec![]);
+    bytes.serialize(&mut ser).unwrap();
+
+    let bytes = ByteBuf::from(vec![1, 2, 3]);
+    let mut ser = BytesSerializer::new(vec![1, 2, 3]);
+    bytes.serialize(&mut ser).unwrap();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[test]
+fn test_byte_buf_de_json() {
+    let bytes = ByteBuf::new();
+    let v: ByteBuf = serde_json::from_str("[]").unwrap();
+    assert_eq!(v, bytes);
+
+    let bytes = ByteBuf::from(vec![1, 2, 3]);
+    let v: ByteBuf = serde_json::from_str("[1, 2, 3]").unwrap();
+    assert_eq!(v, bytes);
+}
+
+#[test]
+fn test_byte_buf_de_bytes() {
+    let mut de = BytesDeserializer::new(vec![]);
+    let bytes = serde::Deserialize::deserialize(&mut de);
+    assert_eq!(bytes, Ok(ByteBuf::new()));
+
+    let mut de = BytesDeserializer::new(vec![1, 2, 3]);
+    let bytes = serde::Deserialize::deserialize(&mut de);
+    assert_eq!(bytes, Ok(ByteBuf::from(vec![1, 2, 3])));
+}

serde_tests/tests/test_json_builder.rs

@@ -1,9 +1,7 @@
-extern crate serde;
-
 use std::collections::BTreeMap;
 
-use serde::json::value::Value;
-use serde::json::builder::{ArrayBuilder, ObjectBuilder};
+use serde_json::value::Value;
+use serde_json::builder::{ArrayBuilder, ObjectBuilder};
 
 #[test]
 fn test_array_builder() {
@@ -15,12 +13,12 @@ fn test_array_builder() {
         .push(2)
         .push(3)
         .unwrap();
-    assert_eq!(value, Value::Array(vec!(Value::I64(1), Value::I64(2), Value::I64(3))));
+    assert_eq!(value, Value::Array(vec!(Value::U64(1), Value::U64(2), Value::U64(3))));
 
     let value = ArrayBuilder::new()
         .push_array(|bld| bld.push(1).push(2).push(3))
         .unwrap();
-    assert_eq!(value, Value::Array(vec!(Value::Array(vec!(Value::I64(1), Value::I64(2), Value::I64(3))))));
+    assert_eq!(value, Value::Array(vec!(Value::Array(vec!(Value::U64(1), Value::U64(2), Value::U64(3))))));
 
     let value = ArrayBuilder::new()
         .push_object(|bld|
@@ -30,8 +28,8 @@ fn test_array_builder() {
         .unwrap();
 
     let mut map = BTreeMap::new();
-    map.insert("a".to_string(), Value::I64(1));
-    map.insert("b".to_string(), Value::I64(2));
+    map.insert("a".to_string(), Value::U64(1));
+    map.insert("b".to_string(), Value::U64(2));
     assert_eq!(value, Value::Array(vec!(Value::Object(map))));
 }
 
@@ -46,7 +44,7 @@ fn test_object_builder() {
         .unwrap();
 
     let mut map = BTreeMap::new();
-    map.insert("a".to_string(), Value::I64(1));
-    map.insert("b".to_string(), Value::I64(2));
+    map.insert("a".to_string(), Value::U64(1));
+    map.insert("b".to_string(), Value::U64(2));
     assert_eq!(value, Value::Object(map));
 }

serde_tests/tests/test_macros.rs

@@ -0,0 +1,536 @@
+use std::collections::BTreeMap;
+use serde_json::{self, Value};
+
+macro_rules! btreemap {
+    () => {
+        BTreeMap::new()
+    };
+    ($($key:expr => $value:expr),+) => {
+        {
+            let mut map = BTreeMap::new();
+            $(map.insert($key, $value);)+
+            map
+        }
+    }
+}
+
+/*
+trait Trait {
+    type Type;
+}
+*/
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct NamedUnit;
+
+#[derive(Debug, PartialEq, Serialize)]
+struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
+
+#[derive(Debug, PartialEq, Deserialize)]
+struct DeNamedTuple<A, B, C>(A, B, C);
+
+#[derive(Debug, PartialEq, Serialize)]
+struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
+    a: &'a A,
+    b: &'b mut B,
+    c: C,
+}
+
+#[derive(Debug, PartialEq, Deserialize)]
+struct DeNamedMap<A, B, C> {
+    a: A,
+    b: B,
+    c: C,
+}
+
+#[derive(Debug, PartialEq, Serialize)]
+enum SerEnum<'a, B: 'a, C: /* Trait + */ 'a, D> where D: /* Trait + */ 'a {
+    Unit,
+    Seq(
+        i8,
+        B,
+        &'a C,
+        //C::Type,
+        &'a mut D,
+        //<D as Trait>::Type,
+    ),
+    Map {
+        a: i8,
+        b: B,
+        c: &'a C,
+        //d: C::Type,
+        e: &'a mut D,
+        //f: <D as Trait>::Type,
+    },
+
+    // Make sure we can support more than one variant.
+    _Unit2,
+    _Seq2(
+        i8,
+        B,
+        &'a C,
+        //C::Type,
+        &'a mut D,
+        //<D as Trait>::Type,
+    ),
+    _Map2 {
+        a: i8,
+        b: B,
+        c: &'a C,
+        //d: C::Type,
+        e: &'a mut D,
+        //f: <D as Trait>::Type,
+    },
+}
+
+#[derive(Debug, PartialEq, Deserialize)]
+enum DeEnum<B, C: /* Trait */, D> /* where D: Trait */ {
+    Unit,
+    Seq(
+        i8,
+        B,
+        C,
+        //C::Type,
+        D,
+        //<D as Trait>::Type,
+    ),
+    Map {
+        a: i8,
+        b: B,
+        c: C,
+        //d: C::Type,
+        e: D,
+        //f: <D as Trait>::Type,
+    },
+
+    // Make sure we can support more than one variant.
+    _Unit2,
+    _Seq2(
+        i8,
+        B,
+        C,
+        //C::Type,
+        D,
+        //<D as Trait>::Type,
+    ),
+    _Map2 {
+        a: i8,
+        b: B,
+        c: C,
+        //d: C::Type,
+        e: D,
+        //f: <D as Trait>::Type,
+    },
+}
+
+#[derive(Serialize)]
+enum Lifetimes<'a> {
+    LifetimeSeq(&'a i32),
+    NoLifetimeSeq(i32),
+    LifetimeMap { a: &'a i32 },
+    NoLifetimeMap { a: i32 },
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct GenericStruct<T> {
+    x: T,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct GenericNewtypeStruct<T>(T);
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub struct GenericTupleStruct<T, U>(T, U);
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+pub enum GenericEnum<T, U> {
+    Unit,
+    Newtype(T),
+    Seq(T, U),
+    Map { x: T, y: U },
+}
+
+#[test]
+fn test_named_unit() {
+    let named_unit = NamedUnit;
+
+    assert_eq!(
+        serde_json::to_string(&named_unit).unwrap(),
+        "null".to_string()
+    );
+
+    assert_eq!(
+        serde_json::to_value(&named_unit),
+        Value::Null
+    );
+
+    let v: NamedUnit = serde_json::from_str("null").unwrap();
+    assert_eq!(v, named_unit);
+
+    let v: NamedUnit = serde_json::from_value(Value::Null).unwrap();
+    assert_eq!(v, named_unit);
+}
+
+#[test]
+fn test_ser_named_tuple() {
+    let a = 5;
+    let mut b = 6;
+    let c = 7;
+    let named_tuple = SerNamedTuple(&a, &mut b, c);
+
+    assert_eq!(
+        serde_json::to_string(&named_tuple).unwrap(),
+        "[5,6,7]"
+    );
+
+    assert_eq!(
+        serde_json::to_value(&named_tuple),
+        Value::Array(vec![Value::U64(5), Value::U64(6), Value::U64(7)])
+    );
+}
+
+#[test]
+fn test_de_named_tuple() {
+    let v: DeNamedTuple<i32, i32, i32> = serde_json::from_str("[1,2,3]").unwrap();
+    assert_eq!(
+        v,
+        DeNamedTuple(1, 2, 3)
+    );
+
+    let v: Value = serde_json::from_str("[1,2,3]").unwrap();
+    assert_eq!(
+        v,
+        Value::Array(vec![
+            Value::U64(1),
+            Value::U64(2),
+            Value::U64(3),
+        ])
+    );
+}
+
+#[test]
+fn test_ser_named_map() {
+    let a = 5;
+    let mut b = 6;
+    let c = 7;
+    let named_map = SerNamedMap {
+        a: &a,
+        b: &mut b,
+        c: c,
+    };
+
+    assert_eq!(
+        serde_json::to_string(&named_map).unwrap(),
+        "{\"a\":5,\"b\":6,\"c\":7}"
+    );
+
+    assert_eq!(
+        serde_json::to_value(&named_map),
+        Value::Object(btreemap![
+            "a".to_string() => Value::U64(5),
+            "b".to_string() => Value::U64(6),
+            "c".to_string() => Value::U64(7)
+        ])
+    );
+}
+
+#[test]
+fn test_de_named_map() {
+    let v = DeNamedMap {
+        a: 5,
+        b: 6,
+        c: 7,
+    };
+
+    let v2: DeNamedMap<i32, i32, i32> = serde_json::from_str(
+        "{\"a\":5,\"b\":6,\"c\":7}"
+    ).unwrap();
+    assert_eq!(v, v2);
+
+    let v2 = serde_json::from_value(Value::Object(btreemap![
+        "a".to_string() => Value::U64(5),
+        "b".to_string() => Value::U64(6),
+        "c".to_string() => Value::U64(7)
+    ])).unwrap();
+    assert_eq!(v, v2);
+}
+
+#[test]
+fn test_ser_enum_unit() {
+    assert_eq!(
+        serde_json::to_string(&SerEnum::Unit::<u32, u32, u32>).unwrap(),
+        "{\"Unit\":[]}"
+    );
+
+    assert_eq!(
+        serde_json::to_value(&SerEnum::Unit::<u32, u32, u32>),
+        Value::Object(btreemap!(
+            "Unit".to_string() => Value::Array(vec![]))
+        )
+    );
+}
+
+#[test]
+fn test_ser_enum_seq() {
+    let a = 1;
+    let b = 2;
+    let c = 3;
+    //let d = 4;
+    let mut e = 5;
+    //let f = 6;
+
+    assert_eq!(
+        serde_json::to_string(&SerEnum::Seq(
+            a,
+            b,
+            &c,
+            //d,
+            &mut e,
+            //f,
+        )).unwrap(),
+        "{\"Seq\":[1,2,3,5]}".to_string()
+    );
+
+    assert_eq!(
+        serde_json::to_value(&SerEnum::Seq(
+            a,
+            b,
+            &c,
+            //d,
+            &mut e,
+            //e,
+        )),
+        Value::Object(btreemap!(
+            "Seq".to_string() => Value::Array(vec![
+                Value::U64(1),
+                Value::U64(2),
+                Value::U64(3),
+                //Value::U64(4),
+                Value::U64(5),
+                //Value::U64(6),
+            ])
+        ))
+    );
+}
+
+#[test]
+fn test_ser_enum_map() {
+    let a = 1;
+    let b = 2;
+    let c = 3;
+    //let d = 4;
+    let mut e = 5;
+    //let f = 6;
+
+    assert_eq!(
+        serde_json::to_string(&SerEnum::Map {
+            a: a,
+            b: b,
+            c: &c,
+            //d: d,
+            e: &mut e,
+            //f: f,
+        }).unwrap(),
+        "{\"Map\":{\"a\":1,\"b\":2,\"c\":3,\"e\":5}}".to_string()
+    );
+
+    assert_eq!(
+        serde_json::to_value(&SerEnum::Map {
+            a: a,
+            b: b,
+            c: &c,
+            //d: d,
+            e: &mut e,
+            //f: f,
+        }),
+        Value::Object(btreemap!(
+            "Map".to_string() => Value::Object(btreemap![
+                "a".to_string() => Value::U64(1),
+                "b".to_string() => Value::U64(2),
+                "c".to_string() => Value::U64(3),
+                //"d".to_string() => Value::U64(4)
+                "e".to_string() => Value::U64(5)
+                //"f".to_string() => Value::U64(6)
+            ])
+        ))
+    );
+}
+
+#[test]
+fn test_de_enum_unit() {
+    let v: DeEnum<_, _, _> = serde_json::from_str("{\"Unit\":[]}").unwrap();
+    assert_eq!(
+        v,
+        DeEnum::Unit::<u32, u32, u32>
+    );
+
+    let v: DeEnum<_, _, _> = serde_json::from_value(Value::Object(btreemap!(
+        "Unit".to_string() => Value::Array(vec![]))
+    )).unwrap();
+    assert_eq!(
+        v,
+        DeEnum::Unit::<u32, u32, u32>
+    );
+}
+
+#[test]
+fn test_de_enum_seq() {
+    let a = 1;
+    let b = 2;
+    let c = 3;
+    //let d = 4;
+    let e = 5;
+    //let f = 6;
+
+    let v: DeEnum<_, _, _> = serde_json::from_str("{\"Seq\":[1,2,3,5]}").unwrap();
+    assert_eq!(
+        v,
+        DeEnum::Seq(
+            a,
+            b,
+            c,
+            //d,
+            e,
+            //f,
+        )
+    );
+
+    let v: DeEnum<_, _, _> = serde_json::from_value(Value::Object(btreemap!(
+        "Seq".to_string() => Value::Array(vec![
+            Value::U64(1),
+            Value::U64(2),
+            Value::U64(3),
+            //Value::U64(4),
+            Value::U64(5),
+            //Value::U64(6),
+        ])
+    ))).unwrap();
+    assert_eq!(
+        v,
+        DeEnum::Seq(
+            a,
+            b,
+            c,
+            //d,
+            e,
+            //e,
+        )
+    );
+}
+
+#[test]
+fn test_de_enum_map() {
+    let a = 1;
+    let b = 2;
+    let c = 3;
+    //let d = 4;
+    let e = 5;
+    //let f = 6;
+
+    let v: DeEnum<_, _, _> = serde_json::from_str(
+        "{\"Map\":{\"a\":1,\"b\":2,\"c\":3,\"e\":5}}"
+    ).unwrap();
+    assert_eq!(
+        v,
+        DeEnum::Map {
+            a: a,
+            b: b,
+            c: c,
+            //d: d,
+            e: e,
+            //f: f,
+        }
+    );
+
+    let v: DeEnum<_, _, _> = serde_json::from_value(Value::Object(btreemap!(
+        "Map".to_string() => Value::Object(btreemap![
+            "a".to_string() => Value::U64(1),
+            "b".to_string() => Value::U64(2),
+            "c".to_string() => Value::U64(3),
+            //"d".to_string() => Value::U64(4)
+            "e".to_string() => Value::U64(5)
+            //"f".to_string() => Value::U64(6)
+        ])
+    ))).unwrap();
+
+    assert_eq!(
+        v,
+        DeEnum::Map {
+            a: a,
+            b: b,
+            c: c,
+            //d: d,
+            e: e,
+            //f: f,
+        }
+    );
+}
+
+#[test]
+fn test_lifetimes() {
+    let value = 5;
+    let lifetime = Lifetimes::LifetimeSeq(&value);
+    assert_eq!(
+        serde_json::to_string(&lifetime).unwrap(),
+        "{\"LifetimeSeq\":5}"
+    );
+
+    let lifetime = Lifetimes::NoLifetimeSeq(5);
+    assert_eq!(
+        serde_json::to_string(&lifetime).unwrap(),
+        "{\"NoLifetimeSeq\":5}"
+    );
+
+    let value = 5;
+    let lifetime = Lifetimes::LifetimeMap { a: &value };
+    assert_eq!(
+        serde_json::to_string(&lifetime).unwrap(),
+        "{\"LifetimeMap\":{\"a\":5}}"
+    );
+
+    let lifetime = Lifetimes::NoLifetimeMap { a: 5 };
+    assert_eq!(
+        serde_json::to_string(&lifetime).unwrap(),
+        "{\"NoLifetimeMap\":{\"a\":5}}"
+    );
+}
+
+macro_rules! declare_tests {
+    ($($name:ident { $($ty:ty : $value:expr => $str:expr,)+ })+) => {
+        $(
+            #[test]
+            fn $name() {
+                $(
+                    let value: $ty = $value;
+
+                    let string = serde_json::to_string(&value).unwrap();
+                    assert_eq!(string, $str);
+
+                    let expected: $ty = serde_json::from_str(&string).unwrap();
+                    assert_eq!(value, expected);
+                )+
+            }
+        )+
+    }
+}
+
+declare_tests! {
+    test_generic_struct {
+        GenericStruct<u32> : GenericStruct { x: 5 } => "{\"x\":5}",
+    }
+    test_generic_newtype_struct {
+        GenericNewtypeStruct<u32> : GenericNewtypeStruct(5) => "5",
+    }
+    test_generic_tuple_struct {
+        GenericTupleStruct<u32, u32> : GenericTupleStruct(5, 6) => "[5,6]",
+    }
+    test_generic_enum_newtype {
+        GenericEnum<u32, u32> : GenericEnum::Newtype(5) => "{\"Newtype\":5}",
+    }
+    test_generic_enum_seq {
+        GenericEnum<u32, u32> : GenericEnum::Seq(5, 6) => "{\"Seq\":[5,6]}",
+    }
+    test_generic_enum_map {
+        GenericEnum<u32, u32> : GenericEnum::Map { x: 5, y: 6 } => "{\"Map\":{\"x\":5,\"y\":6}}",
+    }
+}

serde_tests/tests/test_ser.rs

@@ -1,13 +1,7 @@
-#![feature(custom_derive, plugin, test)]
-#![plugin(serde_macros)]
-
-extern crate test;
-extern crate serde;
-
 use std::vec;
 use std::collections::BTreeMap;
 
-use serde::ser::{Serialize, Serializer, Visitor, SeqVisitor, MapVisitor};
+use serde::ser::{Serialize, Serializer, SeqVisitor, MapVisitor};
 
 #[derive(Clone, PartialEq, Debug)]
 pub enum Token<'a> {
@@ -30,19 +24,21 @@ pub enum Token<'a> {
     Option(bool),
 
     Unit,
-    NamedUnit(&'a str),
+    UnitStruct(&'a str),
     EnumUnit(&'a str, &'a str),
 
-    SeqStart(usize),
-    NamedSeqStart(&'a str, usize),
-    EnumSeqStart(&'a str, &'a str, usize),
-    SeqSep(bool),
+    EnumNewtype(&'a str, &'a str),
+
+    SeqStart(Option<usize>),
+    TupleStructStart(&'a str, Option<usize>),
+    EnumSeqStart(&'a str, &'a str, Option<usize>),
+    SeqSep,
     SeqEnd,
 
-    MapStart(usize),
-    NamedMapStart(&'a str, usize),
-    EnumMapStart(&'a str, &'a str, usize),
-    MapSep(bool),
+    MapStart(Option<usize>),
+    StructStart(&'a str, Option<usize>),
+    EnumMapStart(&'a str, &'a str, Option<usize>),
+    MapSep,
     MapEnd,
 }
 
@@ -79,16 +75,6 @@ impl<'a> AssertSerializer<'a> {
 }
 
 impl<'a> Serializer for AssertSerializer<'a> {
-    type Value = ();
-    type Error = ();
-
-    fn visit<T: Serialize>(&mut self, value: &T) -> Result<(), ()> {
-        value.visit(self)
-    }
-}
-
-impl<'a> Visitor for AssertSerializer<'a> {
-    type Value = ();
     type Error = ();
 
     fn visit_unit(&mut self) -> Result<(), ()> {
@@ -96,13 +82,31 @@ impl<'a> Visitor for AssertSerializer<'a> {
         Ok(())
     }
 
-    fn visit_named_unit(&mut self, name: &str) -> Result<(), ()> {
-        assert_eq!(self.iter.next().unwrap(), Token::NamedUnit(name));
+    fn visit_newtype_variant<T>(&mut self,
+                                name: &str,
+                                _variant_index: usize,
+                                variant: &str,
+                                value: T) -> Result<(), ()>
+        where T: Serialize,
+    {
+        assert_eq!(self.iter.next(), Some(Token::EnumNewtype(name, variant)));
+        value.serialize(self)
+    }
+
+    fn visit_unit_struct(&mut self, name: &str) -> Result<(), ()> {
+        assert_eq!(self.iter.next().unwrap(), Token::UnitStruct(name));
         Ok(())
     }
 
-    fn visit_enum_unit(&mut self, name: &str, variant: &str) -> Result<(), ()> {
-        assert_eq!(self.iter.next().unwrap(), Token::EnumUnit(name, variant));
+    fn visit_unit_variant(&mut self,
+                          name: &str,
+                          _variant_index: usize,
+                          variant: &str) -> Result<(), ()> {
+        assert_eq!(
+            self.iter.next().unwrap(),
+            Token::EnumUnit(name, variant)
+        );
+
         Ok(())
     }
 
@@ -190,115 +194,127 @@ impl<'a> Visitor for AssertSerializer<'a> {
         where V: Serialize,
     {
         assert_eq!(self.iter.next(), Some(Token::Option(true)));
-        value.visit(self)
+        value.serialize(self)
     }
 
 
     fn visit_seq<V>(&mut self, visitor: V) -> Result<(), ()>
         where V: SeqVisitor
     {
-        let (len, _) = visitor.size_hint();
+        let len = visitor.len();
 
         assert_eq!(self.iter.next(), Some(Token::SeqStart(len)));
 
         self.visit_sequence(visitor)
     }
 
-    fn visit_named_seq<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
+    fn visit_tuple_struct<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
         where V: SeqVisitor
     {
-        let (len, _) = visitor.size_hint();
+        let len = visitor.len();
 
-        assert_eq!(self.iter.next().unwrap(), Token::NamedSeqStart(name, len));
+        assert_eq!(
+            self.iter.next().unwrap(),
+            Token::TupleStructStart(name, len)
+        );
 
         self.visit_sequence(visitor)
     }
 
-    fn visit_enum_seq<V>(&mut self,
-                         name: &str,
-                         variant: &str,
-                         visitor: V) -> Result<(), ()>
+    fn visit_tuple_variant<V>(&mut self,
+                              name: &str,
+                              _variant_index: usize,
+                              variant: &str,
+                              visitor: V) -> Result<(), ()>
         where V: SeqVisitor
     {
-        let (len, _) = visitor.size_hint();
+        let len = visitor.len();
 
-        assert_eq!(self.iter.next().unwrap(), Token::EnumSeqStart(name, variant, len));
+        assert_eq!(
+            self.iter.next().unwrap(),
+            Token::EnumSeqStart(name, variant, len)
+        );
 
         self.visit_sequence(visitor)
     }
 
-    fn visit_seq_elt<T>(&mut self, first: bool, value: T) -> Result<(), ()>
+    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), ()>
         where T: Serialize
     {
-        assert_eq!(self.iter.next(), Some(Token::SeqSep(first)));
-        value.visit(self)
+        assert_eq!(self.iter.next(), Some(Token::SeqSep));
+        value.serialize(self)
     }
 
     fn visit_map<V>(&mut self, visitor: V) -> Result<(), ()>
         where V: MapVisitor
     {
-        let (len, _) = visitor.size_hint();
+        let len = visitor.len();
 
         assert_eq!(self.iter.next(), Some(Token::MapStart(len)));
 
         self.visit_mapping(visitor)
     }
 
-    fn visit_named_map<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
+    fn visit_struct<V>(&mut self, name: &str, visitor: V) -> Result<(), ()>
         where V: MapVisitor
     {
-        let (len, _) = visitor.size_hint();
+        let len = visitor.len();
 
-        assert_eq!(self.iter.next().unwrap(), Token::NamedMapStart(name, len));
+        assert_eq!(
+            self.iter.next().unwrap(),
+            Token::StructStart(name, len)
+        );
 
         self.visit_mapping(visitor)
     }
 
-    fn visit_enum_map<V>(&mut self,
-                         name: &str,
-                         variant: &str,
-                         visitor: V) -> Result<(), ()>
+    fn visit_struct_variant<V>(&mut self,
+                               name: &str,
+                               _variant_index: usize,
+                               variant: &str,
+                               visitor: V) -> Result<(), ()>
         where V: MapVisitor
     {
-        let (len, _) = visitor.size_hint();
+        let len = visitor.len();
 
-        assert_eq!(self.iter.next().unwrap(), Token::EnumMapStart(name, variant, len));
+        assert_eq!(
+            self.iter.next().unwrap(),
+            Token::EnumMapStart(name, variant, len)
+        );
 
         self.visit_mapping(visitor)
     }
 
-    fn visit_map_elt<K, V>(&mut self,
-                           first: bool,
-                           key: K,
-                           value: V) -> Result<(), ()>
+    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), ()>
         where K: Serialize,
               V: Serialize,
     {
-        assert_eq!(self.iter.next(), Some(Token::MapSep(first)));
+        assert_eq!(self.iter.next(), Some(Token::MapSep));
 
-        try!(key.visit(self));
-        value.visit(self)
+        try!(key.serialize(self));
+        value.serialize(self)
     }
 }
 
 //////////////////////////////////////////////////////////////////////////
 
-#[derive_serialize]
-struct NamedUnit;
+#[derive(Serialize)]
+struct UnitStruct;
 
-#[derive_serialize]
-struct NamedSeq(i32, i32, i32);
+#[derive(Serialize)]
+struct TupleStruct(i32, i32, i32);
 
-#[derive_serialize]
-struct NamedMap {
+#[derive(Serialize)]
+struct Struct {
     a: i32,
     b: i32,
     c: i32,
 }
 
-#[derive_serialize]
+#[derive(Serialize)]
 enum Enum {
     Unit,
+    One(i32),
     Seq(i32, i32),
     Map { a: i32, b: i32 },
 }
@@ -324,7 +340,7 @@ macro_rules! declare_test {
         fn $name() {
             $(
                 let mut ser = AssertSerializer::new($tokens);
-                assert_eq!(ser.visit(&$value), Ok(()));
+                assert_eq!($value.serialize(&mut ser), Ok(()));
             )+
         }
     }
@@ -378,47 +394,75 @@ declare_tests! {
             Token::I32(1),
         ],
     }
+    test_result {
+        Ok::<i32, i32>(0) => vec![
+            Token::EnumNewtype("Result", "Ok"),
+            Token::I32(0),
+        ],
+        Err::<i32, i32>(1) => vec![
+            Token::EnumNewtype("Result", "Err"),
+            Token::I32(1),
+        ],
+    }
     test_slice {
         &[0][..0] => vec![
-            Token::SeqStart(0),
+            Token::SeqStart(Some(0)),
             Token::SeqEnd,
         ],
         &[1, 2, 3][..] => vec![
-            Token::SeqStart(3),
-                Token::SeqSep(true),
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
                 Token::I32(1),
 
-                Token::SeqSep(false),
+                Token::SeqSep,
                 Token::I32(2),
 
-                Token::SeqSep(false),
+                Token::SeqSep,
+                Token::I32(3),
+            Token::SeqEnd,
+        ],
+    }
+    test_array {
+        [0; 0] => vec![
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        [1, 2, 3] => vec![
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+
+                Token::SeqSep,
                 Token::I32(3),
             Token::SeqEnd,
         ],
     }
     test_vec {
         Vec::<isize>::new() => vec![
-            Token::SeqStart(0),
+            Token::SeqStart(Some(0)),
             Token::SeqEnd,
         ],
         vec![vec![], vec![1], vec![2, 3]] => vec![
-            Token::SeqStart(3),
-                Token::SeqSep(true),
-                Token::SeqStart(0),
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::SeqStart(Some(0)),
                 Token::SeqEnd,
 
-                Token::SeqSep(false),
-                Token::SeqStart(1),
-                    Token::SeqSep(true),
+                Token::SeqSep,
+                Token::SeqStart(Some(1)),
+                    Token::SeqSep,
                     Token::I32(1),
                 Token::SeqEnd,
 
-                Token::SeqSep(false),
-                Token::SeqStart(2),
-                    Token::SeqSep(true),
+                Token::SeqSep,
+                Token::SeqStart(Some(2)),
+                    Token::SeqSep,
                     Token::I32(2),
 
-                    Token::SeqSep(false),
+                    Token::SeqSep,
                     Token::I32(3),
                 Token::SeqEnd,
             Token::SeqEnd,
@@ -426,93 +470,93 @@ declare_tests! {
     }
     test_tuple {
         (1,) => vec![
-            Token::SeqStart(1),
-                Token::SeqSep(true),
+            Token::SeqStart(Some(1)),
+                Token::SeqSep,
                 Token::I32(1),
             Token::SeqEnd,
         ],
         (1, 2, 3) => vec![
-            Token::SeqStart(3),
-                Token::SeqSep(true),
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
                 Token::I32(1),
 
-                Token::SeqSep(false),
+                Token::SeqSep,
                 Token::I32(2),
 
-                Token::SeqSep(false),
+                Token::SeqSep,
                 Token::I32(3),
             Token::SeqEnd,
         ],
     }
     test_btreemap {
         btreemap![1 => 2] => vec![
-            Token::MapStart(1),
-                Token::MapSep(true),
+            Token::MapStart(Some(1)),
+                Token::MapSep,
                 Token::I32(1),
                 Token::I32(2),
             Token::MapEnd,
         ],
         btreemap![1 => 2, 3 => 4] => vec![
-            Token::MapStart(2),
-                Token::MapSep(true),
+            Token::MapStart(Some(2)),
+                Token::MapSep,
                 Token::I32(1),
                 Token::I32(2),
 
-                Token::MapSep(false),
+                Token::MapSep,
                 Token::I32(3),
                 Token::I32(4),
             Token::MapEnd,
         ],
         btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => vec![
-            Token::MapStart(2),
-                Token::MapSep(true),
+            Token::MapStart(Some(2)),
+                Token::MapSep,
                 Token::I32(1),
-                Token::MapStart(0),
+                Token::MapStart(Some(0)),
                 Token::MapEnd,
 
-                Token::MapSep(false),
+                Token::MapSep,
                 Token::I32(2),
-                Token::MapStart(2),
-                    Token::MapSep(true),
+                Token::MapStart(Some(2)),
+                    Token::MapSep,
                     Token::I32(3),
                     Token::I32(4),
 
-                    Token::MapSep(false),
+                    Token::MapSep,
                     Token::I32(5),
                     Token::I32(6),
                 Token::MapEnd,
             Token::MapEnd,
         ],
     }
-    test_named_unit {
-        NamedUnit => vec![Token::NamedUnit("NamedUnit")],
+    test_unit_struct {
+        UnitStruct => vec![Token::UnitStruct("UnitStruct")],
     }
-    test_named_seq {
-        NamedSeq(1, 2, 3) => vec![
-            Token::NamedSeqStart("NamedSeq", 3),
-                Token::SeqSep(true),
+    test_tuple_struct {
+        TupleStruct(1, 2, 3) => vec![
+            Token::TupleStructStart("TupleStruct", Some(3)),
+                Token::SeqSep,
                 Token::I32(1),
 
-                Token::SeqSep(false),
+                Token::SeqSep,
                 Token::I32(2),
 
-                Token::SeqSep(false),
+                Token::SeqSep,
                 Token::I32(3),
             Token::SeqEnd,
         ],
     }
-    test_named_map {
-        NamedMap { a: 1, b: 2, c: 3 } => vec![
-            Token::NamedMapStart("NamedMap", 3),
-                Token::MapSep(true),
+    test_struct {
+        Struct { a: 1, b: 2, c: 3 } => vec![
+            Token::StructStart("Struct", Some(3)),
+                Token::MapSep,
                 Token::Str("a"),
                 Token::I32(1),
 
-                Token::MapSep(false),
+                Token::MapSep,
                 Token::Str("b"),
                 Token::I32(2),
 
-                Token::MapSep(false),
+                Token::MapSep,
                 Token::Str("c"),
                 Token::I32(3),
             Token::MapEnd,
@@ -520,22 +564,23 @@ declare_tests! {
     }
     test_enum {
         Enum::Unit => vec![Token::EnumUnit("Enum", "Unit")],
+        Enum::One(42) => vec![Token::EnumNewtype("Enum", "One"), Token::I32(42)],
         Enum::Seq(1, 2) => vec![
-            Token::EnumSeqStart("Enum", "Seq", 2),
-                Token::SeqSep(true),
+            Token::EnumSeqStart("Enum", "Seq", Some(2)),
+                Token::SeqSep,
                 Token::I32(1),
 
-                Token::SeqSep(false),
+                Token::SeqSep,
                 Token::I32(2),
             Token::SeqEnd,
         ],
         Enum::Map { a: 1, b: 2 } => vec![
-            Token::EnumMapStart("Enum", "Map", 2),
-                Token::MapSep(true),
+            Token::EnumMapStart("Enum", "Map", Some(2)),
+                Token::MapSep,
                 Token::Str("a"),
                 Token::I32(1),
 
-                Token::MapSep(false),
+                Token::MapSep,
                 Token::Str("b"),
                 Token::I32(2),
             Token::MapEnd,

src/de.rs

@@ -1,819 +0,0 @@
-use std::collections::{HashMap, BTreeMap};
-use std::hash::Hash;
-use std::marker::PhantomData;
-use std::num::FromPrimitive;
-use std::path;
-use std::str;
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub trait Error {
-    fn syntax_error() -> Self;
-
-    fn end_of_stream_error() -> Self;
-
-    fn missing_field_error(&'static str) -> Self;
-}
-
-pub trait Deserialize {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
-        where D: Deserializer;
-}
-
-pub trait Deserializer {
-    type Error: Error;
-
-    fn visit<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor;
-
-    /// The `visit_option` method allows a `Deserialize` type to inform the
-    /// `Deserializer` that it's expecting an optional value. This allows
-    /// deserializers that encode an optional value as a nullable value to
-    /// convert the null value into a `None`, and a regular value as
-    /// `Some(value)`.
-    #[inline]
-    fn visit_option<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.visit(visitor)
-    }
-
-    /// The `visit_enum` method allows a `Deserialize` type to inform the
-    /// `Deserializer` that it's expecting an enum value. This allows
-    /// deserializers that provide a custom enumeration serialization to
-    /// properly deserialize the type.
-    #[inline]
-    fn visit_enum<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
-        where V: Visitor,
-    {
-        self.visit(visitor)
-    }
-}
-
-pub trait Visitor {
-    type Value;
-
-    fn visit_bool<E>(&mut self, _v: bool) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        Err(Error::syntax_error())
-    }
-
-    fn visit_isize<E>(&mut self, v: isize) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        self.visit_i64(v as i64)
-    }
-
-    fn visit_i8<E>(&mut self, v: i8) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        self.visit_i64(v as i64)
-    }
-
-    fn visit_i16<E>(&mut self, v: i16) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        self.visit_i64(v as i64)
-    }
-
-    fn visit_i32<E>(&mut self, v: i32) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        self.visit_i64(v as i64)
-    }
-
-    fn visit_i64<E>(&mut self, _v: i64) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        Err(Error::syntax_error())
-    }
-
-    fn visit_usize<E>(&mut self, v: usize) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        self.visit_u64(v as u64)
-    }
-
-    fn visit_u8<E>(&mut self, v: u8) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        self.visit_u64(v as u64)
-    }
-
-    fn visit_u16<E>(&mut self, v: u16) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        self.visit_u64(v as u64)
-    }
-
-    fn visit_u32<E>(&mut self, v: u32) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        self.visit_u64(v as u64)
-    }
-
-    fn visit_u64<E>(&mut self, _v: u64) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        Err(Error::syntax_error())
-    }
-
-    fn visit_f32<E>(&mut self, v: f32) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        self.visit_f64(v as f64)
-    }
-
-    fn visit_f64<E>(&mut self, _v: f64) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        Err(Error::syntax_error())
-    }
-
-    #[inline]
-    fn visit_char<E>(&mut self, v: char) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        // The unwraps in here should be safe.
-        let mut s = &mut [0; 4];
-        let len = v.encode_utf8(s).unwrap();
-        self.visit_str(str::from_utf8(&s[..len]).unwrap())
-    }
-
-    fn visit_str<E>(&mut self, _v: &str) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        Err(Error::syntax_error())
-    }
-
-    #[inline]
-    fn visit_string<E>(&mut self, v: String) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        self.visit_str(&v)
-    }
-
-    fn visit_unit<E>(&mut self) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        Err(Error::syntax_error())
-    }
-
-    #[inline]
-    fn visit_named_unit<E>(&mut self, _name: &str) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        self.visit_unit()
-    }
-
-    fn visit_none<E>(&mut self) -> Result<Self::Value, E>
-        where E: Error,
-    {
-        Err(Error::syntax_error())
-    }
-
-    fn visit_some<D>(&mut self, _deserializer: &mut D) -> Result<Self::Value, D::Error>
-        where D: Deserializer,
-    {
-        Err(Error::syntax_error())
-    }
-
-    fn visit_seq<V>(&mut self, _visitor: V) -> Result<Self::Value, V::Error>
-        where V: SeqVisitor,
-    {
-        Err(Error::syntax_error())
-    }
-
-    #[inline]
-    fn visit_named_seq<V>(&mut self, _name: &str, visitor: V) -> Result<Self::Value, V::Error>
-        where V: SeqVisitor,
-    {
-        self.visit_seq(visitor)
-    }
-
-    fn visit_map<V>(&mut self, _visitor: V) -> Result<Self::Value, V::Error>
-        where V: MapVisitor,
-    {
-        Err(Error::syntax_error())
-    }
-
-    #[inline]
-    fn visit_named_map<V>(&mut self, _name: &str, visitor: V) -> Result<Self::Value, V::Error>
-        where V: MapVisitor,
-    {
-        self.visit_map(visitor)
-    }
-
-    #[inline]
-    fn visit_enum<V>(&mut self,
-                     _name: &str,
-                     _variant: &str,
-                     _visitor: V) -> Result<Self::Value, V::Error>
-        where V: EnumVisitor,
-    {
-        Err(Error::syntax_error())
-    }
-
-    #[inline]
-    fn visit_variant<V>(&mut self, _name: &str, _visitor: V) -> Result<Self::Value, V::Error>
-        where V: EnumVisitor,
-    {
-        Err(Error::syntax_error())
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub trait SeqVisitor {
-    type Error: Error;
-
-    fn visit<T>(&mut self) -> Result<Option<T>, Self::Error>
-        where T: Deserialize;
-
-    fn end(&mut self) -> Result<(), Self::Error>;
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, None)
-    }
-}
-
-impl<'a, V> SeqVisitor for &'a mut V where V: SeqVisitor {
-    type Error = V::Error;
-
-    #[inline]
-    fn visit<T>(&mut self) -> Result<Option<T>, V::Error>
-        where T: Deserialize
-    {
-        (**self).visit()
-    }
-
-    #[inline]
-    fn end(&mut self) -> Result<(), V::Error> {
-        (**self).end()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (**self).size_hint()
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub trait MapVisitor {
-    type Error: Error;
-
-    #[inline]
-    fn visit<K, V>(&mut self) -> Result<Option<(K, V)>, Self::Error>
-        where K: Deserialize,
-              V: Deserialize,
-    {
-        match try!(self.visit_key()) {
-            Some(key) => {
-                let value = try!(self.visit_value());
-                Ok(Some((key, value)))
-            }
-            None => Ok(None)
-        }
-    }
-
-    fn visit_key<K>(&mut self) -> Result<Option<K>, Self::Error>
-        where K: Deserialize;
-
-    fn visit_value<V>(&mut self) -> Result<V, Self::Error>
-        where V: Deserialize;
-
-    fn end(&mut self) -> Result<(), Self::Error>;
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, None)
-    }
-}
-
-impl<'a, V_> MapVisitor for &'a mut V_ where V_: MapVisitor {
-    type Error = V_::Error;
-
-    #[inline]
-    fn visit<K, V>(&mut self) -> Result<Option<(K, V)>, V_::Error>
-        where K: Deserialize,
-              V: Deserialize,
-    {
-        (**self).visit()
-    }
-
-    #[inline]
-    fn visit_key<K>(&mut self) -> Result<Option<K>, V_::Error>
-        where K: Deserialize
-    {
-        (**self).visit_key()
-    }
-
-    #[inline]
-    fn visit_value<V>(&mut self) -> Result<V, V_::Error>
-        where V: Deserialize
-    {
-        (**self).visit_value()
-    }
-
-    #[inline]
-    fn end(&mut self) -> Result<(), V_::Error> {
-        (**self).end()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (**self).size_hint()
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub trait EnumVisitor {
-    type Error: Error;
-
-    fn visit_unit(&mut self) -> Result<(), Self::Error> {
-        Err(Error::syntax_error())
-    }
-
-    fn visit_seq<V>(&mut self, _visitor: V) -> Result<V::Value, Self::Error>
-        where V: EnumSeqVisitor,
-    {
-        Err(Error::syntax_error())
-    }
-
-    fn visit_map<V>(&mut self, _visitor: V) -> Result<V::Value, Self::Error>
-        where V: EnumMapVisitor,
-    {
-        Err(Error::syntax_error())
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub trait EnumSeqVisitor {
-    type Value;
-
-    fn visit<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
-        where V: SeqVisitor;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub trait EnumMapVisitor {
-    type Value;
-
-    fn visit<V>(&mut self, visitor: V) -> Result<Self::Value, V::Error>
-        where V: MapVisitor;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-struct UnitVisitor;
-
-impl Visitor for UnitVisitor {
-    type Value = ();
-
-    fn visit_unit<E>(&mut self) -> Result<(), E>
-        where E: Error,
-    {
-        Ok(())
-    }
-
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<(), V::Error>
-        where V: SeqVisitor,
-    {
-        visitor.end()
-    }
-}
-
-impl Deserialize for () {
-    fn deserialize<D>(deserializer: &mut D) -> Result<(), D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(UnitVisitor)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-struct BoolVisitor;
-
-impl Visitor for BoolVisitor {
-    type Value = bool;
-
-    fn visit_bool<E>(&mut self, v: bool) -> Result<bool, E>
-        where E: Error,
-    {
-        Ok(v)
-    }
-}
-
-impl Deserialize for bool {
-    fn deserialize<D>(deserializer: &mut D) -> Result<bool, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(BoolVisitor)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-macro_rules! impl_deserialize_num_method {
-    ($src_ty:ty, $method:ident, $from_method:ident) => {
-        #[inline]
-        fn $method<E>(&mut self, v: $src_ty) -> Result<T, E>
-            where E: Error,
-        {
-            match FromPrimitive::$from_method(v) {
-                Some(v) => Ok(v),
-                None => Err(Error::syntax_error()),
-            }
-        }
-    }
-}
-
-pub struct PrimitiveVisitor<T> {
-    marker: PhantomData<T>,
-}
-
-impl<T> PrimitiveVisitor<T> {
-    #[inline]
-    pub fn new() -> Self {
-        PrimitiveVisitor {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<
-    T: Deserialize + FromPrimitive
-> self::Visitor for PrimitiveVisitor<T> {
-    type Value = T;
-
-    impl_deserialize_num_method!(isize, visit_isize, from_isize);
-    impl_deserialize_num_method!(i8, visit_i8, from_i8);
-    impl_deserialize_num_method!(i16, visit_i16, from_i16);
-    impl_deserialize_num_method!(i32, visit_i32, from_i32);
-    impl_deserialize_num_method!(i64, visit_i64, from_i64);
-    impl_deserialize_num_method!(usize, visit_usize, from_usize);
-    impl_deserialize_num_method!(u8, visit_u8, from_u8);
-    impl_deserialize_num_method!(u16, visit_u16, from_u16);
-    impl_deserialize_num_method!(u32, visit_u32, from_u32);
-    impl_deserialize_num_method!(u64, visit_u64, from_u64);
-    impl_deserialize_num_method!(f32, visit_f32, from_f32);
-    impl_deserialize_num_method!(f64, visit_f64, from_f64);
-}
-
-macro_rules! impl_deserialize_num {
-    ($ty:ty) => {
-        impl Deserialize for $ty {
-            #[inline]
-            fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
-                where D: Deserializer,
-            {
-                deserializer.visit(PrimitiveVisitor::new())
-            }
-        }
-    }
-}
-
-impl_deserialize_num!(isize);
-impl_deserialize_num!(i8);
-impl_deserialize_num!(i16);
-impl_deserialize_num!(i32);
-impl_deserialize_num!(i64);
-impl_deserialize_num!(usize);
-impl_deserialize_num!(u8);
-impl_deserialize_num!(u16);
-impl_deserialize_num!(u32);
-impl_deserialize_num!(u64);
-impl_deserialize_num!(f32);
-impl_deserialize_num!(f64);
-
-///////////////////////////////////////////////////////////////////////////////
-
-struct CharVisitor;
-
-impl Visitor for CharVisitor {
-    type Value = char;
-
-    #[inline]
-    fn visit_char<E>(&mut self, v: char) -> Result<char, E>
-        where E: Error,
-    {
-        Ok(v)
-    }
-
-    #[inline]
-    fn visit_str<E>(&mut self, v: &str) -> Result<char, E>
-        where E: Error,
-    {
-        let mut iter = v.chars();
-        if let Some(v) = iter.next() {
-            if iter.next().is_some() {
-                Err(Error::syntax_error())
-            } else {
-                Ok(v)
-            }
-        } else {
-            Err(Error::end_of_stream_error())
-        }
-    }
-}
-
-impl Deserialize for char {
-    #[inline]
-    fn deserialize<D>(deserializer: &mut D) -> Result<char, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(CharVisitor)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-struct StringVisitor;
-
-impl Visitor for StringVisitor {
-    type Value = String;
-
-    fn visit_str<E>(&mut self, v: &str) -> Result<String, E>
-        where E: Error,
-    {
-        Ok(v.to_string())
-    }
-
-    fn visit_string<E>(&mut self, v: String) -> Result<String, E>
-        where E: Error,
-    {
-        Ok(v)
-    }
-}
-
-impl Deserialize for String {
-    fn deserialize<D>(deserializer: &mut D) -> Result<String, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(StringVisitor)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-struct OptionVisitor<T> {
-    marker: PhantomData<T>,
-}
-
-impl<
-    T: Deserialize,
-> Visitor for OptionVisitor<T> {
-    type Value = Option<T>;
-
-    #[inline]
-    fn visit_none<E>(&mut self) -> Result<Option<T>, E>
-        where E: Error,
-    {
-        Ok(None)
-    }
-
-    #[inline]
-    fn visit_some<D>(&mut self, deserializer: &mut D) -> Result<Option<T>, D::Error>
-        where D: Deserializer,
-    {
-        Ok(Some(try!(Deserialize::deserialize(deserializer))))
-    }
-}
-
-impl<T> Deserialize for Option<T> where T: Deserialize {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Option<T>, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit_option(OptionVisitor { marker: PhantomData })
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub struct VecVisitor<T> {
-    marker: PhantomData<T>,
-}
-
-impl<T> VecVisitor<T> {
-    pub fn new() -> Self {
-        VecVisitor {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<T> Visitor for VecVisitor<T> where T: Deserialize {
-    type Value = Vec<T>;
-
-    #[inline]
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<Vec<T>, V::Error>
-        where V: SeqVisitor,
-    {
-        let (len, _) = visitor.size_hint();
-        let mut values = Vec::with_capacity(len);
-
-        while let Some(value) = try!(visitor.visit()) {
-            values.push(value);
-        }
-
-        Ok(values)
-    }
-}
-
-impl<T: Deserialize> Deserialize for Vec<T> {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Vec<T>, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(VecVisitor::new())
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-macro_rules! tuple_impls {
-    () => {};
-    ($($visitor:ident => ($($name:ident),+),)+) => {
-        $(
-            struct $visitor<$($name,)+> {
-                marker: PhantomData<($($name,)+)>,
-            }
-
-            impl<
-                $($name: Deserialize,)+
-            > Visitor for $visitor<$($name,)+> {
-                type Value = ($($name,)+);
-
-                #[inline]
-                #[allow(non_snake_case)]
-                fn visit_seq<V>(&mut self, mut visitor: V) -> Result<($($name,)+), V::Error>
-                    where V: SeqVisitor,
-                {
-                    $(
-                        let $name = match try!(visitor.visit()) {
-                            Some(value) => value,
-                            None => { return Err(Error::end_of_stream_error()); }
-                        };
-                     )+;
-
-                    try!(visitor.end());
-
-                    Ok(($($name,)+))
-                }
-            }
-
-            impl<
-                $($name: Deserialize),+
-            > Deserialize for ($($name,)+) {
-                #[inline]
-                fn deserialize<D>(deserializer: &mut D) -> Result<($($name,)+), D::Error>
-                    where D: Deserializer,
-                {
-                    deserializer.visit($visitor { marker: PhantomData })
-                }
-            }
-        )+
-    }
-}
-
-tuple_impls! {
-    TupleVisitor1 => (T0),
-    TupleVisitor2 => (T0, T1),
-    TupleVisitor3 => (T0, T1, T2),
-    TupleVisitor4 => (T0, T1, T2, T3),
-    TupleVisitor5 => (T0, T1, T2, T3, T4),
-    TupleVisitor6 => (T0, T1, T2, T3, T4, T5),
-    TupleVisitor7 => (T0, T1, T2, T3, T4, T5, T6),
-    TupleVisitor8 => (T0, T1, T2, T3, T4, T5, T6, T7),
-    TupleVisitor9 => (T0, T1, T2, T3, T4, T5, T6, T7, T8),
-    TupleVisitor10 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9),
-    TupleVisitor11 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10),
-    TupleVisitor12 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11),
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub struct HashMapVisitor<K, V> {
-    marker: PhantomData<HashMap<K, V>>,
-}
-
-impl<K, V> HashMapVisitor<K, V> {
-    #[inline]
-    pub fn new() -> Self {
-        HashMapVisitor {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<K, V> Visitor for HashMapVisitor<K, V>
-    where K: Deserialize + Eq + Hash,
-          V: Deserialize,
-{
-    type Value = HashMap<K, V>;
-
-    #[inline]
-    fn visit_map<V_>(&mut self, mut visitor: V_) -> Result<HashMap<K, V>, V_::Error>
-        where V_: MapVisitor,
-    {
-        let (len, _) = visitor.size_hint();
-        let mut values = HashMap::with_capacity(len);
-
-        while let Some((key, value)) = try!(visitor.visit()) {
-            values.insert(key, value);
-        }
-
-        Ok(values)
-    }
-}
-
-impl<K, V> Deserialize for HashMap<K, V>
-    where K: Deserialize + Eq + Hash,
-          V: Deserialize,
-{
-    fn deserialize<D>(deserializer: &mut D) -> Result<HashMap<K, V>, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(HashMapVisitor::new())
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub struct BTreeMapVisitor<K, V> {
-    marker: PhantomData<BTreeMap<K, V>>,
-}
-
-impl<K, V> BTreeMapVisitor<K, V> {
-    #[inline]
-    pub fn new() -> Self {
-        BTreeMapVisitor {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<K, V> Visitor for BTreeMapVisitor<K, V>
-    where K: Deserialize + Ord,
-          V: Deserialize
-{
-    type Value = BTreeMap<K, V>;
-
-    #[inline]
-    fn visit_map<Visitor>(&mut self, mut visitor: Visitor) -> Result<BTreeMap<K, V>, Visitor::Error>
-        where Visitor: MapVisitor,
-    {
-        let mut values = BTreeMap::new();
-
-        while let Some((key, value)) = try!(visitor.visit()) {
-            values.insert(key, value);
-        }
-
-        Ok(values)
-    }
-}
-
-impl<
-    K: Deserialize + Eq + Ord,
-    V: Deserialize,
-> Deserialize for BTreeMap<K, V> {
-    fn deserialize<D>(deserializer: &mut D) -> Result<BTreeMap<K, V>, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(BTreeMapVisitor::new())
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-struct PathBufVisitor;
-
-impl Visitor for PathBufVisitor {
-    type Value = path::PathBuf;
-
-    fn visit_str<E>(&mut self, v: &str) -> Result<path::PathBuf, E>
-        where E: Error,
-    {
-        Ok(path::PathBuf::new(&v))
-    }
-
-    fn visit_string<E>(&mut self, v: String) -> Result<path::PathBuf, E>
-        where E: Error,
-    {
-        self.visit_str(&v)
-    }
-}
-
-impl Deserialize for path::PathBuf {
-    fn deserialize<D>(deserializer: &mut D) -> Result<path::PathBuf, D::Error>
-        where D: Deserializer,
-    {
-        deserializer.visit(PathBufVisitor)
-    }
-}

src/json/de.rs

@@ -1,636 +0,0 @@
-use std::char;
-use std::num::Float;
-use unicode::str::Utf16Item;
-use std::str;
-
-use de;
-use super::error::{Error, ErrorCode};
-
-pub struct Deserializer<Iter> {
-    rdr: Iter,
-    ch: Option<u8>,
-    line: usize,
-    col: usize,
-    buf: Vec<u8>,
-}
-
-impl<Iter> Deserializer<Iter>
-    where Iter: Iterator<Item=u8>,
-{
-    /// Creates the JSON parser.
-    #[inline]
-    pub fn new(rdr: Iter) -> Deserializer<Iter> {
-        let mut p = Deserializer {
-            rdr: rdr,
-            ch: Some(b'\x00'),
-            line: 1,
-            col: 0,
-            buf: Vec::with_capacity(128),
-        };
-        p.bump();
-        return p;
-    }
-
-    #[inline]
-    pub fn end(&mut self) -> Result<(), Error> {
-        self.parse_whitespace();
-        if self.eof() {
-            Ok(())
-        } else {
-            Err(self.error(ErrorCode::TrailingCharacters))
-        }
-    }
-
-    fn eof(&self) -> bool { self.ch.is_none() }
-
-    fn ch_or_null(&self) -> u8 { self.ch.unwrap_or(b'\x00') }
-
-    fn bump(&mut self) {
-        self.ch = self.rdr.next();
-
-        if self.ch_is(b'\n') {
-            self.line += 1;
-            self.col = 1;
-        } else {
-            self.col += 1;
-        }
-    }
-
-    fn next_char(&mut self) -> Option<u8> {
-        self.bump();
-        self.ch
-    }
-
-    fn ch_is(&self, c: u8) -> bool {
-        self.ch == Some(c)
-    }
-
-    fn error(&mut self, reason: ErrorCode) -> Error {
-        Error::SyntaxError(reason, self.line, self.col)
-    }
-
-    fn parse_whitespace(&mut self) {
-        while self.ch_is(b' ') ||
-              self.ch_is(b'\n') ||
-              self.ch_is(b'\t') ||
-              self.ch_is(b'\r') { self.bump(); }
-    }
-
-    fn parse_value<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        self.parse_whitespace();
-
-        if self.eof() {
-            return Err(self.error(ErrorCode::EOFWhileParsingValue));
-        }
-
-        match self.ch_or_null() {
-            b'n' => {
-                try!(self.parse_ident(b"ull"));
-                visitor.visit_unit()
-            }
-            b't' => {
-                try!(self.parse_ident(b"rue"));
-                visitor.visit_bool(true)
-            }
-            b'f' => {
-                try!(self.parse_ident(b"alse"));
-                visitor.visit_bool(false)
-            }
-            b'0' ... b'9' | b'-' => self.parse_number(visitor),
-            b'"' => {
-                try!(self.parse_string());
-                let s = str::from_utf8(&self.buf).unwrap();
-                visitor.visit_str(s)
-            }
-            b'[' => {
-                self.bump();
-                visitor.visit_seq(SeqVisitor::new(self))
-            }
-            b'{' => {
-                self.bump();
-                visitor.visit_map(MapVisitor::new(self))
-            }
-            _ => {
-                Err(self.error(ErrorCode::ExpectedSomeValue))
-            }
-        }
-    }
-
-    fn parse_ident(&mut self, ident: &[u8]) -> Result<(), Error> {
-        if ident.iter().all(|c| Some(*c) == self.next_char()) {
-            self.bump();
-            Ok(())
-        } else {
-            Err(self.error(ErrorCode::ExpectedSomeIdent))
-        }
-    }
-
-    fn parse_number<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        let mut neg = 1;
-
-        if self.ch_is(b'-') {
-            self.bump();
-            neg = -1;
-        }
-
-        let res = try!(self.parse_integer());
-
-        if self.ch_is(b'.') || self.ch_is(b'e') || self.ch_is(b'E') {
-            let neg = neg as f64;
-            let mut res = res as f64;
-
-            if self.ch_is(b'.') {
-                res = try!(self.parse_decimal(res));
-            }
-
-            if self.ch_is(b'e') || self.ch_is(b'E') {
-                res = try!(self.parse_exponent(res));
-            }
-
-            visitor.visit_f64(neg * res)
-        } else {
-            visitor.visit_i64(neg * res)
-        }
-    }
-
-    fn parse_integer(&mut self) -> Result<i64, Error> {
-        let mut res = 0;
-
-        match self.ch_or_null() {
-            b'0' => {
-                self.bump();
-
-                // There can be only one leading '0'.
-                match self.ch_or_null() {
-                    b'0' ... b'9' => {
-                        return Err(self.error(ErrorCode::InvalidNumber));
-                    }
-                    _ => ()
-                }
-            },
-            b'1' ... b'9' => {
-                while !self.eof() {
-                    match self.ch_or_null() {
-                        c @ b'0' ... b'9' => {
-                            res *= 10;
-                            res += (c as i64) - (b'0' as i64);
-                            self.bump();
-                        }
-                        _ => break,
-                    }
-                }
-            }
-            _ => { return Err(self.error(ErrorCode::InvalidNumber)); }
-        }
-
-        Ok(res)
-    }
-
-    fn parse_decimal(&mut self, res: f64) -> Result<f64, Error> {
-        self.bump();
-
-        // Make sure a digit follows the decimal place.
-        match self.ch_or_null() {
-            b'0' ... b'9' => (),
-             _ => { return Err(self.error(ErrorCode::InvalidNumber)); }
-        }
-
-        let mut res = res;
-        let mut dec = 1.0;
-        while !self.eof() {
-            match self.ch_or_null() {
-                c @ b'0' ... b'9' => {
-                    dec /= 10.0;
-                    res += (((c as u64) - (b'0' as u64)) as f64) * dec;
-                    self.bump();
-                }
-                _ => break,
-            }
-        }
-
-        Ok(res)
-    }
-
-    fn parse_exponent(&mut self, mut res: f64) -> Result<f64, Error> {
-        self.bump();
-
-        let mut exp = 0;
-        let mut neg_exp = false;
-
-        if self.ch_is(b'+') {
-            self.bump();
-        } else if self.ch_is(b'-') {
-            self.bump();
-            neg_exp = true;
-        }
-
-        // Make sure a digit follows the exponent place.
-        match self.ch_or_null() {
-            b'0' ... b'9' => (),
-            _ => { return Err(self.error(ErrorCode::InvalidNumber)); }
-        }
-        while !self.eof() {
-            match self.ch_or_null() {
-                c @ b'0' ... b'9' => {
-                    exp *= 10;
-                    exp += (c as i32) - (b'0' as i32);
-
-                    self.bump();
-                }
-                _ => break
-            }
-        }
-
-        let exp: f64 = 10_f64.powi(exp);
-        if neg_exp {
-            res /= exp;
-        } else {
-            res *= exp;
-        }
-
-        Ok(res)
-    }
-
-    fn decode_hex_escape(&mut self) -> Result<u16, Error> {
-        let mut i = 0;
-        let mut n = 0u16;
-        while i < 4 && !self.eof() {
-            self.bump();
-            n = match self.ch_or_null() {
-                c @ b'0' ... b'9' => n * 16_u16 + ((c as u16) - (b'0' as u16)),
-                b'a' | b'A' => n * 16_u16 + 10_u16,
-                b'b' | b'B' => n * 16_u16 + 11_u16,
-                b'c' | b'C' => n * 16_u16 + 12_u16,
-                b'd' | b'D' => n * 16_u16 + 13_u16,
-                b'e' | b'E' => n * 16_u16 + 14_u16,
-                b'f' | b'F' => n * 16_u16 + 15_u16,
-                _ => { return Err(self.error(ErrorCode::InvalidEscape)); }
-            };
-
-            i += 1;
-        }
-
-        // Error out if we didn't parse 4 digits.
-        if i != 4 {
-            return Err(self.error(ErrorCode::InvalidEscape));
-        }
-
-        Ok(n)
-    }
-
-    fn parse_string(&mut self) -> Result<(), Error> {
-        self.buf.clear();
-
-        let mut escape = false;
-
-        loop {
-            let ch = match self.next_char() {
-                Some(ch) => ch,
-                None => { return Err(self.error(ErrorCode::EOFWhileParsingString)); }
-            };
-
-            if escape {
-                match ch {
-                    b'"' => self.buf.push(b'"'),
-                    b'\\' => self.buf.push(b'\\'),
-                    b'/' => self.buf.push(b'/'),
-                    b'b' => self.buf.push(b'\x08'),
-                    b'f' => self.buf.push(b'\x0c'),
-                    b'n' => self.buf.push(b'\n'),
-                    b'r' => self.buf.push(b'\r'),
-                    b't' => self.buf.push(b'\t'),
-                    b'u' => {
-                        let c = match try!(self.decode_hex_escape()) {
-                            0xDC00 ... 0xDFFF => {
-                                return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
-                            }
-
-                            // Non-BMP characters are encoded as a sequence of
-                            // two hex escapes, representing UTF-16 surrogates.
-                            n1 @ 0xD800 ... 0xDBFF => {
-                                let c1 = self.next_char();
-                                let c2 = self.next_char();
-                                match (c1, c2) {
-                                    (Some(b'\\'), Some(b'u')) => (),
-                                    _ => {
-                                        return Err(self.error(ErrorCode::UnexpectedEndOfHexEscape));
-                                    }
-                                }
-
-                                let buf = &[n1, try!(self.decode_hex_escape())];
-                                match ::unicode::str::utf16_items(buf).next() {
-                                    Some(Utf16Item::ScalarValue(c)) => c,
-                                    _ => {
-                                        return Err(self.error(ErrorCode::LoneLeadingSurrogateInHexEscape));
-                                    }
-                                }
-                            }
-
-                            n => match char::from_u32(n as u32) {
-                                Some(c) => c,
-                                None => {
-                                    return Err(self.error(ErrorCode::InvalidUnicodeCodePoint));
-                                }
-                            }
-                        };
-
-                        let buf = &mut [0; 4];
-                        let len = c.encode_utf8(buf).unwrap_or(0);
-                        self.buf.extend(buf[..len].iter().map(|b| *b));
-                    }
-                    _ => {
-                        return Err(self.error(ErrorCode::InvalidEscape));
-                    }
-                }
-                escape = false;
-            } else {
-                match ch {
-                    b'"' => {
-                        self.bump();
-                        return Ok(());
-                    }
-                    b'\\' => {
-                        escape = true;
-                    }
-                    ch => {
-                        self.buf.push(ch);
-                    }
-                }
-            }
-        }
-    }
-
-    fn parse_object_colon(&mut self) -> Result<(), Error> {
-        self.parse_whitespace();
-
-        if self.ch_is(b':') {
-            self.bump();
-            Ok(())
-        } else if self.eof() {
-            Err(self.error(ErrorCode::EOFWhileParsingObject))
-        } else {
-            Err(self.error(ErrorCode::ExpectedColon))
-        }
-    }
-}
-
-impl<Iter> de::Deserializer for Deserializer<Iter>
-    where Iter: Iterator<Item=u8>,
-{
-    type Error = Error;
-
-    #[inline]
-    fn visit<V>(&mut self, visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        self.parse_value(visitor)
-    }
-
-    #[inline]
-    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        self.parse_whitespace();
-
-        if self.eof() {
-            return Err(self.error(ErrorCode::EOFWhileParsingValue));
-        }
-
-        if self.ch_is(b'n') {
-            try!(self.parse_ident(b"ull"));
-            visitor.visit_none()
-        } else {
-            visitor.visit_some(self)
-        }
-    }
-
-    #[inline]
-    fn visit_enum<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        self.parse_whitespace();
-
-        if self.ch_is(b'{') {
-            self.bump();
-            self.parse_whitespace();
-
-            try!(self.parse_string());
-            try!(self.parse_object_colon());
-
-            let variant = str::from_utf8(&self.buf).unwrap().to_string();
-
-            let value = try!(visitor.visit_variant(&variant, EnumVisitor {
-                de: self,
-            }));
-
-            self.parse_whitespace();
-
-            if self.ch_is(b'}') {
-                self.bump();
-                Ok(value)
-            } else {
-                return Err(self.error(ErrorCode::ExpectedSomeValue));
-            }
-        } else {
-            Err(self.error(ErrorCode::ExpectedSomeValue))
-        }
-    }
-}
-
-struct SeqVisitor<'a, Iter: 'a> {
-    de: &'a mut Deserializer<Iter>,
-    first: bool,
-}
-
-impl<'a, Iter> SeqVisitor<'a, Iter> {
-    fn new(de: &'a mut Deserializer<Iter>) -> Self {
-        SeqVisitor {
-            de: de,
-            first: true,
-        }
-    }
-}
-
-impl<'a, Iter> de::SeqVisitor for SeqVisitor<'a, Iter>
-    where Iter: Iterator<Item=u8>
-{
-    type Error = Error;
-
-    fn visit<T>(&mut self) -> Result<Option<T>, Error>
-        where T: de::Deserialize,
-    {
-        self.de.parse_whitespace();
-
-        if self.de.ch_is(b']') {
-            self.de.bump();
-            return Ok(None);
-        }
-
-        if self.first {
-            self.first = false;
-        } else {
-            if self.de.ch_is(b',') {
-                self.de.bump();
-            } else if self.de.eof() {
-                return Err(self.de.error(ErrorCode::EOFWhileParsingList));
-            } else {
-                return Err(self.de.error(ErrorCode::ExpectedListCommaOrEnd));
-            }
-        }
-
-        let value = try!(de::Deserialize::deserialize(self.de));
-        Ok(Some(value))
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        self.de.parse_whitespace();
-
-        if self.de.ch_is(b']') {
-            self.de.bump();
-            Ok(())
-        } else if self.de.eof() {
-            Err(self.de.error(ErrorCode::EOFWhileParsingList))
-        } else {
-            Err(self.de.error(ErrorCode::TrailingCharacters))
-        }
-    }
-}
-
-struct MapVisitor<'a, Iter: 'a> {
-    de: &'a mut Deserializer<Iter>,
-    first: bool,
-}
-
-impl<'a, Iter> MapVisitor<'a, Iter> {
-    fn new(de: &'a mut Deserializer<Iter>) -> Self {
-        MapVisitor {
-            de: de,
-            first: true,
-        }
-    }
-}
-
-impl<'a, Iter> de::MapVisitor for MapVisitor<'a, Iter>
-    where Iter: Iterator<Item=u8>
-{
-    type Error = Error;
-
-    fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
-        where K: de::Deserialize,
-    {
-        self.de.parse_whitespace();
-
-        if self.de.ch_is(b'}') {
-            self.de.bump();
-            return Ok(None);
-        }
-
-        if self.first {
-            self.first = false;
-        } else {
-            if self.de.ch_is(b',') {
-                self.de.bump();
-                self.de.parse_whitespace();
-            } else if self.de.eof() {
-                return Err(self.de.error(ErrorCode::EOFWhileParsingObject));
-            } else {
-                return Err(self.de.error(ErrorCode::ExpectedObjectCommaOrEnd));
-            }
-        }
-
-        if self.de.eof() {
-            return Err(self.de.error(ErrorCode::EOFWhileParsingValue));
-        }
-
-        if !self.de.ch_is(b'"') {
-            return Err(self.de.error(ErrorCode::KeyMustBeAString));
-        }
-
-        Ok(Some(try!(de::Deserialize::deserialize(self.de))))
-    }
-
-    fn visit_value<V>(&mut self) -> Result<V, Error>
-        where V: de::Deserialize,
-    {
-        try!(self.de.parse_object_colon());
-
-        Ok(try!(de::Deserialize::deserialize(self.de)))
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        self.de.parse_whitespace();
-
-        if self.de.ch_is(b']') {
-            self.de.bump();
-            Ok(())
-        } else if self.de.eof() {
-            Err(self.de.error(ErrorCode::EOFWhileParsingList))
-        } else {
-            Err(self.de.error(ErrorCode::TrailingCharacters))
-        }
-    }
-}
-
-struct EnumVisitor<'a, Iter: 'a> {
-    de: &'a mut Deserializer<Iter>,
-}
-
-impl<'a, Iter> de::EnumVisitor for EnumVisitor<'a, Iter>
-    where Iter: Iterator<Item=u8>,
-{
-    type Error = Error;
-
-    fn visit_unit(&mut self) -> Result<(), Error> {
-        de::Deserialize::deserialize(self.de)
-    }
-
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::EnumSeqVisitor,
-    {
-        self.de.parse_whitespace();
-
-        if self.de.ch_is(b'[') {
-            self.de.bump();
-            visitor.visit(SeqVisitor::new(self.de))
-        } else {
-            Err(self.de.error(ErrorCode::ExpectedSomeValue))
-        }
-    }
-
-    fn visit_map<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::EnumMapVisitor,
-    {
-        self.de.parse_whitespace();
-
-        if self.de.ch_is(b'{') {
-            self.de.bump();
-            visitor.visit(MapVisitor::new(self.de))
-        } else {
-            Err(self.de.error(ErrorCode::ExpectedSomeValue))
-        }
-    }
-}
-
-/// Decodes a json value from an `Iterator<u8>`.
-pub fn from_iter<I, T>(iter: I) -> Result<T, Error>
-    where I: Iterator<Item=u8>,
-          T: de::Deserialize
-{
-    let mut de = Deserializer::new(iter);
-    let value = try!(de::Deserialize::deserialize(&mut de));
-
-    // Make sure the whole stream has been consumed.
-    try!(de.end());
-    Ok(value)
-}
-
-/// Decodes a json value from a string
-pub fn from_str<'a, T>(s: &'a str) -> Result<T, Error>
-    where T: de::Deserialize
-{
-    from_iter(s.bytes())
-}

src/json/mod.rs

@@ -1,19 +0,0 @@
-pub use self::de::{Deserializer, from_str};
-pub use self::error::{Error, ErrorCode};
-pub use self::ser::{
-    Serializer,
-    to_writer,
-    to_writer_pretty,
-    to_vec,
-    to_vec_pretty,
-    to_string,
-    to_string_pretty,
-    escape_str,
-};
-pub use self::value::{Value, to_value, from_value};
-
-pub mod builder;
-pub mod de;
-pub mod error;
-pub mod ser;
-pub mod value;

src/json/ser.rs

@@ -1,457 +0,0 @@
-use std::{f32, f64};
-use std::io;
-use std::num::{Float, FpCategory};
-use std::string::FromUtf8Error;
-
-use ser;
-
-/// A structure for implementing serialization to JSON.
-pub struct Serializer<W> {
-    writer: W,
-    format: Format,
-    current_indent: usize,
-    indent: usize,
-}
-
-#[derive(Copy, PartialEq)]
-enum Format {
-    Compact,
-    Pretty,
-}
-
-impl<W: io::Write> Serializer<W> {
-    /// Creates a new JSON visitr whose output will be written to the writer
-    /// specified.
-    #[inline]
-    pub fn new(writer: W) -> Serializer<W> {
-        Serializer {
-            writer: writer,
-            format: Format::Compact,
-            current_indent: 0,
-            indent: 0,
-        }
-    }
-
-    /// Creates a new JSON visitr whose output will be written to the writer
-    /// specified.
-    #[inline]
-    pub fn new_pretty(writer: W) -> Serializer<W> {
-        Serializer {
-            writer: writer,
-            format: Format::Pretty,
-            current_indent: 0,
-            indent: 2,
-        }
-    }
-
-    /// Unwrap the `Writer` from the `Serializer`.
-    #[inline]
-    pub fn into_inner(self) -> W {
-        self.writer
-    }
-}
-
-impl<W: io::Write> ser::Serializer for Serializer<W> {
-    type Value = ();
-    type Error = io::Error;
-
-    #[inline]
-    fn visit<T>(&mut self, value: &T) -> io::Result<()>
-        where T: ser::Serialize,
-    {
-        value.visit(&mut Visitor {
-            writer: &mut self.writer,
-            format: self.format,
-            current_indent: self.current_indent,
-            indent: self.indent,
-        })
-    }
-}
-
-struct Visitor<'a, W: 'a> {
-    writer: &'a mut W,
-    format: Format,
-    current_indent: usize,
-    indent: usize,
-}
-
-impl<'a, W> Visitor<'a, W> where W: io::Write, {
-    fn serialize_sep(&mut self, first: bool) -> io::Result<()> {
-        match self.format {
-            Format::Compact => {
-                if first {
-                    Ok(())
-                } else {
-                    self.writer.write_all(b",")
-                }
-            }
-            Format::Pretty => {
-                if first {
-                    self.current_indent += self.indent;
-                    try!(self.writer.write_all(b"\n"));
-                } else {
-                    try!(self.writer.write_all(b",\n"));
-                }
-
-                spaces(&mut self.writer, self.current_indent)
-            }
-        }
-    }
-
-    fn serialize_colon(&mut self) -> io::Result<()> {
-        match self.format {
-            Format::Compact => self.writer.write_all(b":"),
-            Format::Pretty => self.writer.write_all(b": "),
-        }
-    }
-
-    fn serialize_end(&mut self, current_indent: usize, s: &[u8]) -> io::Result<()> {
-        if self.format == Format::Pretty && current_indent != self.current_indent {
-            self.current_indent -= self.indent;
-            try!(self.writer.write(b"\n"));
-            try!(spaces(&mut self.writer, self.current_indent));
-        }
-
-        self.writer.write_all(s)
-    }
-}
-
-impl<'a, W> ser::Visitor for Visitor<'a, W> where W: io::Write, {
-    type Value = ();
-    type Error = io::Error;
-
-    #[inline]
-    fn visit_bool(&mut self, value: bool) -> io::Result<()> {
-        if value {
-            self.writer.write_all(b"true")
-        } else {
-            self.writer.write_all(b"false")
-        }
-    }
-
-    #[inline]
-    fn visit_isize(&mut self, value: isize) -> io::Result<()> {
-        write!(self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_i8(&mut self, value: i8) -> io::Result<()> {
-        write!(self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_i16(&mut self, value: i16) -> io::Result<()> {
-        write!(self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_i32(&mut self, value: i32) -> io::Result<()> {
-        write!(self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_i64(&mut self, value: i64) -> io::Result<()> {
-        write!(self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_usize(&mut self, value: usize) -> io::Result<()> {
-        write!(self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_u8(&mut self, value: u8) -> io::Result<()> {
-        write!(self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_u16(&mut self, value: u16) -> io::Result<()> {
-        write!(self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_u32(&mut self, value: u32) -> io::Result<()> {
-        write!(self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_u64(&mut self, value: u64) -> io::Result<()> {
-        write!(self.writer, "{}", value)
-    }
-
-    #[inline]
-    fn visit_f32(&mut self, value: f32) -> io::Result<()> {
-        fmt_f32_or_null(self.writer, value)
-    }
-
-    #[inline]
-    fn visit_f64(&mut self, value: f64) -> io::Result<()> {
-        fmt_f64_or_null(self.writer, value)
-    }
-
-    #[inline]
-    fn visit_char(&mut self, value: char) -> io::Result<()> {
-        escape_char(self.writer, value)
-    }
-
-    #[inline]
-    fn visit_str(&mut self, value: &str) -> io::Result<()> {
-        escape_str(self.writer, value)
-    }
-
-    #[inline]
-    fn visit_none(&mut self) -> io::Result<()> {
-        self.visit_unit()
-    }
-
-    #[inline]
-    fn visit_some<V>(&mut self, value: V) -> io::Result<()>
-        where V: ser::Serialize
-    {
-        value.visit(self)
-    }
-
-    #[inline]
-    fn visit_unit(&mut self) -> io::Result<()> {
-        self.writer.write_all(b"null")
-    }
-
-    #[inline]
-    fn visit_enum_unit(&mut self, _name: &str, variant: &str) -> io::Result<()> {
-        let current_indent = self.current_indent;
-
-        try!(self.writer.write_all(b"{"));
-        try!(self.serialize_sep(true));
-        try!(self.visit_str(variant));
-        try!(self.serialize_colon());
-        try!(self.writer.write_all(b"[]"));
-        self.serialize_end(current_indent, b"}")
-    }
-
-    #[inline]
-    fn visit_seq<V>(&mut self, mut visitor: V) -> io::Result<()>
-        where V: ser::SeqVisitor,
-    {
-        let current_indent = self.current_indent;
-
-        try!(self.writer.write_all(b"["));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        self.serialize_end(current_indent, b"]")
-    }
-
-    #[inline]
-    fn visit_enum_seq<V>(&mut self, _name: &str, variant: &str, visitor: V) -> io::Result<()>
-        where V: ser::SeqVisitor,
-    {
-        let current_indent = self.current_indent;
-
-        try!(self.writer.write_all(b"{"));
-        try!(self.serialize_sep(true));
-        try!(self.visit_str(variant));
-        try!(self.serialize_colon());
-        try!(self.visit_seq(visitor));
-        self.serialize_end(current_indent, b"}")
-    }
-
-    #[inline]
-    fn visit_seq_elt<T>(&mut self, first: bool, value: T) -> io::Result<()>
-        where T: ser::Serialize,
-    {
-        try!(self.serialize_sep(first));
-
-        value.visit(self)
-    }
-
-    #[inline]
-    fn visit_map<V>(&mut self, mut visitor: V) -> io::Result<()>
-        where V: ser::MapVisitor,
-    {
-        let current_indent = self.current_indent;
-
-        try!(self.writer.write_all(b"{"));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        self.serialize_end(current_indent, b"}")
-    }
-
-    #[inline]
-    fn visit_enum_map<V>(&mut self, _name: &str, variant: &str, visitor: V) -> io::Result<()>
-        where V: ser::MapVisitor,
-    {
-        let current_indent = self.current_indent;
-
-        try!(self.writer.write_all(b"{"));
-        try!(self.serialize_sep(true));
-        try!(self.visit_str(variant));
-        try!(self.serialize_colon());
-        try!(self.visit_map(visitor));
-        self.serialize_end(current_indent, b"}")
-    }
-
-    #[inline]
-    fn visit_map_elt<K, V>(&mut self, first: bool, key: K, value: V) -> io::Result<()>
-        where K: ser::Serialize,
-              V: ser::Serialize,
-    {
-        try!(self.serialize_sep(first));
-        try!(key.visit(self));
-        try!(self.serialize_colon());
-        value.visit(self)
-    }
-}
-
-#[inline]
-pub fn escape_bytes<W>(wr: &mut W, bytes: &[u8]) -> io::Result<()>
-    where W: io::Write
-{
-    try!(wr.write_all(b"\""));
-
-    let mut start = 0;
-
-    for (i, byte) in bytes.iter().enumerate() {
-        let escaped = match *byte {
-            b'"' => b"\\\"",
-            b'\\' => b"\\\\",
-            b'\x08' => b"\\b",
-            b'\x0c' => b"\\f",
-            b'\n' => b"\\n",
-            b'\r' => b"\\r",
-            b'\t' => b"\\t",
-            _ => { continue; }
-        };
-
-        if start < i {
-            try!(wr.write_all(&bytes[start..i]));
-        }
-
-        try!(wr.write_all(escaped));
-
-        start = i + 1;
-    }
-
-    if start != bytes.len() {
-        try!(wr.write_all(&bytes[start..]));
-    }
-
-    try!(wr.write_all(b"\""));
-    Ok(())
-}
-
-#[inline]
-pub fn escape_str<W>(wr: &mut W, value: &str) -> io::Result<()>
-    where W: io::Write
-{
-    escape_bytes(wr, value.as_bytes())
-}
-
-#[inline]
-fn escape_char<W>(wr: &mut W, value: char) -> io::Result<()>
-    where W: io::Write
-{
-    let buf = &mut [0; 4];
-    value.encode_utf8(buf);
-    escape_bytes(wr, buf)
-}
-
-fn fmt_f32_or_null<W>(wr: &mut W, value: f32) -> io::Result<()>
-    where W: io::Write
-{
-    match value.classify() {
-        FpCategory::Nan | FpCategory::Infinite => wr.write_all(b"null"),
-        _ => wr.write_all(f32::to_str_digits(value, 6).as_bytes()),
-    }
-}
-
-fn fmt_f64_or_null<W>(wr: &mut W, value: f64) -> io::Result<()>
-    where W: io::Write
-{
-    match value.classify() {
-        FpCategory::Nan | FpCategory::Infinite => wr.write_all(b"null"),
-        _ => wr.write_all(f64::to_str_digits(value, 6).as_bytes()),
-    }
-}
-
-/// Encode the specified struct into a json `[u8]` writer.
-#[inline]
-pub fn to_writer<W, T>(writer: &mut W, value: &T) -> io::Result<()>
-    where W: io::Write,
-          T: ser::Serialize,
-{
-    let mut ser = Serializer::new(writer);
-    try!(ser::Serializer::visit(&mut ser, value));
-    Ok(())
-}
-
-/// Encode the specified struct into a json `[u8]` writer.
-#[inline]
-pub fn to_writer_pretty<W, T>(writer: &mut W, value: &T) -> io::Result<()>
-    where W: io::Write,
-          T: ser::Serialize,
-{
-    let mut ser = Serializer::new_pretty(writer);
-    try!(ser::Serializer::visit(&mut ser, value));
-    Ok(())
-}
-
-/// Encode the specified struct into a json `[u8]` buffer.
-#[inline]
-pub fn to_vec<T>(value: &T) -> Vec<u8>
-    where T: ser::Serialize,
-{
-    // We are writing to a Vec, which doesn't fail. So we can ignore
-    // the error.
-    let mut writer = Vec::with_capacity(128);
-    to_writer(&mut writer, value).unwrap();
-    writer
-}
-
-/// Encode the specified struct into a json `[u8]` buffer.
-#[inline]
-pub fn to_vec_pretty<T>(value: &T) -> Vec<u8>
-    where T: ser::Serialize,
-{
-    // We are writing to a Vec, which doesn't fail. So we can ignore
-    // the error.
-    let mut writer = Vec::with_capacity(128);
-    to_writer_pretty(&mut writer, value).unwrap();
-    writer
-}
-
-/// Encode the specified struct into a json `String` buffer.
-#[inline]
-pub fn to_string<T>(value: &T) -> Result<String, FromUtf8Error>
-    where T: ser::Serialize
-{
-    let vec = to_vec(value);
-    String::from_utf8(vec)
-}
-
-/// Encode the specified struct into a json `String` buffer.
-#[inline]
-pub fn to_string_pretty<T>(value: &T) -> Result<String, FromUtf8Error>
-    where T: ser::Serialize
-{
-    let vec = to_vec_pretty(value);
-    String::from_utf8(vec)
-}
-
-fn spaces<W>(wr: &mut W, mut n: usize) -> io::Result<()>
-    where W: io::Write,
-{
-    const LEN: usize = 16;
-    const BUF: &'static [u8; LEN] = &[b' '; 16];
-
-    while n >= LEN {
-        try!(wr.write_all(BUF));
-        n -= LEN;
-    }
-
-    if n > 0 {
-        wr.write_all(&BUF[..n])
-    } else {
-        Ok(())
-    }
-}

src/json/value.rs

@@ -1,604 +0,0 @@
-use std::collections::{BTreeMap, btree_map};
-use std::fmt;
-use std::io;
-use std::str;
-use std::vec;
-
-use de;
-use ser;
-use super::error::Error;
-
-#[derive(Clone, PartialEq)]
-pub enum Value {
-    Null,
-    Bool(bool),
-    I64(i64),
-    F64(f64),
-    String(String),
-    Array(Vec<Value>),
-    Object(BTreeMap<String, Value>),
-}
-
-impl ser::Serialize for Value {
-    #[inline]
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: ser::Visitor,
-    {
-        match *self {
-            Value::Null => visitor.visit_unit(),
-            Value::Bool(v) => visitor.visit_bool(v),
-            Value::I64(v) => visitor.visit_i64(v),
-            Value::F64(v) => visitor.visit_f64(v),
-            Value::String(ref v) => visitor.visit_str(&v),
-            Value::Array(ref v) => v.visit(visitor),
-            Value::Object(ref v) => v.visit(visitor),
-        }
-    }
-}
-
-impl de::Deserialize for Value {
-    #[inline]
-    fn deserialize<D>(deserializer: &mut D) -> Result<Value, D::Error>
-        where D: de::Deserializer,
-    {
-        struct ValueVisitor;
-
-        impl de::Visitor for ValueVisitor {
-            type Value = Value;
-
-            #[inline]
-            fn visit_bool<E>(&mut self, value: bool) -> Result<Value, E> {
-                Ok(Value::Bool(value))
-            }
-
-            #[inline]
-            fn visit_i64<E>(&mut self, value: i64) -> Result<Value, E> {
-                Ok(Value::I64(value))
-            }
-
-            #[inline]
-            fn visit_f64<E>(&mut self, value: f64) -> Result<Value, E> {
-                Ok(Value::F64(value))
-            }
-
-            #[inline]
-            fn visit_str<E>(&mut self, value: &str) -> Result<Value, E>
-                where E: de::Error,
-            {
-                self.visit_string(value.to_string())
-            }
-
-            #[inline]
-            fn visit_string<E>(&mut self, value: String) -> Result<Value, E> {
-                Ok(Value::String(value))
-            }
-
-            #[inline]
-            fn visit_none<E>(&mut self) -> Result<Value, E> {
-                Ok(Value::Null)
-            }
-
-            #[inline]
-            fn visit_some<D>(&mut self, deserializer: &mut D) -> Result<Value, D::Error>
-                where D: de::Deserializer,
-            {
-                de::Deserialize::deserialize(deserializer)
-            }
-
-            #[inline]
-            fn visit_unit<E>(&mut self) -> Result<Value, E> {
-                Ok(Value::Null)
-            }
-
-            #[inline]
-            fn visit_seq<V>(&mut self, visitor: V) -> Result<Value, V::Error>
-                where V: de::SeqVisitor,
-            {
-                let values = try!(de::VecVisitor::new().visit_seq(visitor));
-                Ok(Value::Array(values))
-            }
-
-            #[inline]
-            fn visit_map<V>(&mut self, visitor: V) -> Result<Value, V::Error>
-                where V: de::MapVisitor,
-            {
-                let values = try!(de::BTreeMapVisitor::new().visit_map(visitor));
-                Ok(Value::Object(values))
-            }
-        }
-
-        deserializer.visit(ValueVisitor)
-    }
-}
-
-struct WriterFormatter<'a, 'b: 'a> {
-    inner: &'a mut fmt::Formatter<'b>,
-}
-
-impl<'a, 'b> io::Write for WriterFormatter<'a, 'b> {
-    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        match self.inner.write_str(str::from_utf8(buf).unwrap()) {
-            Ok(_) => Ok(buf.len()),
-            Err(_) => Err(io::Error::last_os_error()),
-        }
-    }
-
-    fn flush(&mut self) -> io::Result<()> {
-        Ok(())
-    }
-}
-
-impl fmt::Debug for Value {
-    /// Serializes a json value into a string
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut wr = WriterFormatter { inner: f };
-        super::ser::to_writer(&mut wr, self).map_err(|_| fmt::Error)
-    }
-}
-
-#[derive(Debug)]
-enum State {
-    Value(Value),
-    Array(Vec<Value>),
-    Object(BTreeMap<String, Value>),
-}
-
-pub struct Serializer {
-    state: Vec<State>,
-}
-
-impl Serializer {
-    pub fn new() -> Serializer {
-        Serializer {
-            state: Vec::with_capacity(4),
-        }
-    }
-
-    pub fn unwrap(mut self) -> Value {
-        match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        }
-    }
-}
-
-impl ser::Serializer for Serializer {
-    type Value = ();
-    type Error = ();
-
-    #[inline]
-    fn visit<T>(&mut self, value: &T) -> Result<(), ()>
-        where T: ser::Serialize,
-    {
-        try!(value.visit(self));
-        Ok(())
-    }
-}
-
-impl ser::Visitor for Serializer {
-    type Value = ();
-    type Error = ();
-
-    #[inline]
-    fn visit_bool(&mut self, value: bool) -> Result<(), ()> {
-        self.state.push(State::Value(Value::Bool(value)));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_i64(&mut self, value: i64) -> Result<(), ()> {
-        self.state.push(State::Value(Value::I64(value)));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_u64(&mut self, value: u64) -> Result<(), ()> {
-        self.state.push(State::Value(Value::I64(value as i64)));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_f64(&mut self, value: f64) -> Result<(), ()> {
-        self.state.push(State::Value(Value::F64(value as f64)));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_char(&mut self, value: char) -> Result<(), ()> {
-        self.state.push(State::Value(Value::String(value.to_string())));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_str(&mut self, value: &str) -> Result<(), ()> {
-        self.state.push(State::Value(Value::String(value.to_string())));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_none(&mut self) -> Result<(), ()> {
-        self.visit_unit()
-    }
-
-    #[inline]
-    fn visit_some<V>(&mut self, value: V) -> Result<(), ()>
-        where V: ser::Serialize,
-    {
-        value.visit(self)
-    }
-
-    #[inline]
-    fn visit_unit(&mut self) -> Result<(), ()> {
-        self.state.push(State::Value(Value::Null));
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_enum_unit(&mut self, _name: &str, variant: &str) -> Result<(), ()> {
-        let mut values = BTreeMap::new();
-        values.insert(variant.to_string(), Value::Array(vec![]));
-
-        self.state.push(State::Value(Value::Object(values)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<(), ()>
-        where V: ser::SeqVisitor,
-    {
-        let len = match visitor.size_hint() {
-            (_, Some(len)) => len,
-            (len, None) => len,
-        };
-
-        let values = Vec::with_capacity(len);
-
-        self.state.push(State::Array(values));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        let values = match self.state.pop().unwrap() {
-            State::Array(values) => values,
-            state => panic!("Expected array, found {:?}", state),
-        };
-
-        self.state.push(State::Value(Value::Array(values)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_enum_seq<V>(&mut self, _name: &str, variant: &str, visitor: V) -> Result<(), ()>
-        where V: ser::SeqVisitor,
-    {
-        try!(self.visit_seq(visitor));
-
-        let value = match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        };
-
-        let mut object = BTreeMap::new();
-
-        object.insert(variant.to_string(), value);
-
-        self.state.push(State::Value(Value::Object(object)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_seq_elt<T>(&mut self, _first: bool, value: T) -> Result<(), ()>
-        where T: ser::Serialize,
-    {
-        try!(value.visit(self));
-
-        let value = match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        };
-
-        match *self.state.last_mut().unwrap() {
-            State::Array(ref mut values) => { values.push(value); }
-            ref state => panic!("expected array, found {:?}", state),
-        }
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_map<V>(&mut self, mut visitor: V) -> Result<(), ()>
-        where V: ser::MapVisitor,
-    {
-        let values = BTreeMap::new();
-
-        self.state.push(State::Object(values));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        let values = match self.state.pop().unwrap() {
-            State::Object(values) => values,
-            state => panic!("expected object, found {:?}", state),
-        };
-
-        self.state.push(State::Value(Value::Object(values)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_enum_map<V>(&mut self, _name: &str, variant: &str, visitor: V) -> Result<(), ()>
-        where V: ser::MapVisitor,
-    {
-        try!(self.visit_map(visitor));
-
-        let value = match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        };
-
-        let mut object = BTreeMap::new();
-
-        object.insert(variant.to_string(), value);
-
-        self.state.push(State::Value(Value::Object(object)));
-
-        Ok(())
-    }
-
-    #[inline]
-    fn visit_map_elt<K, V>(&mut self, _first: bool, key: K, value: V) -> Result<(), ()>
-        where K: ser::Serialize,
-              V: ser::Serialize,
-    {
-        try!(key.visit(self));
-
-        let key = match self.state.pop().unwrap() {
-            State::Value(Value::String(value)) => value,
-            state => panic!("expected key, found {:?}", state),
-        };
-
-        try!(value.visit(self));
-
-        let value = match self.state.pop().unwrap() {
-            State::Value(value) => value,
-            state => panic!("expected value, found {:?}", state),
-        };
-
-        match *self.state.last_mut().unwrap() {
-            State::Object(ref mut values) => { values.insert(key, value); }
-            ref state => panic!("expected object, found {:?}", state),
-        }
-
-        Ok(())
-    }
-}
-
-pub struct Deserializer {
-    value: Option<Value>,
-}
-
-impl Deserializer {
-    /// Creates a new deserializer instance for deserializing the specified JSON value.
-    pub fn new(value: Value) -> Deserializer {
-        Deserializer {
-            value: Some(value),
-        }
-    }
-}
-
-impl de::Deserializer for Deserializer {
-    type Error = Error;
-
-    #[inline]
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        let value = match self.value.take() {
-            Some(value) => value,
-            None => { return Err(de::Error::end_of_stream_error()); }
-        };
-
-        match value {
-            Value::Null => visitor.visit_unit(),
-            Value::Bool(v) => visitor.visit_bool(v),
-            Value::I64(v) => visitor.visit_i64(v),
-            Value::F64(v) => visitor.visit_f64(v),
-            Value::String(v) => visitor.visit_string(v),
-            Value::Array(v) => {
-                let len = v.len();
-                visitor.visit_seq(SeqDeserializer {
-                    de: self,
-                    iter: v.into_iter(),
-                    len: len,
-                })
-            }
-            Value::Object(v) => {
-                let len = v.len();
-                visitor.visit_map(MapDeserializer {
-                    de: self,
-                    iter: v.into_iter(),
-                    value: None,
-                    len: len,
-                })
-            }
-        }
-    }
-
-    #[inline]
-    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        match self.value {
-            Some(Value::Null) => visitor.visit_none(),
-            Some(_) => visitor.visit_some(self),
-            None => Err(de::Error::end_of_stream_error()),
-        }
-    }
-
-    #[inline]
-    fn visit_enum<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        let value = match self.value.take() {
-            Some(Value::Object(value)) => value,
-            Some(_) => { return Err(de::Error::syntax_error()); }
-            None => { return Err(de::Error::end_of_stream_error()); }
-        };
-
-        let mut iter = value.into_iter();
-
-        let value = match iter.next() {
-            Some((variant, Value::Array(fields))) => {
-                let len = fields.len();
-                try!(visitor.visit_variant(&variant, SeqDeserializer {
-                    de: self,
-                    iter: fields.into_iter(),
-                    len: len,
-                }))
-            }
-            Some((variant, Value::Object(fields))) => {
-                let len = fields.len();
-                try!(visitor.visit_variant(&variant, MapDeserializer {
-                    de: self,
-                    iter: fields.into_iter(),
-                    value: None,
-                    len: len,
-                }))
-            }
-            Some(_) => { return Err(de::Error::syntax_error()); }
-            None => { return Err(de::Error::syntax_error()); }
-        };
-
-        match iter.next() {
-            Some(_) => Err(de::Error::syntax_error()),
-            None => Ok(value)
-        }
-    }
-}
-
-struct SeqDeserializer<'a> {
-    de: &'a mut Deserializer,
-    iter: vec::IntoIter<Value>,
-    len: usize,
-}
-
-impl<'a> de::SeqVisitor for SeqDeserializer<'a> {
-    type Error = Error;
-
-    fn visit<T>(&mut self) -> Result<Option<T>, Error>
-        where T: de::Deserialize
-    {
-        match self.iter.next() {
-            Some(value) => {
-                self.len -= 1;
-                self.de.value = Some(value);
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        if self.len == 0 {
-            Ok(())
-        } else {
-            Err(de::Error::end_of_stream_error())
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-impl<'a> de::EnumVisitor for SeqDeserializer<'a> {
-    type Error = Error;
-
-    fn visit_unit(&mut self) -> Result<(), Error> {
-        if self.len == 0 {
-            Ok(())
-        } else {
-            Err(de::Error::syntax_error())
-        }
-    }
-
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::EnumSeqVisitor,
-    {
-        visitor.visit(self)
-    }
-}
-
-struct MapDeserializer<'a> {
-    de: &'a mut Deserializer,
-    iter: btree_map::IntoIter<String, Value>,
-    value: Option<Value>,
-    len: usize,
-}
-
-impl<'a> de::MapVisitor for MapDeserializer<'a> {
-    type Error = Error;
-
-    fn visit_key<T>(&mut self) -> Result<Option<T>, Error>
-        where T: de::Deserialize
-    {
-        match self.iter.next() {
-            Some((key, value)) => {
-                self.len -= 1;
-                self.value = Some(value);
-                self.de.value = Some(Value::String(key));
-                Ok(Some(try!(de::Deserialize::deserialize(self.de))))
-            }
-            None => Ok(None),
-        }
-    }
-
-    fn visit_value<T>(&mut self) -> Result<T, Error>
-        where T: de::Deserialize
-    {
-        let value = self.value.take().unwrap();
-        self.de.value = Some(value);
-        Ok(try!(de::Deserialize::deserialize(self.de)))
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        if self.len == 0 {
-            Ok(())
-        } else {
-            Err(de::Error::end_of_stream_error())
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-impl<'a> de::EnumVisitor for MapDeserializer<'a> {
-    type Error = Error;
-
-    fn visit_map<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::EnumMapVisitor,
-    {
-        visitor.visit(self)
-    }
-}
-
-/// Shortcut function to encode a `T` into a JSON `Value`
-pub fn to_value<T>(value: &T) -> Value
-    where T: ser::Serialize
-{
-    let mut ser = Serializer::new();
-    ser::Serializer::visit(&mut ser, value).ok().unwrap();
-    ser.unwrap()
-}
-
-/// Shortcut function to decode a JSON `Value` into a `T`
-pub fn from_value<T>(value: Value) -> Result<T, Error>
-    where T: de::Deserialize
-{
-    let mut de = Deserializer::new(value);
-    de::Deserialize::deserialize(&mut de)
-}

src/lib.rs

@@ -1,10 +0,0 @@
-#![feature(core, io, path, std_misc, unicode)]
-
-extern crate unicode;
-
-pub use ser::{Serialize, Serializer};
-pub use de::{Deserialize, Deserializer, Error};
-
-pub mod ser;
-pub mod de;
-pub mod json;

src/ser.rs

@@ -1,660 +0,0 @@
-use std::collections::hash_state::HashState;
-use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
-use std::hash::Hash;
-use std::path;
-use std::rc::Rc;
-use std::str;
-use std::sync::Arc;
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub trait Serialize {
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub trait Serializer {
-    type Value;
-    type Error;
-
-    fn visit<T>(&mut self, value: &T) -> Result<Self::Value, Self::Error>
-        where T: Serialize;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub trait Visitor {
-    type Value;
-    type Error;
-
-    fn visit_bool(&mut self, v: bool) -> Result<Self::Value, Self::Error>;
-
-    #[inline]
-    fn visit_isize(&mut self, v: isize) -> Result<Self::Value, Self::Error> {
-        self.visit_i64(v as i64)
-    }
-
-    #[inline]
-    fn visit_i8(&mut self, v: i8) -> Result<Self::Value, Self::Error> {
-        self.visit_i64(v as i64)
-    }
-
-    #[inline]
-    fn visit_i16(&mut self, v: i16) -> Result<Self::Value, Self::Error> {
-        self.visit_i64(v as i64)
-    }
-
-    #[inline]
-    fn visit_i32(&mut self, v: i32) -> Result<Self::Value, Self::Error> {
-        self.visit_i64(v as i64)
-    }
-
-    #[inline]
-    fn visit_i64(&mut self, v: i64) -> Result<Self::Value, Self::Error>;
-
-    #[inline]
-    fn visit_usize(&mut self, v: usize) -> Result<Self::Value, Self::Error> {
-        self.visit_u64(v as u64)
-    }
-
-    #[inline]
-    fn visit_u8(&mut self, v: u8) -> Result<Self::Value, Self::Error> {
-        self.visit_u64(v as u64)
-    }
-
-    #[inline]
-    fn visit_u16(&mut self, v: u16) -> Result<Self::Value, Self::Error> {
-        self.visit_u64(v as u64)
-    }
-
-    #[inline]
-    fn visit_u32(&mut self, v: u32) -> Result<Self::Value, Self::Error> {
-        self.visit_u64(v as u64)
-    }
-
-    #[inline]
-    fn visit_u64(&mut self, v: u64) -> Result<Self::Value, Self::Error>;
-
-    #[inline]
-    fn visit_f32(&mut self, v: f32) -> Result<Self::Value, Self::Error> {
-        self.visit_f64(v as f64)
-    }
-
-    fn visit_f64(&mut self, v: f64) -> Result<Self::Value, Self::Error>;
-
-    #[inline]
-    fn visit_char(&mut self, v: char) -> Result<Self::Value, Self::Error> {
-        // The unwraps in here should be safe.
-        let mut s = &mut [0; 4];
-        let len = v.encode_utf8(s).unwrap();
-        self.visit_str(str::from_utf8(&s[..len]).unwrap())
-    }
-
-    fn visit_str(&mut self, value: &str) -> Result<Self::Value, Self::Error>;
-
-    fn visit_unit(&mut self) -> Result<Self::Value, Self::Error>;
-
-    #[inline]
-    fn visit_named_unit(&mut self, _name: &str) -> Result<Self::Value, Self::Error> {
-        self.visit_unit()
-    }
-
-    #[inline]
-    fn visit_enum_unit(&mut self,
-                       _name: &str,
-                       _variant: &str) -> Result<Self::Value, Self::Error> {
-        self.visit_unit()
-    }
-
-    fn visit_none(&mut self) -> Result<Self::Value, Self::Error>;
-
-    fn visit_some<V>(&mut self, value: V) -> Result<Self::Value, Self::Error>
-        where V: Serialize;
-
-    fn visit_seq<V>(&mut self, visitor: V) -> Result<Self::Value, Self::Error>
-        where V: SeqVisitor;
-
-    #[inline]
-    fn visit_named_seq<V>(&mut self,
-                          _name: &'static str,
-                          visitor: V) -> Result<Self::Value, Self::Error>
-        where V: SeqVisitor,
-    {
-        self.visit_seq(visitor)
-    }
-
-    #[inline]
-    fn visit_enum_seq<V>(&mut self,
-                         _name: &'static str,
-                         _variant: &'static str,
-                         visitor: V) -> Result<Self::Value, Self::Error>
-        where V: SeqVisitor,
-    {
-        self.visit_seq(visitor)
-    }
-
-    fn visit_seq_elt<T>(&mut self,
-                        first: bool,
-                        value: T) -> Result<Self::Value, Self::Error>
-        where T: Serialize;
-
-    fn visit_map<V>(&mut self, visitor: V) -> Result<Self::Value, Self::Error>
-        where V: MapVisitor;
-
-    #[inline]
-    fn visit_named_map<V>(&mut self,
-                          _name: &'static str,
-                          visitor: V) -> Result<Self::Value, Self::Error>
-        where V: MapVisitor,
-    {
-        self.visit_map(visitor)
-    }
-
-    #[inline]
-    fn visit_enum_map<V>(&mut self,
-                          _name: &'static str,
-                          _variant: &'static str,
-                          visitor: V) -> Result<Self::Value, Self::Error>
-        where V: MapVisitor,
-    {
-        self.visit_map(visitor)
-    }
-
-    fn visit_map_elt<K, V>(&mut self,
-                           first: bool,
-                           key: K,
-                           value: V) -> Result<Self::Value, Self::Error>
-        where K: Serialize,
-              V: Serialize;
-}
-
-pub trait SeqVisitor {
-    fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error>
-        where V: Visitor;
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, None)
-    }
-}
-
-pub trait MapVisitor {
-    fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error>
-        where V: Visitor;
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, None)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-macro_rules! impl_visit {
-    ($ty:ty, $method:ident) => {
-        impl Serialize for $ty {
-            #[inline]
-            fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-                where V: Visitor,
-            {
-                visitor.$method(*self)
-            }
-        }
-    }
-}
-
-impl_visit!(bool, visit_bool);
-impl_visit!(isize, visit_isize);
-impl_visit!(i8, visit_i8);
-impl_visit!(i16, visit_i16);
-impl_visit!(i32, visit_i32);
-impl_visit!(i64, visit_i64);
-impl_visit!(usize, visit_usize);
-impl_visit!(u8, visit_u8);
-impl_visit!(u16, visit_u16);
-impl_visit!(u32, visit_u32);
-impl_visit!(u64, visit_u64);
-impl_visit!(f32, visit_f32);
-impl_visit!(f64, visit_f64);
-impl_visit!(char, visit_char);
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl<'a> Serialize for &'a str {
-    #[inline]
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        visitor.visit_str(*self)
-    }
-}
-
-impl Serialize for String {
-    #[inline]
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        (&self[..]).visit(visitor)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl<T> Serialize for Option<T> where T: Serialize {
-    #[inline]
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        match *self {
-            Some(ref value) => visitor.visit_some(value),
-            None => visitor.visit_none(),
-        }
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub struct SeqIteratorVisitor<Iter> {
-    iter: Iter,
-    first: bool,
-}
-
-impl<T, Iter> SeqIteratorVisitor<Iter>
-    where Iter: Iterator<Item=T>
-{
-    #[inline]
-    pub fn new(iter: Iter) -> SeqIteratorVisitor<Iter> {
-        SeqIteratorVisitor {
-            iter: iter,
-            first: true,
-        }
-    }
-}
-
-impl<T, Iter> SeqVisitor for SeqIteratorVisitor<Iter>
-    where T: Serialize,
-          Iter: Iterator<Item=T>,
-{
-    #[inline]
-    fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error>
-        where V: Visitor,
-    {
-        let first = self.first;
-        self.first = false;
-
-        match self.iter.next() {
-            Some(value) => {
-                let value = try!(visitor.visit_seq_elt(first, value));
-                Ok(Some(value))
-            }
-            None => Ok(None),
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl<'a, T> Serialize for &'a [T]
-    where T: Serialize,
-{
-    #[inline]
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        visitor.visit_seq(SeqIteratorVisitor::new(self.iter()))
-    }
-}
-
-impl<T> Serialize for Vec<T> where T: Serialize {
-    #[inline]
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        (&self[..]).visit(visitor)
-    }
-}
-
-impl<T> Serialize for BTreeSet<T> where T: Serialize {
-    #[inline]
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        visitor.visit_seq(SeqIteratorVisitor::new(self.iter()))
-    }
-}
-
-impl<T, S> Serialize for HashSet<T, S>
-    where T: Serialize + Eq + Hash,
-          S: HashState,
-{
-    #[inline]
-    fn visit<V: Visitor>(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
-        visitor.visit_seq(SeqIteratorVisitor::new(self.iter()))
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl Serialize for () {
-    #[inline]
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        visitor.visit_unit()
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-// FIXME(rust #19630) Remove this work-around
-macro_rules! e {
-    ($e:expr) => { $e }
-}
-
-macro_rules! tuple_impls {
-    ($(
-        $TupleVisitor:ident ($len:expr, $($T:ident),+) {
-            $($state:pat => $idx:tt,)+
-        }
-    )+) => {
-        $(
-            pub struct $TupleVisitor<'a, $($T: 'a),+> {
-                tuple: &'a ($($T,)+),
-                state: u8,
-                first: bool,
-            }
-
-            impl<'a, $($T: 'a),+> $TupleVisitor<'a, $($T),+> {
-                pub fn new(tuple: &'a ($($T,)+)) -> $TupleVisitor<'a, $($T),+> {
-                    $TupleVisitor {
-                        tuple: tuple,
-                        state: 0,
-                        first: true,
-                    }
-                }
-            }
-
-            impl<'a, $($T),+> SeqVisitor for $TupleVisitor<'a, $($T),+>
-                where $($T: Serialize),+
-            {
-                fn visit<V>(&mut self, visitor: &mut V) -> Result<Option<V::Value>, V::Error>
-                    where V: Visitor,
-                {
-                    let first = self.first;
-                    self.first = false;
-
-                    match self.state {
-                        $(
-                            $state => {
-                                self.state += 1;
-                                Ok(Some(try!(visitor.visit_seq_elt(first, &e!(self.tuple.$idx)))))
-                            }
-                        )+
-                        _ => {
-                            Ok(None)
-                        }
-                    }
-                }
-
-                fn size_hint(&self) -> (usize, Option<usize>) {
-                    ($len, Some($len))
-                }
-            }
-
-            impl<$($T),+> Serialize for ($($T,)+)
-                where $($T: Serialize),+
-            {
-                #[inline]
-                fn visit<V: Visitor>(&self, visitor: &mut V) -> Result<V::Value, V::Error> {
-                    visitor.visit_seq($TupleVisitor::new(self))
-                }
-            }
-        )+
-    }
-}
-
-tuple_impls! {
-    TupleVisitor1 (1, T0) {
-        0 => 0,
-    }
-    TupleVisitor2 (2, T0, T1) {
-        0 => 0,
-        1 => 1,
-    }
-    TupleVisitor3 (3, T0, T1, T2) {
-        0 => 0,
-        1 => 1,
-        2 => 2,
-    }
-    TupleVisitor4 (4, T0, T1, T2, T3) {
-        0 => 0,
-        1 => 1,
-        2 => 2,
-        3 => 3,
-    }
-    TupleVisitor5 (5, T0, T1, T2, T3, T4) {
-        0 => 0,
-        1 => 1,
-        2 => 2,
-        3 => 3,
-        4 => 4,
-    }
-    TupleVisitor6 (6, T0, T1, T2, T3, T4, T5) {
-        0 => 0,
-        1 => 1,
-        2 => 2,
-        3 => 3,
-        4 => 4,
-        5 => 5,
-    }
-    TupleVisitor7 (7, T0, T1, T2, T3, T4, T5, T6) {
-        0 => 0,
-        1 => 1,
-        2 => 2,
-        3 => 3,
-        4 => 4,
-        5 => 5,
-        6 => 6,
-    }
-    TupleVisitor8 (8, T0, T1, T2, T3, T4, T5, T6, T7) {
-        0 => 0,
-        1 => 1,
-        2 => 2,
-        3 => 3,
-        4 => 4,
-        5 => 5,
-        6 => 6,
-        7 => 7,
-    }
-    TupleVisitor9 (9, T0, T1, T2, T3, T4, T5, T6, T7, T8) {
-        0 => 0,
-        1 => 1,
-        2 => 2,
-        3 => 3,
-        4 => 4,
-        5 => 5,
-        6 => 6,
-        7 => 7,
-        8 => 8,
-    }
-    TupleVisitor10 (10, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9) {
-        0 => 0,
-        1 => 1,
-        2 => 2,
-        3 => 3,
-        4 => 4,
-        5 => 5,
-        6 => 6,
-        7 => 7,
-        8 => 8,
-        9 => 9,
-    }
-    TupleVisitor11 (11, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) {
-        0 => 0,
-        1 => 1,
-        2 => 2,
-        3 => 3,
-        4 => 4,
-        5 => 5,
-        6 => 6,
-        7 => 7,
-        8 => 8,
-        9 => 9,
-        10 => 10,
-    }
-    TupleVisitor12 (12, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) {
-        0 => 0,
-        1 => 1,
-        2 => 2,
-        3 => 3,
-        4 => 4,
-        5 => 5,
-        6 => 6,
-        7 => 7,
-        8 => 8,
-        9 => 9,
-        10 => 10,
-        11 => 11,
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-pub struct MapIteratorVisitor<Iter> {
-    iter: Iter,
-    first: bool,
-}
-
-impl<K, V, Iter> MapIteratorVisitor<Iter>
-    where Iter: Iterator<Item=(K, V)>
-{
-    #[inline]
-    pub fn new(iter: Iter) -> MapIteratorVisitor<Iter> {
-        MapIteratorVisitor {
-            iter: iter,
-            first: true,
-        }
-    }
-}
-
-impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
-    where K: Serialize,
-          V: Serialize,
-          I: Iterator<Item=(K, V)>,
-{
-    #[inline]
-    fn visit<V_>(&mut self, visitor: &mut V_) -> Result<Option<V_::Value>, V_::Error>
-        where V_: Visitor,
-    {
-        let first = self.first;
-        self.first = false;
-
-        match self.iter.next() {
-            Some((key, value)) => {
-                let value = try!(visitor.visit_map_elt(first, key, value));
-                Ok(Some(value))
-            }
-            None => Ok(None)
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl<K, V> Serialize for BTreeMap<K, V>
-    where K: Serialize + Ord,
-          V: Serialize,
-{
-    #[inline]
-    fn visit<V_: Visitor>(&self, visitor: &mut V_) -> Result<V_::Value, V_::Error> {
-        visitor.visit_map(MapIteratorVisitor::new(self.iter()))
-    }
-}
-
-impl<K, V, S> Serialize for HashMap<K, V, S>
-    where K: Serialize + Eq + Hash,
-          V: Serialize,
-          S: HashState,
-{
-    #[inline]
-    fn visit<V_: Visitor>(&self, visitor: &mut V_) -> Result<V_::Value, V_::Error> {
-        visitor.visit_map(MapIteratorVisitor::new(self.iter()))
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl<'a, T> Serialize for &'a T where T: Serialize {
-    #[inline]
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        (**self).visit(visitor)
-    }
-}
-
-impl<'a, T> Serialize for &'a mut T where T: Serialize {
-    #[inline]
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        (**self).visit(visitor)
-    }
-}
-
-impl<T> Serialize for Box<T> where T: Serialize {
-    #[inline]
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        (**self).visit(visitor)
-    }
-}
-
-impl<T> Serialize for Rc<T> where T: Serialize, {
-    #[inline]
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        (**self).visit(visitor)
-    }
-}
-
-impl<T> Serialize for Arc<T> where T: Serialize, {
-    #[inline]
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        (**self).visit(visitor)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
-impl Serialize for path::Path {
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        self.to_str().unwrap().visit(visitor)
-    }
-}
-
-impl Serialize for path::PathBuf {
-    fn visit<V>(&self, visitor: &mut V) -> Result<V::Value, V::Error>
-        where V: Visitor,
-    {
-        self.to_str().unwrap().visit(visitor)
-    }
-}

tests/test_de.rs

@@ -1,651 +0,0 @@
-#![feature(custom_derive, plugin, test)]
-#![plugin(serde_macros)]
-
-extern crate test;
-extern crate serde;
-
-use std::collections::BTreeMap;
-use std::iter;
-use std::vec;
-
-use serde::de::{self, Deserialize, Deserializer, Visitor};
-
-#[derive(Debug)]
-enum Token<'a> {
-    Bool(bool),
-    Isize(isize),
-    I8(i8),
-    I16(i16),
-    I32(i32),
-    I64(i64),
-    Usize(usize),
-    U8(u8),
-    U16(u16),
-    U32(u32),
-    U64(u64),
-    F32(f32),
-    F64(f64),
-    Char(char),
-    Str(&'a str),
-    String(String),
-
-    Option(bool),
-
-    Unit,
-    NamedUnit(&'a str),
-
-    SeqStart(usize),
-    NamedSeqStart(&'a str, usize),
-    SeqSep(bool),
-    SeqEnd,
-
-    MapStart(usize),
-    NamedMapStart(&'a str, usize),
-    MapSep(bool),
-    MapEnd,
-
-    EnumStart(&'a str, &'a str),
-    EnumEnd,
-}
-
-struct TokenDeserializer<'a> {
-    tokens: iter::Peekable<vec::IntoIter<Token<'a>>>,
-}
-
-impl<'a> TokenDeserializer<'a> {
-    fn new(tokens: Vec<Token<'a>>) -> TokenDeserializer<'a> {
-        TokenDeserializer {
-            tokens: tokens.into_iter().peekable(),
-        }
-    }
-}
-
-#[derive(Copy, PartialEq, Debug)]
-enum Error {
-    SyntaxError,
-    EndOfStreamError,
-    MissingFieldError(&'static str),
-}
-
-impl de::Error for Error {
-    fn syntax_error() -> Error { Error::SyntaxError }
-
-    fn end_of_stream_error() -> Error { Error::EndOfStreamError }
-
-    fn missing_field_error(field: &'static str) -> Error {
-        Error::MissingFieldError(field)
-    }
-}
-
-impl<'a> Deserializer for TokenDeserializer<'a> {
-    type Error = Error;
-
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: Visitor,
-    {
-        match self.tokens.next() {
-            Some(Token::Bool(v)) => visitor.visit_bool(v),
-            Some(Token::Isize(v)) => visitor.visit_isize(v),
-            Some(Token::I8(v)) => visitor.visit_i8(v),
-            Some(Token::I16(v)) => visitor.visit_i16(v),
-            Some(Token::I32(v)) => visitor.visit_i32(v),
-            Some(Token::I64(v)) => visitor.visit_i64(v),
-            Some(Token::Usize(v)) => visitor.visit_usize(v),
-            Some(Token::U8(v)) => visitor.visit_u8(v),
-            Some(Token::U16(v)) => visitor.visit_u16(v),
-            Some(Token::U32(v)) => visitor.visit_u32(v),
-            Some(Token::U64(v)) => visitor.visit_u64(v),
-            Some(Token::F32(v)) => visitor.visit_f32(v),
-            Some(Token::F64(v)) => visitor.visit_f64(v),
-            Some(Token::Char(v)) => visitor.visit_char(v),
-            Some(Token::Str(v)) => visitor.visit_str(v),
-            Some(Token::String(v)) => visitor.visit_string(v),
-            Some(Token::Option(false)) => visitor.visit_none(),
-            Some(Token::Option(true)) => visitor.visit_some(self),
-            Some(Token::Unit) => visitor.visit_unit(),
-            Some(Token::NamedUnit(name)) => visitor.visit_named_unit(name),
-            Some(Token::SeqStart(len)) => {
-                visitor.visit_seq(TokenDeserializerSeqVisitor {
-                    de: self,
-                    len: len,
-                    first: true,
-                })
-            }
-            Some(Token::NamedSeqStart(name, len)) => {
-                visitor.visit_named_seq(name, TokenDeserializerSeqVisitor {
-                    de: self,
-                    len: len,
-                    first: true,
-                })
-            }
-            Some(Token::MapStart(len)) => {
-                visitor.visit_map(TokenDeserializerMapVisitor {
-                    de: self,
-                    len: len,
-                    first: true,
-                })
-            }
-            Some(Token::NamedMapStart(name, len)) => {
-                visitor.visit_named_map(name, TokenDeserializerMapVisitor {
-                    de: self,
-                    len: len,
-                    first: true,
-                })
-            }
-            Some(Token::EnumStart(name, variant)) => {
-                visitor.visit_enum(name, variant, TokenDeserializerEnumVisitor {
-                    de: self,
-                })
-            }
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    /// Hook into `Option` deserializing so we can treat `Unit` as a
-    /// `None`, or a regular value as `Some(value)`.
-    #[inline]
-    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: Visitor,
-    {
-        match self.tokens.peek() {
-            Some(&Token::Option(false)) => {
-                self.tokens.next();
-                visitor.visit_none()
-            }
-            Some(&Token::Option(true)) => {
-                self.tokens.next();
-                visitor.visit_some(self)
-            }
-            Some(&Token::Unit) => {
-                self.tokens.next();
-                visitor.visit_none()
-            }
-            Some(_) => visitor.visit_some(self),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-struct TokenDeserializerSeqVisitor<'a, 'b: 'a> {
-    de: &'a mut TokenDeserializer<'b>,
-    len: usize,
-    first: bool,
-}
-
-impl<'a, 'b> de::SeqVisitor for TokenDeserializerSeqVisitor<'a, 'b> {
-    type Error = Error;
-
-    fn visit<T>(&mut self) -> Result<Option<T>, Error>
-        where T: Deserialize,
-    {
-        let first = self.first;
-        self.first = false;
-
-        match self.de.tokens.next() {
-            Some(Token::SeqSep(first_)) if first_ == first => {
-                self.len -= 1;
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
-            }
-            Some(Token::SeqEnd) => Ok(None),
-            Some(_) => {
-                Err(Error::SyntaxError)
-            }
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        match self.de.tokens.next() {
-            Some(Token::SeqEnd) => Ok(()),
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-struct TokenDeserializerMapVisitor<'a, 'b: 'a> {
-    de: &'a mut TokenDeserializer<'b>,
-    len: usize,
-    first: bool,
-}
-
-impl<'a, 'b> de::MapVisitor for TokenDeserializerMapVisitor<'a, 'b> {
-    type Error = Error;
-
-    fn visit_key<K>(&mut self) -> Result<Option<K>, Error>
-        where K: Deserialize,
-    {
-        let first = self.first;
-        self.first = false;
-
-        match self.de.tokens.next() {
-            Some(Token::MapSep(first_)) if first_ == first => {
-                Ok(Some(try!(Deserialize::deserialize(self.de))))
-            }
-            Some(Token::MapEnd) => Ok(None),
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_value<V>(&mut self) -> Result<V, Error>
-        where V: Deserialize,
-    {
-        Ok(try!(Deserialize::deserialize(self.de)))
-    }
-
-    fn end(&mut self) -> Result<(), Error> {
-        match self.de.tokens.next() {
-            Some(Token::MapEnd) => Ok(()),
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-struct TokenDeserializerEnumVisitor<'a, 'b: 'a> {
-    de: &'a mut TokenDeserializer<'b>,
-}
-
-impl<'a, 'b> de::EnumVisitor for TokenDeserializerEnumVisitor<'a, 'b> {
-    type Error = Error;
-
-    fn visit_unit(&mut self) -> Result<(), Error> {
-        let value = try!(Deserialize::deserialize(self.de));
-
-        match self.de.tokens.next() {
-            Some(Token::EnumEnd) => Ok(value),
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::EnumSeqVisitor,
-    {
-        let token = self.de.tokens.next();
-        match token {
-            Some(Token::SeqStart(len)) => {
-                let value = try!(visitor.visit(TokenDeserializerSeqVisitor {
-                    de: self.de,
-                    len: len,
-                    first: true,
-                }));
-
-                match self.de.tokens.next() {
-                    Some(Token::EnumEnd) => Ok(value),
-                    Some(_) => Err(Error::SyntaxError),
-                    None => Err(Error::EndOfStreamError),
-                }
-            }
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-
-    fn visit_map<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::EnumMapVisitor,
-    {
-        match self.de.tokens.next() {
-            Some(Token::MapStart(len)) => {
-                let value = try!(visitor.visit(TokenDeserializerMapVisitor {
-                    de: self.de,
-                    len: len,
-                    first: true,
-                }));
-
-                match self.de.tokens.next() {
-                    Some(Token::EnumEnd) => Ok(value),
-                    Some(_) => Err(Error::SyntaxError),
-                    None => Err(Error::EndOfStreamError),
-                }
-            }
-            Some(_) => Err(Error::SyntaxError),
-            None => Err(Error::EndOfStreamError),
-        }
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-#[derive(Copy, PartialEq, Debug)]
-#[derive_deserialize]
-struct NamedUnit;
-
-#[derive(PartialEq, Debug)]
-#[derive_deserialize]
-struct NamedSeq(i32, i32, i32);
-
-#[derive(PartialEq, Debug)]
-#[derive_deserialize]
-struct NamedMap {
-    a: i32,
-    b: i32,
-    c: i32,
-}
-
-#[derive(PartialEq, Debug)]
-#[derive_deserialize]
-enum Enum {
-    Unit,
-    Seq(i32, i32, i32),
-    Map { a: i32, b: i32, c: i32 }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-macro_rules! btreemap {
-    () => {
-        BTreeMap::new()
-    };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = BTreeMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    }
-}
-
-macro_rules! declare_test {
-    ($name:ident { $($value:expr => $tokens:expr,)+ }) => {
-        #[test]
-        fn $name() {
-            $(
-                let mut de = TokenDeserializer::new($tokens);
-                let value: Result<_, Error> = Deserialize::deserialize(&mut de);
-                assert_eq!(value, Ok($value));
-            )+
-        }
-    }
-}
-
-macro_rules! declare_tests {
-    ($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
-        $(
-            declare_test!($name { $($value => $tokens,)+ });
-        )+
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////
-
-declare_tests! {
-    test_bool {
-        true => vec![Token::Bool(true)],
-        false => vec![Token::Bool(false)],
-    }
-    test_isize {
-        0isize => vec![Token::Isize(0)],
-        0isize => vec![Token::I8(0)],
-        0isize => vec![Token::I16(0)],
-        0isize => vec![Token::I32(0)],
-        0isize => vec![Token::I64(0)],
-        0isize => vec![Token::Usize(0)],
-        0isize => vec![Token::U8(0)],
-        0isize => vec![Token::U16(0)],
-        0isize => vec![Token::U32(0)],
-        0isize => vec![Token::U64(0)],
-        0isize => vec![Token::F32(0.)],
-        0isize => vec![Token::F64(0.)],
-    }
-    test_ints {
-        0isize => vec![Token::Isize(0)],
-        0i8 => vec![Token::I8(0)],
-        0i16 => vec![Token::I16(0)],
-        0i32 => vec![Token::I32(0)],
-        0i64 => vec![Token::I64(0)],
-    }
-    test_uints {
-        0usize => vec![Token::Usize(0)],
-        0u8 => vec![Token::U8(0)],
-        0u16 => vec![Token::U16(0)],
-        0u32 => vec![Token::U32(0)],
-        0u64 => vec![Token::U64(0)],
-    }
-    test_floats {
-        0f32 => vec![Token::F32(0.)],
-        0f64 => vec![Token::F64(0.)],
-    }
-    test_char {
-        'a' => vec![Token::Char('a')],
-        'a' => vec![Token::Str("a")],
-        'a' => vec![Token::String("a".to_string())],
-    }
-    test_string {
-        "abc".to_string() => vec![Token::Str("abc")],
-        "abc".to_string() => vec![Token::String("abc".to_string())],
-        "a".to_string() => vec![Token::Char('a')],
-    }
-    test_option {
-        None::<i32> => vec![Token::Unit],
-        None::<i32> => vec![Token::Option(false)],
-        Some(1) => vec![Token::I32(1)],
-        Some(1) => vec![
-            Token::Option(true),
-            Token::I32(1),
-        ],
-    }
-    test_unit {
-        () => vec![Token::Unit],
-        () => vec![
-            Token::SeqStart(0),
-            Token::SeqEnd,
-        ],
-        () => vec![
-            Token::NamedSeqStart("Anything", 0),
-            Token::SeqEnd,
-        ],
-    }
-    test_named_unit {
-        NamedUnit => vec![Token::Unit],
-        NamedUnit => vec![Token::NamedUnit("NamedUnit")],
-        NamedUnit => vec![
-            Token::SeqStart(0),
-            Token::SeqEnd,
-        ],
-    }
-    test_named_seq {
-        NamedSeq(1, 2, 3) => vec![
-            Token::SeqStart(3),
-                Token::SeqSep(true),
-                Token::I32(1),
-
-                Token::SeqSep(false),
-                Token::I32(2),
-
-                Token::SeqSep(false),
-                Token::I32(3),
-            Token::SeqEnd,
-        ],
-        NamedSeq(1, 2, 3) => vec![
-            Token::NamedSeqStart("NamedSeq", 3),
-                Token::SeqSep(true),
-                Token::I32(1),
-
-                Token::SeqSep(false),
-                Token::I32(2),
-
-                Token::SeqSep(false),
-                Token::I32(3),
-            Token::SeqEnd,
-        ],
-    }
-    test_vec {
-        Vec::<isize>::new() => vec![
-            Token::SeqStart(0),
-            Token::SeqEnd,
-        ],
-        vec![vec![], vec![1], vec![2, 3]] => vec![
-            Token::SeqStart(3),
-                Token::SeqSep(true),
-                Token::SeqStart(0),
-                Token::SeqEnd,
-
-                Token::SeqSep(false),
-                Token::SeqStart(1),
-                    Token::SeqSep(true),
-                    Token::I32(1),
-                Token::SeqEnd,
-
-                Token::SeqSep(false),
-                Token::SeqStart(2),
-                    Token::SeqSep(true),
-                    Token::I32(2),
-
-                    Token::SeqSep(false),
-                    Token::I32(3),
-                Token::SeqEnd,
-            Token::SeqEnd,
-        ],
-    }
-    test_tuple {
-        (1,) => vec![
-            Token::SeqStart(1),
-                Token::SeqSep(true),
-                Token::I32(1),
-            Token::SeqEnd,
-        ],
-        (1, 2, 3) => vec![
-            Token::SeqStart(3),
-                Token::SeqSep(true),
-                Token::I32(1),
-
-                Token::SeqSep(false),
-                Token::I32(2),
-
-                Token::SeqSep(false),
-                Token::I32(3),
-            Token::SeqEnd,
-        ],
-    }
-    test_btreemap {
-        btreemap![1 => 2] => vec![
-            Token::MapStart(1),
-                Token::MapSep(true),
-                Token::I32(1),
-                Token::I32(2),
-            Token::MapEnd,
-        ],
-        btreemap![1 => 2, 3 => 4] => vec![
-            Token::MapStart(2),
-                Token::MapSep(true),
-                Token::I32(1),
-                Token::I32(2),
-
-                Token::MapSep(false),
-                Token::I32(3),
-                Token::I32(4),
-            Token::MapEnd,
-        ],
-        btreemap![1 => btreemap![], 2 => btreemap![3 => 4, 5 => 6]] => vec![
-            Token::MapStart(2),
-                Token::MapSep(true),
-                Token::I32(1),
-                Token::MapStart(0),
-                Token::MapEnd,
-
-                Token::MapSep(false),
-                Token::I32(2),
-                Token::MapStart(2),
-                    Token::MapSep(true),
-                    Token::I32(3),
-                    Token::I32(4),
-
-                    Token::MapSep(false),
-                    Token::I32(5),
-                    Token::I32(6),
-                Token::MapEnd,
-            Token::MapEnd,
-        ],
-    }
-    test_named_map {
-        NamedMap { a: 1, b: 2, c: 3 } => vec![
-            Token::MapStart(3),
-                Token::MapSep(true),
-                Token::Str("a"),
-                Token::I32(1),
-
-                Token::MapSep(false),
-                Token::Str("b"),
-                Token::I32(2),
-
-                Token::MapSep(false),
-                Token::Str("c"),
-                Token::I32(3),
-            Token::MapEnd,
-        ],
-        NamedMap { a: 1, b: 2, c: 3 } => vec![
-            Token::NamedMapStart("NamedMap", 3),
-                Token::MapSep(true),
-                Token::Str("a"),
-                Token::I32(1),
-
-                Token::MapSep(false),
-                Token::Str("b"),
-                Token::I32(2),
-
-                Token::MapSep(false),
-                Token::Str("c"),
-                Token::I32(3),
-            Token::MapEnd,
-        ],
-    }
-    test_enum {
-        Enum::Unit => vec![
-            Token::EnumStart("Enum", "Unit"),
-                Token::Unit,
-            Token::EnumEnd,
-        ],
-    }
-    test_enum_seq {
-        Enum::Seq(1, 2, 3) => vec![
-            Token::EnumStart("Enum", "Seq"),
-                Token::SeqStart(3),
-                    Token::SeqSep(true),
-                    Token::I32(1),
-
-                    Token::SeqSep(false),
-                    Token::I32(2),
-
-                    Token::SeqSep(false),
-                    Token::I32(3),
-                Token::SeqEnd,
-            Token::EnumEnd,
-        ],
-    }
-    test_enum_map {
-        Enum::Map { a: 1, b: 2, c: 3 } => vec![
-            Token::EnumStart("Enum", "Map"),
-                Token::MapStart(3),
-                    Token::MapSep(true),
-                    Token::Str("a"),
-                    Token::I32(1),
-
-                    Token::MapSep(false),
-                    Token::Str("b"),
-                    Token::I32(2),
-
-                    Token::MapSep(false),
-                    Token::Str("c"),
-                    Token::I32(3),
-                Token::MapEnd,
-            Token::EnumEnd,
-        ],
-    }
-}

tests/test_json.rs

@@ -1,761 +0,0 @@
-#![feature(custom_derive, plugin, test)]
-#![plugin(serde_macros)]
-
-extern crate test;
-extern crate serde;
-
-use std::fmt::Debug;
-use std::collections::BTreeMap;
-
-use serde::de;
-use serde::ser;
-
-use serde::json::{
-    self,
-    Value,
-    from_str,
-    from_value,
-    to_value,
-};
-
-use serde::json::error::{Error, ErrorCode};
-
-macro_rules! treemap {
-    ($($k:expr => $v:expr),*) => ({
-        let mut _m = BTreeMap::new();
-        $(_m.insert($k, $v);)*
-        _m
-    })
-}
-
-#[derive(PartialEq, Debug)]
-#[derive_serialize]
-#[derive_deserialize]
-enum Animal {
-    Dog,
-    Frog(String, Vec<isize>),
-    Cat { age: usize, name: String },
-
-}
-
-#[derive(PartialEq, Debug)]
-#[derive_serialize]
-#[derive_deserialize]
-struct Inner {
-    a: (),
-    b: usize,
-    c: Vec<String>,
-}
-
-#[derive(PartialEq, Debug)]
-#[derive_serialize]
-#[derive_deserialize]
-struct Outer {
-    inner: Vec<Inner>,
-}
-
-fn test_encode_ok<T>(errors: &[(T, &str)])
-    where T: PartialEq + Debug + ser::Serialize,
-{
-    for &(ref value, out) in errors {
-        let out = out.to_string();
-
-        let s = json::to_string(value).unwrap();
-        assert_eq!(s, out);
-
-        let v = to_value(&value);
-        let s = json::to_string(&v).unwrap();
-        assert_eq!(s, out);
-    }
-}
-
-fn test_pretty_encode_ok<T>(errors: &[(T, &str)])
-    where T: PartialEq + Debug + ser::Serialize,
-{
-    for &(ref value, out) in errors {
-        let out = out.to_string();
-
-        let s = json::to_string_pretty(value).unwrap();
-        assert_eq!(s, out);
-
-        let v = to_value(&value);
-        let s = json::to_string_pretty(&v).unwrap();
-        assert_eq!(s, out);
-    }
-}
-
-#[test]
-fn test_write_null() {
-    let tests = &[
-        ((), "null"),
-    ];
-    test_encode_ok(tests);
-    test_pretty_encode_ok(tests);
-}
-
-#[test]
-fn test_write_i64() {
-    let tests = &[
-        (3i64, "3"),
-        (-2i64, "-2"),
-        (-1234i64, "-1234"),
-    ];
-    test_encode_ok(tests);
-    test_pretty_encode_ok(tests);
-}
-
-#[test]
-fn test_write_f64() {
-    let tests = &[
-        (3.0, "3"),
-        (3.1, "3.1"),
-        (-1.5, "-1.5"),
-        (0.5, "0.5"),
-    ];
-    test_encode_ok(tests);
-    test_pretty_encode_ok(tests);
-}
-
-#[test]
-fn test_write_str() {
-    let tests = &[
-        ("", "\"\""),
-        ("foo", "\"foo\""),
-    ];
-    test_encode_ok(tests);
-    test_pretty_encode_ok(tests);
-}
-
-#[test]
-fn test_write_bool() {
-    let tests = &[
-        (true, "true"),
-        (false, "false"),
-    ];
-    test_encode_ok(tests);
-    test_pretty_encode_ok(tests);
-}
-
-#[test]
-fn test_write_list() {
-    test_encode_ok(&[
-        (vec![], "[]"),
-        (vec![true], "[true]"),
-        (vec![true, false], "[true,false]"),
-    ]);
-
-    test_pretty_encode_ok(&[
-        (vec![], "[]"),
-        (
-            vec![true],
-            concat!(
-                "[\n",
-                "  true\n",
-                "]"
-            ),
-        ),
-        (
-            vec![true, false],
-            concat!(
-                "[\n",
-                "  true,\n",
-                "  false\n",
-                "]"
-            ),
-        ),
-    ]);
-
-    let long_test_list = Value::Array(vec![
-        Value::Bool(false),
-        Value::Null,
-        Value::Array(vec![Value::String("foo\nbar".to_string()), Value::F64(3.5)])]);
-
-    test_encode_ok(&[
-        (
-            long_test_list.clone(),
-            "[false,null,[\"foo\\nbar\",3.5]]",
-        ),
-    ]);
-
-    test_pretty_encode_ok(&[
-        (
-            long_test_list,
-            concat!(
-                "[\n",
-                "  false,\n",
-                "  null,\n",
-                "  [\n",
-                "    \"foo\\nbar\",\n",
-                "    3.5\n",
-                "  ]\n",
-                "]"
-            ),
-        )
-    ]);
-}
-
-#[test]
-fn test_write_object() {
-    test_encode_ok(&[
-        (treemap!(), "{}"),
-        (treemap!("a".to_string() => true), "{\"a\":true}"),
-        (
-            treemap!(
-                "a".to_string() => true,
-                "b".to_string() => false
-            ),
-            "{\"a\":true,\"b\":false}"),
-    ]);
-
-    test_pretty_encode_ok(&[
-        (treemap!(), "{}"),
-        (
-            treemap!("a".to_string() => true),
-            concat!(
-                "{\n",
-                "  \"a\": true\n",
-                "}"
-            ),
-        ),
-        (
-            treemap!(
-                "a".to_string() => true,
-                "b".to_string() => false
-            ),
-            concat!(
-                "{\n",
-                "  \"a\": true,\n",
-                "  \"b\": false\n",
-                "}"
-            ),
-        ),
-    ]);
-
-    let complex_obj = Value::Object(treemap!(
-        "b".to_string() => Value::Array(vec![
-            Value::Object(treemap!("c".to_string() => Value::String("\x0c\r".to_string()))),
-            Value::Object(treemap!("d".to_string() => Value::String("".to_string())))
-        ])
-    ));
-
-    test_encode_ok(&[
-        (
-            complex_obj.clone(),
-            "{\
-                \"b\":[\
-                    {\"c\":\"\\f\\r\"},\
-                    {\"d\":\"\"}\
-                ]\
-            }"
-        ),
-    ]);
-
-    test_pretty_encode_ok(&[
-        (
-            complex_obj.clone(),
-            concat!(
-                "{\n",
-                "  \"b\": [\n",
-                "    {\n",
-                "      \"c\": \"\\f\\r\"\n",
-                "    },\n",
-                "    {\n",
-                "      \"d\": \"\"\n",
-                "    }\n",
-                "  ]\n",
-                "}"
-            ),
-        )
-    ]);
-}
-
-#[test]
-fn test_write_tuple() {
-    test_encode_ok(&[
-        (
-            (5,),
-            "[5]",
-        ),
-    ]);
-
-    test_pretty_encode_ok(&[
-        (
-            (5,),
-            concat!(
-                "[\n",
-                "  5\n",
-                "]"
-            ),
-        ),
-    ]);
-
-    test_encode_ok(&[
-        (
-            (5, (6, "abc")),
-            "[5,[6,\"abc\"]]",
-        ),
-    ]);
-
-    test_pretty_encode_ok(&[
-        (
-            (5, (6, "abc")),
-            concat!(
-                "[\n",
-                "  5,\n",
-                "  [\n",
-                "    6,\n",
-                "    \"abc\"\n",
-                "  ]\n",
-                "]"
-            ),
-        ),
-    ]);
-}
-
-#[test]
-fn test_write_enum() {
-    test_encode_ok(&[
-        (
-            Animal::Dog,
-            "{\"Dog\":[]}",
-        ),
-        (
-            Animal::Frog("Henry".to_string(), vec![]),
-            "{\"Frog\":[\"Henry\",[]]}",
-        ),
-        (
-            Animal::Frog("Henry".to_string(), vec![349]),
-            "{\"Frog\":[\"Henry\",[349]]}",
-        ),
-        (
-            Animal::Frog("Henry".to_string(), vec![349, 102]),
-            "{\"Frog\":[\"Henry\",[349,102]]}",
-        ),
-        (
-            Animal::Cat { age: 5, name: "Kate".to_string() },
-            "{\"Cat\":{\"age\":5,\"name\":\"Kate\"}}"
-        ),
-    ]);
-
-    test_pretty_encode_ok(&[
-        (
-            Animal::Dog,
-            concat!(
-                "{\n",
-                "  \"Dog\": []\n",
-                "}"
-            ),
-        ),
-        (
-            Animal::Frog("Henry".to_string(), vec![]),
-            concat!(
-                "{\n",
-                "  \"Frog\": [\n",
-                "    \"Henry\",\n",
-                "    []\n",
-                "  ]\n",
-                "}"
-            ),
-        ),
-        (
-            Animal::Frog("Henry".to_string(), vec![349]),
-            concat!(
-                "{\n",
-                "  \"Frog\": [\n",
-                "    \"Henry\",\n",
-                "    [\n",
-                "      349\n",
-                "    ]\n",
-                "  ]\n",
-                "}"
-            ),
-        ),
-        (
-            Animal::Frog("Henry".to_string(), vec![349, 102]),
-            concat!(
-                "{\n",
-                "  \"Frog\": [\n",
-                "    \"Henry\",\n",
-                "    [\n",
-                "      349,\n",
-                "      102\n",
-                "    ]\n",
-                "  ]\n",
-                "}"
-            ),
-        ),
-    ]);
-}
-
-#[test]
-fn test_write_option() {
-    test_encode_ok(&[
-        (None, "null"),
-        (Some("jodhpurs"), "\"jodhpurs\""),
-    ]);
-
-    test_encode_ok(&[
-        (None, "null"),
-        (Some(vec!["foo", "bar"]), "[\"foo\",\"bar\"]"),
-    ]);
-
-    test_pretty_encode_ok(&[
-        (None, "null"),
-        (Some("jodhpurs"), "\"jodhpurs\""),
-    ]);
-
-    test_pretty_encode_ok(&[
-        (None, "null"),
-        (
-            Some(vec!["foo", "bar"]),
-            concat!(
-                "[\n",
-                "  \"foo\",\n",
-                "  \"bar\"\n",
-                "]"
-            ),
-        ),
-    ]);
-}
-
-fn test_parse_ok<'a, T>(errors: &[(&'a str, T)])
-    where T: PartialEq + Debug + ser::Serialize + de::Deserialize,
-{
-    for &(s, ref value) in errors {
-        let v: T = from_str(s).unwrap();
-        assert_eq!(v, *value);
-
-        // Make sure we can deserialize into a `Value`.
-        let json_value: Value = from_str(s).unwrap();
-        assert_eq!(json_value, to_value(&value));
-
-        // Make sure we can deserialize from a `Value`.
-        let v: T = from_value(json_value.clone()).unwrap();
-        assert_eq!(v, *value);
-
-        // Make sure we can round trip back to `Value`.
-        let json_value2: Value = from_value(json_value.clone()).unwrap();
-        assert_eq!(json_value, json_value2);
-    }
-}
-
-// FIXME (#5527): these could be merged once UFCS is finished.
-fn test_parse_err<'a, T>(errors: &[(&'a str, Error)])
-    where T: Debug + de::Deserialize,
-{
-    for &(s, ref err) in errors {
-        let v: Result<T, Error> = from_str(s);
-        assert_eq!(v.unwrap_err(), *err);
-    }
-}
-
-#[test]
-fn test_parse_null() {
-    test_parse_err::<()>(&[
-        ("n", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 2)),
-        ("nul", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 4)),
-        ("nulla", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 5)),
-    ]);
-
-    test_parse_ok(&[
-        ("null", ()),
-    ]);
-}
-
-#[test]
-fn test_parse_bool() {
-    test_parse_err::<bool>(&[
-        ("t", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 2)),
-        ("truz", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 4)),
-        ("f", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 2)),
-        ("faz", Error::SyntaxError(ErrorCode::ExpectedSomeIdent, 1, 3)),
-        ("truea", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 5)),
-        ("falsea", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 6)),
-    ]);
-
-    test_parse_ok(&[
-        ("true", true),
-        (" true ", true),
-        ("false", false),
-        (" false ", false),
-    ]);
-}
-
-#[test]
-fn test_parse_number_errors() {
-    test_parse_err::<f64>(&[
-        ("+", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 1)),
-        (".", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 1)),
-        ("-", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 2)),
-        ("00", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 2)),
-        ("1.", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 3)),
-        ("1e", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 3)),
-        ("1e+", Error::SyntaxError(ErrorCode::InvalidNumber, 1, 4)),
-        ("1a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 2)),
-    ]);
-}
-
-#[test]
-fn test_parse_i64() {
-    test_parse_ok(&[
-        ("3", 3),
-        ("-2", -2),
-        ("-1234", -1234),
-        (" -1234 ", -1234),
-    ]);
-}
-
-#[test]
-fn test_parse_f64() {
-    test_parse_ok(&[
-        ("3.0", 3.0f64),
-        ("3.1", 3.1),
-        ("-1.2", -1.2),
-        ("0.4", 0.4),
-        ("0.4e5", 0.4e5),
-        ("0.4e15", 0.4e15),
-        ("0.4e-01", 0.4e-01),
-        (" 0.4e-01 ", 0.4e-01),
-    ]);
-}
-
-#[test]
-fn test_parse_string() {
-    test_parse_err::<String>(&[
-        ("\"", Error::SyntaxError(ErrorCode::EOFWhileParsingString, 1, 2)),
-        ("\"lol", Error::SyntaxError(ErrorCode::EOFWhileParsingString, 1, 5)),
-        ("\"lol\"a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 6)),
-    ]);
-
-    test_parse_ok(&[
-        ("\"\"", "".to_string()),
-        ("\"foo\"", "foo".to_string()),
-        (" \"foo\" ", "foo".to_string()),
-        ("\"\\\"\"", "\"".to_string()),
-        ("\"\\b\"", "\x08".to_string()),
-        ("\"\\n\"", "\n".to_string()),
-        ("\"\\r\"", "\r".to_string()),
-        ("\"\\t\"", "\t".to_string()),
-        ("\"\\u12ab\"", "\u{12ab}".to_string()),
-        ("\"\\uAB12\"", "\u{AB12}".to_string()),
-    ]);
-}
-
-#[test]
-fn test_parse_list() {
-    test_parse_err::<Vec<f64>>(&[
-        ("[", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 2)),
-        ("[ ", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 3)),
-        ("[1", Error::SyntaxError(ErrorCode::EOFWhileParsingList,  1, 3)),
-        ("[1,", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 4)),
-        ("[1,]", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 4)),
-        ("[1 2]", Error::SyntaxError(ErrorCode::ExpectedListCommaOrEnd, 1, 4)),
-        ("[]a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 3)),
-    ]);
-
-    test_parse_ok(&[
-        ("[]", vec![]),
-        ("[ ]", vec![]),
-        ("[null]", vec![()]),
-        (" [ null ] ", vec![()]),
-    ]);
-
-    test_parse_ok(&[
-        ("[true]", vec![true]),
-    ]);
-
-    test_parse_ok(&[
-        ("[3,1]", vec![3, 1]),
-        (" [ 3 , 1 ] ", vec![3, 1]),
-    ]);
-
-    test_parse_ok(&[
-        ("[[3], [1, 2]]", vec![vec![3], vec![1, 2]]),
-    ]);
-
-    test_parse_ok(&[
-        ("[1]", (1,)),
-    ]);
-
-    test_parse_ok(&[
-        ("[1, 2]", (1, 2)),
-    ]);
-
-    test_parse_ok(&[
-        ("[1, 2, 3]", (1, 2, 3)),
-    ]);
-
-    test_parse_ok(&[
-        ("[1, [2, 3]]", (1, (2, 3))),
-    ]);
-
-    let v: () = from_str("[]").unwrap();
-    assert_eq!(v, ());
-}
-
-#[test]
-fn test_parse_object() {
-    test_parse_err::<BTreeMap<String, u32>>(&[
-        ("{", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 2)),
-        ("{ ", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 3)),
-        ("{1", Error::SyntaxError(ErrorCode::KeyMustBeAString, 1, 2)),
-        ("{ \"a\"", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 6)),
-        ("{\"a\"", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 5)),
-        ("{\"a\" ", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 6)),
-        ("{\"a\" 1", Error::SyntaxError(ErrorCode::ExpectedColon, 1, 6)),
-        ("{\"a\":", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 6)),
-        ("{\"a\":1", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 1, 7)),
-        ("{\"a\":1 1", Error::SyntaxError(ErrorCode::ExpectedObjectCommaOrEnd, 1, 8)),
-        ("{\"a\":1,", Error::SyntaxError(ErrorCode::EOFWhileParsingValue, 1, 8)),
-        ("{}a", Error::SyntaxError(ErrorCode::TrailingCharacters, 1, 3)),
-    ]);
-
-    test_parse_ok(&[
-        ("{}", treemap!()),
-        ("{ }", treemap!()),
-        (
-            "{\"a\":3}",
-            treemap!("a".to_string() => 3)
-        ),
-        (
-            "{ \"a\" : 3 }",
-            treemap!("a".to_string() => 3)
-        ),
-        (
-            "{\"a\":3,\"b\":4}",
-            treemap!("a".to_string() => 3, "b".to_string() => 4)
-        ),
-        (
-            " { \"a\" : 3 , \"b\" : 4 } ",
-            treemap!("a".to_string() => 3, "b".to_string() => 4),
-        ),
-    ]);
-
-    test_parse_ok(&[
-        (
-            "{\"a\": {\"b\": 3, \"c\": 4}}",
-            treemap!("a".to_string() => treemap!("b".to_string() => 3, "c".to_string() => 4)),
-        ),
-    ]);
-}
-
-#[test]
-fn test_parse_struct() {
-    test_parse_err::<Outer>(&[
-        ("[]", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 0, 0)),
-        ("{}", Error::MissingFieldError("inner")),
-        ("{\"inner\": true}", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 0, 0)),
-    ]);
-
-    test_parse_ok(&[
-        (
-            "{
-                \"inner\": []
-            }",
-            Outer {
-                inner: vec![]
-            },
-        ),
-        (
-            "{
-                \"inner\": [
-                    { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
-                ]
-            }",
-            Outer {
-                inner: vec![
-                    Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
-                ]
-            },
-        )
-    ]);
-}
-
-#[test]
-fn test_parse_option() {
-    test_parse_ok(&[
-        ("null", None::<String>),
-        ("\"jodhpurs\"", Some("jodhpurs".to_string())),
-    ]);
-
-    #[derive(PartialEq, Debug)]
-    #[derive_serialize]
-    #[derive_deserialize]
-    struct Foo {
-        x: Option<isize>,
-    }
-
-    /*
-    let value: Foo = from_str("{}").unwrap();
-    assert_eq!(value, Foo { x: None });
-    */
-
-    test_parse_ok(&[
-        ("{\"x\": null}", Foo { x: None }),
-        ("{\"x\": 5}", Foo { x: Some(5) }),
-    ]);
-}
-
-#[test]
-fn test_parse_enum() {
-    test_parse_err::<Animal>(&[
-        ("{}", Error::SyntaxError(ErrorCode::EOFWhileParsingString, 1, 3)),
-        ("{\"unknown\":[]}", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 0, 0)),
-        ("{\"Dog\":{}}", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 0, 0)),
-        ("{\"Frog\":{}}", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 9)),
-        ("{\"Cat\":[]}", Error::SyntaxError(ErrorCode::ExpectedSomeValue, 1, 8)),
-    ]);
-
-    test_parse_ok(&[
-        ("{\"Dog\":[]}", Animal::Dog),
-        (" { \"Dog\" : [ ] } ", Animal::Dog),
-        (
-            "{\"Frog\":[\"Henry\",[]]}",
-            Animal::Frog("Henry".to_string(), vec![]),
-        ),
-        (
-            " { \"Frog\": [ \"Henry\" , [ 349, 102 ] ] } ",
-            Animal::Frog("Henry".to_string(), vec![349, 102]),
-        ),
-        (
-            "{\"Cat\": {\"age\": 5, \"name\": \"Kate\"}}",
-            Animal::Cat { age: 5, name: "Kate".to_string() },
-        ),
-        (
-            " { \"Cat\" : { \"age\" : 5 , \"name\" : \"Kate\" } } ",
-            Animal::Cat { age: 5, name: "Kate".to_string() },
-        ),
-    ]);
-
-    test_parse_ok(&[
-        (
-            concat!(
-                "{",
-                "  \"a\": {\"Dog\": []},",
-                "  \"b\": {\"Frog\":[\"Henry\", []]}",
-                "}"
-            ),
-            treemap!(
-                "a".to_string() => Animal::Dog,
-                "b".to_string() => Animal::Frog("Henry".to_string(), vec![])
-            )
-        ),
-    ]);
-}
-
-#[test]
-fn test_parse_trailing_whitespace() {
-    test_parse_ok(&[
-        ("[1, 2] ", vec![1, 2]),
-        ("[1, 2]\n", vec![1, 2]),
-        ("[1, 2]\t", vec![1, 2]),
-        ("[1, 2]\t \n", vec![1, 2]),
-    ]);
-}
-
-#[test]
-fn test_multiline_errors() {
-    test_parse_err::<BTreeMap<String, String>>(&[
-        ("{\n  \"foo\":\n \"bar\"", Error::SyntaxError(ErrorCode::EOFWhileParsingObject, 3, 8)),
-    ]);
-}

tests/test_macros.rs

@@ -1,406 +0,0 @@
-#![feature(custom_derive, plugin)]
-#![plugin(serde_macros)]
-
-extern crate serde;
-
-use std::collections::BTreeMap;
-use serde::json::{self, Value};
-
-macro_rules! btreemap {
-    () => {
-        BTreeMap::new()
-    };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = BTreeMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    }
-}
-
-/*
-trait Trait {
-    type Type;
-}
-*/
-
-#[derive(Debug, PartialEq)]
-#[derive_serialize]
-#[derive_deserialize]
-struct NamedUnit;
-
-#[derive(Debug, PartialEq)]
-#[derive_serialize]
-enum SerEnum<'a, B: 'a, C: /* Trait + */ 'a, D> where D: /* Trait + */ 'a {
-    Unit,
-    Seq(
-        i8,
-        B,
-        &'a C,
-        //C::Type,
-        &'a mut D,
-        //<D as Trait>::Type,
-    ),
-    Map {
-        a: i8,
-        b: B,
-        c: &'a C,
-        //d: C::Type,
-        e: &'a mut D,
-        //f: <D as Trait>::Type,
-    },
-}
-
-#[derive(Debug, PartialEq)]
-#[derive_deserialize]
-enum DeEnum<B, C: /* Trait */, D> /* where D: Trait */ {
-    Unit,
-    Seq(
-        i8,
-        B,
-        C,
-        //C::Type,
-        D,
-        //<D as Trait>::Type,
-    ),
-    Map {
-        a: i8,
-        b: B,
-        c: C,
-        //d: C::Type,
-        e: D,
-        //f: <D as Trait>::Type,
-    },
-}
-
-#[test]
-fn test_named_unit() {
-    let named_unit = NamedUnit;
-
-    assert_eq!(
-        json::to_string(&named_unit).unwrap(),
-        "null".to_string()
-    );
-
-    assert_eq!(
-        json::to_value(&named_unit),
-        Value::Null
-    );
-
-    let v = json::from_str("null").unwrap();
-    assert_eq!(v, named_unit);
-
-    let v = json::from_value(Value::Null).unwrap();
-    assert_eq!(v, named_unit);
-}
-
-#[test]
-fn test_ser_named_tuple() {
-    #[derive(Debug, PartialEq)]
-    #[derive_serialize]
-    struct NamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
-
-    let a = 5;
-    let mut b = 6;
-    let c = 7;
-    let named_tuple = NamedTuple(&a, &mut b, c);
-
-    assert_eq!(
-        json::to_string(&named_tuple).unwrap(),
-        "[5,6,7]"
-    );
-
-    assert_eq!(
-        json::to_value(&named_tuple),
-        Value::Array(vec![Value::I64(5), Value::I64(6), Value::I64(7)])
-    );
-}
-
-#[test]
-fn test_de_named_tuple() {
-    #[derive(Debug, PartialEq)]
-    #[derive_deserialize]
-    struct NamedTuple<A, B, C>(A, B, C);
-
-    assert_eq!(
-        json::from_str("[1,2,3]").unwrap(),
-        NamedTuple(1, 2, 3)
-    );
-
-    assert_eq!(
-        json::from_str("[1,2,3]").unwrap(),
-        Value::Array(vec![
-            Value::I64(1),
-            Value::I64(2),
-            Value::I64(3),
-        ])
-    );
-}
-
-#[test]
-fn test_ser_named_map() {
-    #[derive(Debug, PartialEq)]
-    #[derive_serialize]
-    struct NamedMap<'a, 'b, A: 'a, B: 'b, C> {
-        a: &'a A,
-        b: &'b mut B,
-        c: C,
-    }
-
-    let a = 5;
-    let mut b = 6;
-    let c = 7;
-    let named_map = NamedMap {
-        a: &a,
-        b: &mut b,
-        c: c,
-    };
-
-    assert_eq!(
-        json::to_string(&named_map).unwrap(),
-        "{\"a\":5,\"b\":6,\"c\":7}"
-    );
-
-    assert_eq!(
-        json::to_value(&named_map),
-        Value::Object(btreemap![
-            "a".to_string() => Value::I64(5),
-            "b".to_string() => Value::I64(6),
-            "c".to_string() => Value::I64(7)
-        ])
-    );
-}
-
-#[test]
-fn test_de_named_map() {
-    #[derive(Debug, PartialEq)]
-    #[derive_deserialize]
-    struct NamedMap<A, B, C> {
-        a: A,
-        b: B,
-        c: C,
-    }
-
-    let v = NamedMap {
-        a: 5,
-        b: 6,
-        c: 7,
-    };
-
-    assert_eq!(
-        json::from_str("{\"a\":5,\"b\":6,\"c\":7}").unwrap(),
-        v
-    );
-
-    assert_eq!(
-        json::from_value(Value::Object(btreemap![
-            "a".to_string() => Value::I64(5),
-            "b".to_string() => Value::I64(6),
-            "c".to_string() => Value::I64(7)
-        ])).unwrap(),
-        v
-    );
-}
-
-#[test]
-fn test_ser_enum_unit() {
-    assert_eq!(
-        json::to_string(&SerEnum::Unit::<u32, u32, u32>).unwrap(),
-        "{\"Unit\":[]}"
-    );
-
-    assert_eq!(
-        json::to_value(&SerEnum::Unit::<u32, u32, u32>),
-        Value::Object(btreemap!(
-            "Unit".to_string() => Value::Array(vec![]))
-        )
-    );
-}
-
-#[test]
-fn test_ser_enum_seq() {
-    let a = 1;
-    let b = 2;
-    let c = 3;
-    //let d = 4;
-    let mut e = 5;
-    //let f = 6;
-
-    assert_eq!(
-        json::to_string(&SerEnum::Seq(
-            a,
-            b,
-            &c,
-            //d,
-            &mut e,
-            //f,
-        )).unwrap(),
-        "{\"Seq\":[1,2,3,5]}".to_string()
-    );
-
-    assert_eq!(
-        json::to_value(&SerEnum::Seq(
-            a,
-            b,
-            &c,
-            //d,
-            &mut e,
-            //e,
-        )),
-        Value::Object(btreemap!(
-            "Seq".to_string() => Value::Array(vec![
-                Value::I64(1),
-                Value::I64(2),
-                Value::I64(3),
-                //Value::I64(4),
-                Value::I64(5),
-                //Value::I64(6),
-            ])
-        ))
-    );
-}
-
-#[test]
-fn test_ser_enum_map() {
-    let a = 1;
-    let b = 2;
-    let c = 3;
-    //let d = 4;
-    let mut e = 5;
-    //let f = 6;
-
-    assert_eq!(
-        json::to_string(&SerEnum::Map {
-            a: a,
-            b: b,
-            c: &c,
-            //d: d,
-            e: &mut e,
-            //f: f,
-        }).unwrap(),
-        "{\"Map\":{\"a\":1,\"b\":2,\"c\":3,\"e\":5}}".to_string()
-    );
-
-    assert_eq!(
-        json::to_value(&SerEnum::Map {
-            a: a,
-            b: b,
-            c: &c,
-            //d: d,
-            e: &mut e,
-            //f: f,
-        }),
-        Value::Object(btreemap!(
-            "Map".to_string() => Value::Object(btreemap![
-                "a".to_string() => Value::I64(1),
-                "b".to_string() => Value::I64(2),
-                "c".to_string() => Value::I64(3),
-                //"d".to_string() => Value::I64(4)
-                "e".to_string() => Value::I64(5)
-                //"f".to_string() => Value::I64(6)
-            ])
-        ))
-    );
-}
-
-#[test]
-fn test_de_enum_unit() {
-    assert_eq!(
-        json::from_str("{\"Unit\":[]}").unwrap(),
-        DeEnum::Unit::<u32, u32, u32>
-    );
-
-    assert_eq!(
-        json::from_value(Value::Object(btreemap!(
-            "Unit".to_string() => Value::Array(vec![]))
-        )).unwrap(),
-        DeEnum::Unit::<u32, u32, u32>
-    );
-}
-
-#[test]
-fn test_de_enum_seq() {
-    let a = 1;
-    let b = 2;
-    let c = 3;
-    //let d = 4;
-    let e = 5;
-    //let f = 6;
-
-    assert_eq!(
-        json::from_str("{\"Seq\":[1,2,3,5]}").unwrap(),
-        DeEnum::Seq(
-            a,
-            b,
-            c,
-            //d,
-            e,
-            //f,
-        )
-    );
-
-    assert_eq!(
-        json::from_value(Value::Object(btreemap!(
-            "Seq".to_string() => Value::Array(vec![
-                Value::I64(1),
-                Value::I64(2),
-                Value::I64(3),
-                //Value::I64(4),
-                Value::I64(5),
-                //Value::I64(6),
-            ])
-        ))).unwrap(),
-        DeEnum::Seq(
-            a,
-            b,
-            c,
-            //d,
-            e,
-            //e,
-        )
-    );
-}
-
-#[test]
-fn test_de_enum_map() {
-    let a = 1;
-    let b = 2;
-    let c = 3;
-    //let d = 4;
-    let e = 5;
-    //let f = 6;
-
-    assert_eq!(
-        json::from_str("{\"Map\":{\"a\":1,\"b\":2,\"c\":3,\"e\":5}}").unwrap(),
-        DeEnum::Map {
-            a: a,
-            b: b,
-            c: c,
-            //d: d,
-            e: e,
-            //f: f,
-        }
-    );
-
-    assert_eq!(
-        json::from_value(Value::Object(btreemap!(
-            "Map".to_string() => Value::Object(btreemap![
-                "a".to_string() => Value::I64(1),
-                "b".to_string() => Value::I64(2),
-                "c".to_string() => Value::I64(3),
-                //"d".to_string() => Value::I64(4)
-                "e".to_string() => Value::I64(5)
-                //"f".to_string() => Value::I64(6)
-            ])
-        ))).unwrap(),
-        DeEnum::Map {
-            a: a,
-            b: b,
-            c: c,
-            //d: d,
-            e: e,
-            //f: f,
-        }
-    );
-}