Release 0.7.10

Merge pull request #371 from dtolnay/hasher
De/serialize for HashMap<K, V, S> and HashSet<T, S>
2026-04-23 08:18:03 +00:00 · 2016-06-11 13:08:33 -07:00 · 2016-06-11 11:51:57 -07:00 · 2016-06-11 11:15:10 -07:00 · 2016-06-12 02:51:08 +09:00 · 2016-06-11 10:02:10 -07:00
50 changed files with 6844 additions and 2955 deletions
@@ -1,2 +1,3 @@
-target
 Cargo.lock
+target
+*.sw[po]
@@ -1,41 +1,43 @@
 language: rust
-sudo: false
-
 rust:
-  - stable
-  - beta
-  - nightly
-
+- stable
+- beta
+- nightly
+- 1.7.0
+- 1.8.0
 addons:
  apt:
    packages:
    - libcurl4-openssl-dev
    - libelf-dev
    - libdw-dev
-
+    - binutils-dev
 before_script:
- |
-    pip install 'travis-cargo<0.2' --user &&
-    export PATH=$HOME/.local/bin:$PATH
-
+- pip install 'travis-cargo<0.2' --user
+- export PATH=$HOME/.local/bin:$PATH
 script:
- |
-    (cd serde && travis-cargo build) &&
-    (cd serde && travis-cargo test) &&
-    (cd serde_tests && travis-cargo test) &&
-    (cd serde_macros && travis-cargo --only nightly test) &&
-    (cd serde_macros && travis-cargo --only nightly bench) &&
-    (cd serde && travis-cargo --only stable doc) &&
-    (cd serde_codegen && travis-cargo --only stable doc)
-
+- (cd serde && travis-cargo build)
+- (cd serde && travis-cargo test)
+- (cd serde && travis-cargo --only nightly test -- --features nightly-testing)
+- (cd serde && travis-cargo build -- --no-default-features)
+- (cd serde && travis-cargo --only nightly build -- --no-default-features)
+- (cd serde && travis-cargo --only nightly build -- --no-default-features --features alloc)
+- (cd serde && travis-cargo --only nightly build -- --no-default-features --features collections)
+- (cd serde_tests && travis-cargo test)
+- (cd serde_tests && travis-cargo --only nightly test -- --features nightly-testing)
+- (cd serde_macros && travis-cargo --only nightly test -- --features nightly-testing)
+- (cd serde_macros && travis-cargo --only nightly bench -- --features nightly-testing)
+- (cd examples/serde-syntex-example && travis-cargo run)
+- (cd examples/serde-syntex-example && travis-cargo --only nightly run -- --features nightly --no-default-features)
+- (cd serde && travis-cargo --only stable doc)
+- (cd serde_codegen && travis-cargo --only stable doc)
+- (cd serde_macros && travis-cargo --only nightly doc)
 after_success:
 - (cd serde && travis-cargo --only stable doc-upload)
+#- (cd serde_codegen && travis-cargo --only stable doc-upload)
+#- (cd serde_macros && travis-cargo --only nightly doc-upload)
 - (cd serde_tests && travis-cargo coveralls --no-sudo)
-
 env:
  global:
-    # override the default `--features unstable` used for the nightly branch (optional)
-    - TRAVIS_CARGO_NIGHTLY_FEATURE=""
-
-    # encrypted github token for doc upload (see `GH_TOKEN` link above)
-    - secure: HO41LMpMXkF2In9+1sxWVu7fgolL+y9+4Q5PI6wZX2L5pDwpPJCjxaQarQXCEnoIxED1PlP03JuF7ULNz0zw1ylYhAOfOSdkxFZRnE2wMZqq6qvXBHwyMiDrAociIzoPKSGv7JVrKPsjsnd+96K6xxueIodQZrmAdyq7N/M82Mc=
+  - TRAVIS_CARGO_NIGHTLY_FEATURE=""
+  - secure: Jcd11Jy0xLyacBUB+oKOaxKBm9iZNInenRDtNBY8GKOtqF5fHUfEjgDf538hwRl5L0FP7DLr8oK0IHmzA7lPjJxlzoKVKV3IM7bRZEYzW5DMonf/lcliuGte7SH0NVFhifM87T8HI2hjGdAb+7+m34siBR7M3AY/XjLInrvUFvY=
@@ -1,9 +1,10 @@
 Serde Rust Serialization Framework
 ==================================

-[![Build Status](https://api.travis-ci.org/serde-rs/serde.png?branch=master)](https://travis-ci.org/serde-rs/serde)
+[![Build Status](https://api.travis-ci.org/serde-rs/serde.svg?branch=master)](https://travis-ci.org/serde-rs/serde)
 [![Coverage Status](https://coveralls.io/repos/serde-rs/serde/badge.svg?branch=master&service=github)](https://coveralls.io/github/serde-rs/serde?branch=master)
 [![Latest Version](https://img.shields.io/crates/v/serde.svg)](https://crates.io/crates/serde)
+[![Clippy Linting Result](http://clippy.bashy.io/github/serde-rs/serde/master/badge.svg)](http://clippy.bashy.io/github/serde-rs/serde/master/log)

 Serde is a powerful framework that enables serialization libraries to
 generically serialize Rust data structures without the overhead of runtime type
@@ -13,9 +14,7 @@ the same speed as a hand written serializer for a specific type.

 Documentation is available at:

-* [serde](https://serde-rs.github.io/serde/serde/serde/index.html)
-* [serde\_json](https://serde-rs.github.io/serde/serde_json/serde_json/index.html)
-* [serde\_codegen](https://serde-rs.github.io/serde/serde_codegen/serde_codegen/index.html)
+* [serde](https://serde-rs.github.io/serde/serde/index.html)

 Using Serde with Nightly Rust and serde\_macros
 ===============================================
@@ -47,7 +46,6 @@ serde_macros = "*"
 #![feature(custom_derive, plugin)]
 #![plugin(serde_macros)]

-extern crate serde;
 extern crate serde_json;

 #[derive(Serialize, Deserialize, Debug)]
@@ -81,7 +79,7 @@ Using Serde with Stable Rust, syntex, and serde\_codegen

 Stable Rust is a little more complicated because it does not yet support
 compiler plugins. Instead we need to use the code generation library
-[syntex](https://github.com/erickt/rust-syntex) for this:
+[syntex](https://github.com/serde-rs/syntex) for this:

 ```toml
 [package]
@@ -101,7 +99,7 @@ serde_json = "*"

 `src/main.rs`:

-```rust
+```rust,ignore
 extern crate serde;
 extern crate serde_json;

@@ -110,7 +108,7 @@ include!(concat!(env!("OUT_DIR"), "/main.rs"));

 `src/main.rs.in`:

-```rust
+```rust,ignore
 #[derive(Serialize, Deserialize, Debug)]
 struct Point {
    x: i32,
@@ -129,6 +127,25 @@ fn main() {
 }
 ```

+`build.rs`
+
+```rust,ignore
+extern crate syntex;
+extern crate serde_codegen;
+
+use std::env;
+use std::path::Path;
+
+pub fn main() {
+    let out_dir = env::var_os("OUT_DIR").unwrap();
+
+    let src = Path::new("src/main.rs.in");
+    let dst = Path::new(&out_dir).join("main.rs");
+
+    serde_codegen::expand(&src, &dst).unwrap();
+}
+```
+
 This also produces:

 ```
@@ -168,7 +185,7 @@ serde_macros = { version = "*", optional = true }

 `build.rs`:

-```rust
+```rust,ignore
 #[cfg(not(feature = "serde_macros"))]
 mod inner {
    extern crate syntex;
@@ -183,10 +200,7 @@ mod inner {
        let src = Path::new("src/main.rs.in");
        let dst = Path::new(&out_dir).join("main.rs");

-        let mut registry = syntex::Registry::new();
-
-        serde_codegen::register(&mut registry);
-        registry.expand("", &src, &dst).unwrap();
+        serde_codegen::expand(&src, &dst).unwrap();
    }
 }

@@ -202,7 +216,7 @@ fn main() {

 `src/main.rs`:

-```rust
+```rust,ignore
 #![cfg_attr(feature = "serde_macros", feature(custom_derive, plugin))]
 #![cfg_attr(feature = "serde_macros", plugin(serde_macros))]

@@ -227,7 +241,7 @@ Then to run with stable:

 Or with nightly:

-```rust
+```
 % cargo build --features nightly --no-default-features
 ...
 ```
@@ -237,9 +251,9 @@ 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)
+[Serializer](http://serde-rs.github.io/serde/serde/serde/ser/trait.Serializer.html)
 and
-[Serialize](http://serde-rs.github.io/serde/serde/ser/trait.Serialize.html)
+[Serialize](http://serde-rs.github.io/serde/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,
@@ -248,27 +262,27 @@ 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)
+[Serializer](http://serde-rs.github.io/serde/serde/serde/ser/trait.Serializer.html)
 is threaded through the type:

-```rust
+```rust,ignore
 impl serde::Serialize for i32 {
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: serde::Serializer,
    {
-        serializer.visit_i32(*self)
+        serializer.serialize_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)
+[MapVisitor](http://serde-rs.github.io/serde/serde/serde/ser/trait.MapVisitor.html)
 to the 
-[Serializer](http://serde-rs.github.io/serde/serde/ser/trait.Serializer.html)
+[Serializer](http://serde-rs.github.io/serde/serde/serde/ser/trait.Serializer.html)
 in order to walk through the type:

-```rust
+```rust,ignore
 impl<K, V> Serialize for BTreeMap<K, V>
    where K: Serialize + Ord,
          V: Serialize,
@@ -277,7 +291,7 @@ impl<K, V> Serialize for BTreeMap<K, V>
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
+        serializer.serialize_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
    }
 }

@@ -309,7 +323,7 @@ impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
    {
        match self.iter.next() {
            Some((key, value)) => {
-                let value = try!(serializer.visit_map_elt(key, value));
+                let value = try!(serializer.serialize_map_elt(key, value));
                Ok(Some(value))
            }
            None => Ok(None)
@@ -329,6 +343,7 @@ the fields:

 ```rust
 extern crate serde;
+extern crate serde_json;

 struct Point {
    x: i32,
@@ -339,7 +354,7 @@ impl serde::Serialize for Point {
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: serde::Serializer
    {
-        serializer.visit_struct("Point", PointMapVisitor {
+        serializer.serialize_struct("Point", PointMapVisitor {
            value: self,
            state: 0,
        })
@@ -358,11 +373,11 @@ impl<'a> serde::ser::MapVisitor for PointMapVisitor<'a> {
        match self.state {
            0 => {
                self.state += 1;
-                Ok(Some(try!(serializer.visit_struct_elt("x", &self.value.x))))
+                Ok(Some(try!(serializer.serialize_struct_elt("x", &self.value.x))))
            }
            1 => {
                self.state += 1;
-                Ok(Some(try!(serializer.visit_struct_elt("y", &self.value.y))))
+                Ok(Some(try!(serializer.serialize_struct_elt("y", &self.value.y))))
            }
            _ => {
                Ok(None)
@@ -370,6 +385,13 @@ impl<'a> serde::ser::MapVisitor for PointMapVisitor<'a> {
        }
    }
 }
+
+fn main() {
+    let point = Point { x: 1, y: 2 };
+    let serialized = serde_json::to_string(&point).unwrap();
+
+    println!("{}", serialized);
+}
 ```

 Deserialization without Macros
@@ -377,19 +399,19 @@ 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)
+[Deserialize](http://serde-rs.github.io/serde/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)
+[Visitor](http://serde-rs.github.io/serde/serde/serde/de/trait.Visitor.html) to the
+[Deserializer](http://serde-rs.github.io/serde/serde/serde/de/trait.Deserializer.html).
+The [Visitor](http://serde-rs.github.io/serde/serde/serde/de/trait.Visitor.html)
 can create the `i32` from a variety of different types:

-```rust
+```rust,ignore
 impl Deserialize for i32 {
    fn deserialize<D>(deserializer: &mut D) -> Result<i32, D::Error>
        where D: serde::Deserializer,
    {
-        deserializer.visit(I32Visitor)
+        deserializer.deserialize(I32Visitor)
    }
 }

@@ -398,7 +420,7 @@ struct I32Visitor;
 impl serde::de::Visitor for I32Visitor {
    type Value = i32;

-    fn visit_i16<E>(&mut self, value: i16) -> Result<i16, E>
+    fn visit_i16<E>(&mut self, value: i16) -> Result<i32, E>
        where E: Error,
    {
        self.visit_i32(value as i32)
@@ -416,18 +438,18 @@ impl serde::de::Visitor for I32Visitor {

 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,
+[Error](http://serde-rs.github.io/serde/serde/serde/de/trait.Error.html) trait,
 which allows a 
-[Deserialize](http://serde-rs.github.io/serde/serde/de/trait.Deserialize.html)
+[Deserialize](http://serde-rs.github.io/serde/serde/serde/de/trait.Deserialize.html)
 to generate an error for a few common error conditions. Here's how it could be used:

-```rust
+```rust,ignore
    ...

    fn visit_string<E>(&mut self, _: String) -> Result<i32, E>
        where E: Error,
    {
-        Err(serde::de::Error::syntax("expect a string"))
+        Err(serde::de::Error::custom("expect a string"))
    }

    ...
@@ -435,11 +457,11 @@ to generate an error for a few common error conditions. Here's how it could be u
 ```

 Maps follow a similar pattern as before, and use a
-[MapVisitor](http://serde-rs.github.io/serde/serde/de/trait.MapVisitor.html)
+[MapVisitor](http://serde-rs.github.io/serde/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).
+[Deserializer](http://serde-rs.github.io/serde/serde/serde/de/trait.Deserializer.html).

-```rust
+```rust,ignore
 impl<K, V> serde::Deserialize for BTreeMap<K, V>
    where K: serde::Deserialize + Eq + Ord,
          V: serde::Deserialize,
@@ -447,7 +469,7 @@ impl<K, V> serde::Deserialize for BTreeMap<K, V>
    fn deserialize<D>(deserializer: &mut D) -> Result<BTreeMap<K, V>, D::Error>
        where D: serde::Deserializer,
    {
-        deserializer.visit(BTreeMapVisitor::new())
+        deserializer.deserialize(BTreeMapVisitor::new())
    }
 }

@@ -489,7 +511,6 @@ impl<K, V> serde::de::Visitor for BTreeMapVisitor<K, V>
        Ok(values)
    }
 }
-
 ```

 Deserializing structs goes a step further in order to support not allocating a
@@ -499,7 +520,9 @@ before, we need to generate:

 ```rust
 extern crate serde;
+extern crate serde_json;

+#[derive(Debug)]
 struct Point {
    x: i32,
    y: i32,
@@ -525,12 +548,12 @@ impl serde::Deserialize for PointField {
                match value {
                    "x" => Ok(PointField::X),
                    "y" => Ok(PointField::Y),
-                    _ => Err(serde::de::Error::syntax("expected x or y")),
+                    _ => Err(serde::de::Error::custom("expected x or y")),
                }
            }
        }

-        deserializer.visit(PointFieldVisitor)
+        deserializer.deserialize(PointFieldVisitor)
    }
 }

@@ -539,7 +562,7 @@ impl serde::Deserialize for Point {
        where D: serde::de::Deserializer
    {
        static FIELDS: &'static [&'static str] = &["x", "y"];
-        deserializer.visit_struct("Point", FIELDS, PointVisitor)
+        deserializer.deserialize_struct("Point", FIELDS, PointVisitor)
    }
 }

@@ -577,6 +600,15 @@ impl serde::de::Visitor for PointVisitor {
        Ok(Point{ x: x, y: y })
    }
 }
+
+
+fn main() {
+    let serialized = "{\"x\":1,\"y\":2}";
+
+    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
+
+    println!("{:?}", deserialized);
+}
 ```

 Design Considerations and tradeoffs for Serializers and Deserializers
@@ -595,7 +627,7 @@ as either a `null`, or some other value. Serde `Serializer`s and
 `Deserializer`s can opt-in support for this. For serialization, this is pretty
 easy. Simply implement these methods:

-```rust
+```rust,ignore
 ...

    fn visit_none(&mut self) -> Result<(), Self::Error> {
@@ -615,7 +647,7 @@ next value in the serialized token stream. This following example is from
 where it checks to see if the next value is an `Option`, a `()`, or some other
 value:

-```rust
+```rust,ignore
 ...

    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
@@ -648,22 +680,71 @@ Annotations
 `serde_codegen` and `serde_macros` support annotations that help to customize
 how types are serialized. Here are the supported annotations:

-| Annotation                                   | Function                                                       |
-| ----------                                   | --------                                                       |
-| `#[serde(rename(json="name1", xml="name2"))` | Serialize this field with the given name for the given formats |
-| `#[serde(default)`                           | If the value is not specified, use the `Default::default()`    |
-| `#[serde(rename="name")`                     | Serialize this field with the given name                       |
-| `#[serde(skip_serializing)`                  | Do not serialize this value                                    |
-| `#[serde(skip_serializing_if_empty)`         | Do not serialize this value if `$value.is_empty()` is `true`   |
-| `#[serde(skip_serializing_if_none)`          | Do not serialize this value if `$value.is_none()` is `true`    |
+Container Annotations:
+
+| Annotation                                  | Function                                                                                                                                           |
+| ----------                                  | --------                                                                                                                                           |
+| `#[serde(rename="name")]`                   | Serialize and deserialize this container with the given name                                                                                       |
+| `#[serde(rename(serialize="name1"))]`       | Serialize this container with the given name                                                                                                       |
+| `#[serde(rename(deserialize="name1"))]`     | Deserialize this container with the given name                                                                                                     |
+| `#[serde(deny_unknown_fields)]`             | Always error during serialization when encountering unknown fields. When absent, unknown fields are ignored for self-describing formats like JSON. |
+| `#[serde(bound="T: MyTrait")]`              | Where-clause for the Serialize and Deserialize impls. This replaces any bounds inferred by Serde.                                                  |
+| `#[serde(bound(serialize="T: MyTrait"))]`   | Where-clause for the Serialize impl.                                                                                                               |
+| `#[serde(bound(deserialize="T: MyTrait"))]` | Where-clause for the Deserialize impl.                                                                                                             |
+
+Variant Annotations:
+
+| Annotation                              | Function                                                   |
+| ----------                              | --------                                                   |
+| `#[serde(rename="name")]`               | Serialize and deserialize this variant with the given name |
+| `#[serde(rename(serialize="name1"))]`   | Serialize this variant with the given name                 |
+| `#[serde(rename(deserialize="name1"))]` | Deserialize this variant with the given name               |
+
+Field Annotations:
+
+| Annotation                                  | Function                                                                                                                |
+| ----------                                  | --------                                                                                                                |
+| `#[serde(rename="name")]`                   | Serialize and deserialize this field with the given name                                                                |
+| `#[serde(rename(serialize="name1"))]`       | Serialize this field with the given name                                                                                |
+| `#[serde(rename(deserialize="name1"))]`     | Deserialize this field with the given name                                                                              |
+| `#[serde(default)]`                         | If the value is not specified, use the `Default::default()`                                                             |
+| `#[serde(default="$path")]`                 | Call the path to a function `fn() -> T` to build the value                                                              |
+| `#[serde(skip_serializing)]`                | Do not serialize this value                                                                                             |
+| `#[serde(skip_deserializing)]`              | Always use `Default::default()` or `#[serde(default="$path")]` instead of deserializing this value                      |
+| `#[serde(skip_serializing_if="$path")]`     | Do not serialize this value if this function `fn(&T) -> bool` returns `true`                                            |
+| `#[serde(serialize_with="$path")]`          | Call a function `fn<S>(&T, &mut S) -> Result<(), S::Error> where S: Serializer` to serialize this value of type `T`     |
+| `#[serde(deserialize_with="$path")]`        | Call a function `fn<D>(&mut D) -> Result<T, D::Error> where D: Deserializer` to deserialize this value of type `T`      |
+| `#[serde(bound="T: MyTrait")]`              | Where-clause for the Serialize and Deserialize impls. This replaces any bounds inferred by Serde for the current field. |
+| `#[serde(bound(serialize="T: MyTrait"))]`   | Where-clause for the Serialize impl.                                                                                    |
+| `#[serde(bound(deserialize="T: MyTrait"))]` | Where-clause for the Deserialize impl.                                                                                  |
+
+Using in `no_std` crates
+========================
+
+The core `serde` package defines a number of features to enable usage in a
+variety of freestanding environments. Enable any or none of the following
+features, and use `default-features = false` in your `Cargo.toml`:
+
+- `alloc` (implies `nightly`)
+- `collections` (implies `alloc` and `nightly`)
+- `std` (default)
+
+If you only use `default-features = false`, you will receive a stock `no_std`
+serde with no support for any of the collection types.
+
+Upgrading from Serde 0.6
+========================
+
+* `#[serde(skip_serializing_if_none)]` was replaced with `#[serde(skip_serializing_if="Option::is_none")]`.
+* `#[serde(skip_serializing_if_empty)]` was replaced with `#[serde(skip_serializing_if="Vec::is_empty")]`.

 Serialization Formats Using Serde
 =================================

-| Format      | Name                                               |
-| ------      | ----                                               |
-| Bincode     | [bincode](https://crates.io/crates/bincode)        |
-| JSON        | [serde\_json](https://crates.io/crates/serde_json) |
-| MessagePack | [rmp](https://crates.io/crates/rmp)                |
-| XML         | [serde\_xml](https://github.com/serde-rs/xml)      |
-| YAML        | [serde\_yaml](https://github.com/serde-rs/yaml/)   |
+| Format      | Name                                                 |
+| ------      | ----                                                 |
+| Bincode     | [bincode](https://crates.io/crates/bincode)          |
+| JSON        | [serde\_json](https://crates.io/crates/serde_json)   |
+| MessagePack | [rmp](https://crates.io/crates/rmp)                  |
+| XML         | [serde\_xml](https://github.com/serde-rs/xml)        |
+| YAML        | [serde\_yaml](https://github.com/dtolnay/serde-yaml) |
@@ -0,0 +1,5 @@
+paths = [
+    "../serde",
+    "../serde_codegen",
+    "../serde_macros",
+]
@@ -9,10 +9,10 @@ default = ["serde_codegen"]
 nightly = ["serde_macros"]

 [build-dependencies]
-serde_codegen = { version = "^0.6.4", optional = true }
-syntex = "^0.22.0"
+serde_codegen = { version = "^0.7.10", optional = true }
+syntex = "^0.33.0"

 [dependencies]
-serde = "^0.6.1"
-serde_json = "^0.6.0"
-serde_macros = { version = "^0.6.1", optional = true }
+serde = "^0.7.10"
+serde_json = "^0.7.0"
+serde_macros = { version = "^0.7.10", optional = true }
@@ -2,12 +2,12 @@ This example demonstrates how to use Serde with Syntex. On stable or nightly
 with Syntex, it can be built with:

 ```
-% multirust run stable cargo run
+% rustup run stable cargo run
     Running `target/debug/serde-syntex-example`
 {"x":1,"y":2}
 Point { x: 1, y: 2 }

-% multirust run nightly cargo run
+% rustup run nightly cargo run
     Running `target/debug/serde-syntex-example`
 {"x":1,"y":2}
 Point { x: 1, y: 2 }
@@ -16,5 +16,5 @@ Point { x: 1, y: 2 }
 On nightly, it can use a plugin with:

 ```
-% multirust run nightly cargo run --features nightly --no-default-features
+% rustup run nightly cargo run --features nightly --no-default-features
 ```
@@ -12,10 +12,7 @@ mod inner {
        let src = Path::new("src/main.rs.in");
        let dst = Path::new(&out_dir).join("main.rs");

-        let mut registry = syntex::Registry::new();
-
-        serde_codegen::register(&mut registry);
-        registry.expand("", &src, &dst).unwrap();
+        serde_codegen::expand(&src, &dst).unwrap();
    }
 }

@@ -1,5 +1,5 @@
-#![cfg_attr(nightly, feature(custom_derive, plugin))]
-#![cfg_attr(nightly, plugin(serde_macros))]
+#![cfg_attr(feature = "serde_macros", feature(custom_derive, plugin))]
+#![cfg_attr(feature = "serde_macros", plugin(serde_macros))]

 extern crate serde;
 extern crate serde_json;
@@ -1,21 +1,23 @@
 [package]
 name = "serde"
-version = "0.6.11"
+version = "0.7.10"
 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 = "https://serde-rs.github.io/serde/serde/serde/index.html"
+documentation = "https://serde-rs.github.io/serde/serde/"
 readme = "../README.md"
 keywords = ["serde", "serialization"]
+include = ["Cargo.toml", "src/**/*.rs"]

 [features]
-nightly = ["clippy"]
-num-bigint = ["num/bigint"]
-num-complex = ["num/complex"]
-num-impls = ["num-bigint", "num-complex", "num-rational"]
-num-rational = ["num/rational"]
+default = ["std"]
+
+std = []
+nightly = []
+alloc = ["nightly"]
+collections = ["alloc"]
+nightly-testing = ["clippy", "nightly", "std"]

 [dependencies]
-clippy = { version = "^0.0.37", optional = true }
-num = { version = "^0.1.27", default-features = false }
+clippy = { version = "^0.*", optional = true }
@@ -1,11 +1,15 @@
 //! Helper module to enable serializing bytes more efficiently

-use std::ops;
-use std::fmt;
-use std::ascii;
+use core::{ops, fmt, char, iter, slice};
+use core::fmt::Write;

 use ser;
-use de;
+
+#[cfg(any(feature = "std", feature = "collections"))]
+pub use self::bytebuf::{ByteBuf, ByteBufVisitor};
+
+#[cfg(feature = "collections")]
+use collections::Vec;

 ///////////////////////////////////////////////////////////////////////////////

@@ -17,7 +21,11 @@ pub struct Bytes<'a> {

 impl<'a> fmt::Debug for Bytes<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "b\"{}\"", escape_bytestring(self.bytes))
+        try!(f.write_str("b\""));
+        for c in escape_bytestring(self.bytes) {
+            try!(f.write_char(c));
+        }
+        f.write_char('"')
    }
 }

@@ -29,10 +37,11 @@ impl<'a> From<&'a [u8]> for Bytes<'a> {
    }
 }

+#[cfg(any(feature = "std", feature = "collections"))]
 impl<'a> From<&'a Vec<u8>> for Bytes<'a> {
    fn from(bytes: &'a Vec<u8>) -> Self {
        Bytes {
-            bytes: &bytes,
+            bytes: bytes,
        }
    }
 }
@@ -54,163 +63,178 @@ impl<'a> ser::Serialize for Bytes<'a> {
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: ser::Serializer
    {
-        serializer.visit_bytes(self.bytes)
+        serializer.serialize_bytes(self.bytes)
    }
 }

 ///////////////////////////////////////////////////////////////////////////////

-/// `ByteBuf` wraps a `Vec<u8>` and serializes as a byte array.
-#[derive(Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]
-pub struct ByteBuf {
-    bytes: Vec<u8>,
-}
+#[cfg(any(feature = "std", feature = "collections"))]
+mod bytebuf {
+    use core::ops;
+    use core::fmt;
+    use core::fmt::Write;

-impl ByteBuf {
-    /// Construct a new, empty `ByteBuf`.
-    pub fn new() -> Self {
-        ByteBuf {
-            bytes: Vec::new(),
+    use ser;
+    use de;
+
+    #[cfg(feature = "collections")]
+    use collections::Vec;
+
+    /// `ByteBuf` wraps a `Vec<u8>` and serializes as a byte array.
+    #[derive(Clone, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
+    pub struct ByteBuf {
+        bytes: Vec<u8>,
+    }
+
+    impl ByteBuf {
+        /// Construct a new, empty `ByteBuf`.
+        pub fn new() -> Self {
+            ByteBuf {
+                bytes: Vec::new(),
+            }
+        }
+
+        /// Construct a new, empty `ByteBuf` with the specified capacity.
+        pub fn with_capacity(cap: usize) -> Self {
+            ByteBuf {
+                bytes: Vec::with_capacity(cap)
+            }
        }
    }

-    /// Construct a new, empty `ByteBuf` with the specified capacity.
-    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 {
+            try!(f.write_str("b\""));
+            for c in super::escape_bytestring(self.bytes.as_ref()) {
+                try!(f.write_char(c));
+            }
+            f.write_char('"')
        }
    }
-}

-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 Into<Vec<u8>> for ByteBuf {
+        fn into(self) -> Vec<u8> {
+            self.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)
-    }
-}
-
-/// This type implements the `serde::de::Visitor` trait for a `ByteBuf`.
-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(),
-        })
+    impl From<Vec<u8>> for ByteBuf {
+        fn from(bytes: Vec<u8>) -> Self {
+            ByteBuf {
+                bytes: bytes,
+            }
+        }
    }

-    #[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);
+    impl AsRef<Vec<u8>> for ByteBuf {
+        fn as_ref(&self) -> &Vec<u8> {
+            &self.bytes
+        }
+    }

-        while let Some(value) = try!(visitor.visit()) {
-            values.push(value);
+    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.serialize_bytes(self)
+        }
+    }
+
+    /// This type implements the `serde::de::Visitor` trait for a `ByteBuf`.
+    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(),
+            })
        }

-        try!(visitor.end());
+        #[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);

-        Ok(ByteBuf {
-            bytes: values,
-        })
+            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,
+            })
+        }
    }

-    #[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)
+    impl de::Deserialize for ByteBuf {
+        #[inline]
+        fn deserialize<D>(deserializer: &mut D) -> Result<ByteBuf, D::Error>
+            where D: de::Deserializer
+        {
+            deserializer.deserialize_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);
-        }
+#[inline]
+fn escape_bytestring<'a>(bytes: &'a [u8]) -> iter::FlatMap<slice::Iter<'a, u8>, char::EscapeDefault, fn(&u8) -> char::EscapeDefault> {
+    fn f(b: &u8) -> char::EscapeDefault {
+        char::from_u32(*b as u32).unwrap().escape_default()
    }
-    result
+    bytes.iter().flat_map(f as fn(&u8) -> char::EscapeDefault)
 }
@@ -0,0 +1,409 @@
+// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Extracted from https://github.com/rust-num/num.
+
+// Rust 1.5 is unhappy that this private module is undocumented.
+#![allow(missing_docs)]
+
+use core::{usize, u8, u16, u32, u64};
+use core::{isize, i8, i16, i32, i64};
+use core::{f32, f64};
+use core::mem::size_of;
+
+/// Numbers which have upper and lower bounds
+pub trait Bounded {
+    // FIXME (#5527): These should be associated constants
+    /// returns the smallest finite number this type can represent
+    fn min_value() -> Self;
+    /// returns the largest finite number this type can represent
+    fn max_value() -> Self;
+}
+
+macro_rules! bounded_impl {
+    ($t:ty, $min:expr, $max:expr) => {
+        impl Bounded for $t {
+            #[inline]
+            fn min_value() -> $t { $min }
+
+            #[inline]
+            fn max_value() -> $t { $max }
+        }
+    }
+}
+
+bounded_impl!(usize, usize::MIN, usize::MAX);
+bounded_impl!(u8, u8::MIN, u8::MAX);
+bounded_impl!(u16, u16::MIN, u16::MAX);
+bounded_impl!(u32, u32::MIN, u32::MAX);
+bounded_impl!(u64, u64::MIN, u64::MAX);
+
+bounded_impl!(isize, isize::MIN, isize::MAX);
+bounded_impl!(i8, i8::MIN, i8::MAX);
+bounded_impl!(i16, i16::MIN, i16::MAX);
+bounded_impl!(i32, i32::MIN, i32::MAX);
+bounded_impl!(i64, i64::MIN, i64::MAX);
+
+bounded_impl!(f32, f32::MIN, f32::MAX);
+bounded_impl!(f64, f64::MIN, f64::MAX);
+
+/// A generic trait for converting a value to a number.
+pub trait ToPrimitive {
+    /// Converts the value of `self` to an `isize`.
+    #[inline]
+    fn to_isize(&self) -> Option<isize> {
+        self.to_i64().and_then(|x| x.to_isize())
+    }
+
+    /// Converts the value of `self` to an `i8`.
+    #[inline]
+    fn to_i8(&self) -> Option<i8> {
+        self.to_i64().and_then(|x| x.to_i8())
+    }
+
+    /// Converts the value of `self` to an `i16`.
+    #[inline]
+    fn to_i16(&self) -> Option<i16> {
+        self.to_i64().and_then(|x| x.to_i16())
+    }
+
+    /// Converts the value of `self` to an `i32`.
+    #[inline]
+    fn to_i32(&self) -> Option<i32> {
+        self.to_i64().and_then(|x| x.to_i32())
+    }
+
+    /// Converts the value of `self` to an `i64`.
+    fn to_i64(&self) -> Option<i64>;
+
+    /// Converts the value of `self` to a `usize`.
+    #[inline]
+    fn to_usize(&self) -> Option<usize> {
+        self.to_u64().and_then(|x| x.to_usize())
+    }
+
+    /// Converts the value of `self` to an `u8`.
+    #[inline]
+    fn to_u8(&self) -> Option<u8> {
+        self.to_u64().and_then(|x| x.to_u8())
+    }
+
+    /// Converts the value of `self` to an `u16`.
+    #[inline]
+    fn to_u16(&self) -> Option<u16> {
+        self.to_u64().and_then(|x| x.to_u16())
+    }
+
+    /// Converts the value of `self` to an `u32`.
+    #[inline]
+    fn to_u32(&self) -> Option<u32> {
+        self.to_u64().and_then(|x| x.to_u32())
+    }
+
+    /// Converts the value of `self` to an `u64`.
+    #[inline]
+    fn to_u64(&self) -> Option<u64>;
+
+    /// Converts the value of `self` to an `f32`.
+    #[inline]
+    fn to_f32(&self) -> Option<f32> {
+        self.to_f64().and_then(|x| x.to_f32())
+    }
+
+    /// Converts the value of `self` to an `f64`.
+    #[inline]
+    fn to_f64(&self) -> Option<f64> {
+        self.to_i64().and_then(|x| x.to_f64())
+    }
+}
+
+macro_rules! impl_to_primitive_int_to_int {
+    ($SrcT:ty, $DstT:ty, $slf:expr) => (
+        {
+            if size_of::<$SrcT>() <= size_of::<$DstT>() {
+                Some($slf as $DstT)
+            } else {
+                let n = $slf as i64;
+                let min_value: $DstT = Bounded::min_value();
+                let max_value: $DstT = Bounded::max_value();
+                if min_value as i64 <= n && n <= max_value as i64 {
+                    Some($slf as $DstT)
+                } else {
+                    None
+                }
+            }
+        }
+    )
+}
+
+macro_rules! impl_to_primitive_int_to_uint {
+    ($SrcT:ty, $DstT:ty, $slf:expr) => (
+        {
+            let zero: $SrcT = 0;
+            let max_value: $DstT = Bounded::max_value();
+            if zero <= $slf && $slf as u64 <= max_value as u64 {
+                Some($slf as $DstT)
+            } else {
+                None
+            }
+        }
+    )
+}
+
+macro_rules! impl_to_primitive_int {
+    ($T:ty) => (
+        impl ToPrimitive for $T {
+            #[inline]
+            fn to_isize(&self) -> Option<isize> { impl_to_primitive_int_to_int!($T, isize, *self) }
+            #[inline]
+            fn to_i8(&self) -> Option<i8> { impl_to_primitive_int_to_int!($T, i8, *self) }
+            #[inline]
+            fn to_i16(&self) -> Option<i16> { impl_to_primitive_int_to_int!($T, i16, *self) }
+            #[inline]
+            fn to_i32(&self) -> Option<i32> { impl_to_primitive_int_to_int!($T, i32, *self) }
+            #[inline]
+            fn to_i64(&self) -> Option<i64> { impl_to_primitive_int_to_int!($T, i64, *self) }
+
+            #[inline]
+            fn to_usize(&self) -> Option<usize> { impl_to_primitive_int_to_uint!($T, usize, *self) }
+            #[inline]
+            fn to_u8(&self) -> Option<u8> { impl_to_primitive_int_to_uint!($T, u8, *self) }
+            #[inline]
+            fn to_u16(&self) -> Option<u16> { impl_to_primitive_int_to_uint!($T, u16, *self) }
+            #[inline]
+            fn to_u32(&self) -> Option<u32> { impl_to_primitive_int_to_uint!($T, u32, *self) }
+            #[inline]
+            fn to_u64(&self) -> Option<u64> { impl_to_primitive_int_to_uint!($T, u64, *self) }
+
+            #[inline]
+            fn to_f32(&self) -> Option<f32> { Some(*self as f32) }
+            #[inline]
+            fn to_f64(&self) -> Option<f64> { Some(*self as f64) }
+        }
+    )
+}
+
+impl_to_primitive_int! { isize }
+impl_to_primitive_int! { i8 }
+impl_to_primitive_int! { i16 }
+impl_to_primitive_int! { i32 }
+impl_to_primitive_int! { i64 }
+
+macro_rules! impl_to_primitive_uint_to_int {
+    ($DstT:ty, $slf:expr) => (
+        {
+            let max_value: $DstT = Bounded::max_value();
+            if $slf as u64 <= max_value as u64 {
+                Some($slf as $DstT)
+            } else {
+                None
+            }
+        }
+    )
+}
+
+macro_rules! impl_to_primitive_uint_to_uint {
+    ($SrcT:ty, $DstT:ty, $slf:expr) => (
+        {
+            if size_of::<$SrcT>() <= size_of::<$DstT>() {
+                Some($slf as $DstT)
+            } else {
+                let zero: $SrcT = 0;
+                let max_value: $DstT = Bounded::max_value();
+                if zero <= $slf && $slf as u64 <= max_value as u64 {
+                    Some($slf as $DstT)
+                } else {
+                    None
+                }
+            }
+        }
+    )
+}
+
+macro_rules! impl_to_primitive_uint {
+    ($T:ty) => (
+        impl ToPrimitive for $T {
+            #[inline]
+            fn to_isize(&self) -> Option<isize> { impl_to_primitive_uint_to_int!(isize, *self) }
+            #[inline]
+            fn to_i8(&self) -> Option<i8> { impl_to_primitive_uint_to_int!(i8, *self) }
+            #[inline]
+            fn to_i16(&self) -> Option<i16> { impl_to_primitive_uint_to_int!(i16, *self) }
+            #[inline]
+            fn to_i32(&self) -> Option<i32> { impl_to_primitive_uint_to_int!(i32, *self) }
+            #[inline]
+            fn to_i64(&self) -> Option<i64> { impl_to_primitive_uint_to_int!(i64, *self) }
+
+            #[inline]
+            fn to_usize(&self) -> Option<usize> {
+                impl_to_primitive_uint_to_uint!($T, usize, *self)
+            }
+            #[inline]
+            fn to_u8(&self) -> Option<u8> { impl_to_primitive_uint_to_uint!($T, u8, *self) }
+            #[inline]
+            fn to_u16(&self) -> Option<u16> { impl_to_primitive_uint_to_uint!($T, u16, *self) }
+            #[inline]
+            fn to_u32(&self) -> Option<u32> { impl_to_primitive_uint_to_uint!($T, u32, *self) }
+            #[inline]
+            fn to_u64(&self) -> Option<u64> { impl_to_primitive_uint_to_uint!($T, u64, *self) }
+
+            #[inline]
+            fn to_f32(&self) -> Option<f32> { Some(*self as f32) }
+            #[inline]
+            fn to_f64(&self) -> Option<f64> { Some(*self as f64) }
+        }
+    )
+}
+
+impl_to_primitive_uint! { usize }
+impl_to_primitive_uint! { u8 }
+impl_to_primitive_uint! { u16 }
+impl_to_primitive_uint! { u32 }
+impl_to_primitive_uint! { u64 }
+
+macro_rules! impl_to_primitive_float_to_float {
+    ($SrcT:ident, $DstT:ident, $slf:expr) => (
+        if size_of::<$SrcT>() <= size_of::<$DstT>() {
+            Some($slf as $DstT)
+        } else {
+            let n = $slf as f64;
+            let max_value: $SrcT = ::core::$SrcT::MAX;
+            if -max_value as f64 <= n && n <= max_value as f64 {
+                Some($slf as $DstT)
+            } else {
+                None
+            }
+        }
+    )
+}
+
+macro_rules! impl_to_primitive_float {
+    ($T:ident) => (
+        impl ToPrimitive for $T {
+            #[inline]
+            fn to_isize(&self) -> Option<isize> { Some(*self as isize) }
+            #[inline]
+            fn to_i8(&self) -> Option<i8> { Some(*self as i8) }
+            #[inline]
+            fn to_i16(&self) -> Option<i16> { Some(*self as i16) }
+            #[inline]
+            fn to_i32(&self) -> Option<i32> { Some(*self as i32) }
+            #[inline]
+            fn to_i64(&self) -> Option<i64> { Some(*self as i64) }
+
+            #[inline]
+            fn to_usize(&self) -> Option<usize> { Some(*self as usize) }
+            #[inline]
+            fn to_u8(&self) -> Option<u8> { Some(*self as u8) }
+            #[inline]
+            fn to_u16(&self) -> Option<u16> { Some(*self as u16) }
+            #[inline]
+            fn to_u32(&self) -> Option<u32> { Some(*self as u32) }
+            #[inline]
+            fn to_u64(&self) -> Option<u64> { Some(*self as u64) }
+
+            #[inline]
+            fn to_f32(&self) -> Option<f32> { impl_to_primitive_float_to_float!($T, f32, *self) }
+            #[inline]
+            fn to_f64(&self) -> Option<f64> { impl_to_primitive_float_to_float!($T, f64, *self) }
+        }
+    )
+}
+
+impl_to_primitive_float! { f32 }
+impl_to_primitive_float! { f64 }
+
+pub trait FromPrimitive: Sized {
+    #[inline]
+    fn from_isize(n: isize) -> Option<Self> {
+        FromPrimitive::from_i64(n as i64)
+    }
+
+    #[inline]
+    fn from_i8(n: i8) -> Option<Self> {
+        FromPrimitive::from_i64(n as i64)
+    }
+
+    #[inline]
+    fn from_i16(n: i16) -> Option<Self> {
+        FromPrimitive::from_i64(n as i64)
+    }
+
+    #[inline]
+    fn from_i32(n: i32) -> Option<Self> {
+        FromPrimitive::from_i64(n as i64)
+    }
+
+    fn from_i64(n: i64) -> Option<Self>;
+
+    #[inline]
+    fn from_usize(n: usize) -> Option<Self> {
+        FromPrimitive::from_u64(n as u64)
+    }
+
+    #[inline]
+    fn from_u8(n: u8) -> Option<Self> {
+        FromPrimitive::from_u64(n as u64)
+    }
+
+    #[inline]
+    fn from_u16(n: u16) -> Option<Self> {
+        FromPrimitive::from_u64(n as u64)
+    }
+
+    #[inline]
+    fn from_u32(n: u32) -> Option<Self> {
+        FromPrimitive::from_u64(n as u64)
+    }
+
+    fn from_u64(n: u64) -> Option<Self>;
+
+    #[inline]
+    fn from_f32(n: f32) -> Option<Self> {
+        FromPrimitive::from_f64(n as f64)
+    }
+
+    #[inline]
+    fn from_f64(n: f64) -> Option<Self> {
+        FromPrimitive::from_i64(n as i64)
+    }
+}
+
+macro_rules! impl_from_primitive {
+    ($T:ty, $to_ty:ident) => (
+        impl FromPrimitive for $T {
+            #[inline] fn from_i8(n: i8) -> Option<$T> { n.$to_ty() }
+            #[inline] fn from_i16(n: i16) -> Option<$T> { n.$to_ty() }
+            #[inline] fn from_i32(n: i32) -> Option<$T> { n.$to_ty() }
+            #[inline] fn from_i64(n: i64) -> Option<$T> { n.$to_ty() }
+
+            #[inline] fn from_u8(n: u8) -> Option<$T> { n.$to_ty() }
+            #[inline] fn from_u16(n: u16) -> Option<$T> { n.$to_ty() }
+            #[inline] fn from_u32(n: u32) -> Option<$T> { n.$to_ty() }
+            #[inline] fn from_u64(n: u64) -> Option<$T> { n.$to_ty() }
+
+            #[inline] fn from_f32(n: f32) -> Option<$T> { n.$to_ty() }
+            #[inline] fn from_f64(n: f64) -> Option<$T> { n.$to_ty() }
+        }
+    )
+}
+
+impl_from_primitive! { isize, to_isize }
+impl_from_primitive! { i8, to_i8 }
+impl_from_primitive! { i16, to_i16 }
+impl_from_primitive! { i32, to_i32 }
+impl_from_primitive! { i64, to_i64 }
+impl_from_primitive! { usize, to_usize }
+impl_from_primitive! { u8, to_u8 }
+impl_from_primitive! { u16, to_u16 }
+impl_from_primitive! { u32, to_u32 }
+impl_from_primitive! { u64, to_u64 }
+impl_from_primitive! { f32, to_f32 }
+impl_from_primitive! { f64, to_f64 }
@@ -1,31 +1,63 @@
 //! This module contains `Deserialize` and `Visitor` implementations.

+#[cfg(feature = "std")]
 use std::borrow::Cow;
-use std::collections::{
+#[cfg(all(feature = "nightly", feature = "collections", not(feature = "std")))]
+use collections::borrow::Cow;
+
+#[cfg(all(feature = "collections", not(feature = "std")))]
+use collections::{
    BinaryHeap,
    BTreeMap,
    BTreeSet,
    LinkedList,
+    VecDeque,
+    Vec,
+    String,
+};
+
+#[cfg(feature = "std")]
+use std::collections::{
    HashMap,
    HashSet,
+    BinaryHeap,
+    BTreeMap,
+    BTreeSet,
+    LinkedList,
    VecDeque,
 };
-#[cfg(feature = "nightly")]
-use collections::enum_set::{CLike, EnumSet};
-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(all(feature = "nightly", feature = "collections"))]
+use collections::enum_set::{CLike, EnumSet};
+#[cfg(all(feature = "nightly", feature = "collections"))]
+use collections::borrow::ToOwned;
+
+use core::hash::{Hash, BuildHasher};
+use core::marker::PhantomData;
+#[cfg(feature = "std")]
+use std::net;
+#[cfg(feature = "std")]
+use std::path;
+use core::str;
+
+#[cfg(feature = "std")]
+use std::rc::Rc;
+#[cfg(all(feature = "nightly", feature = "alloc", not(feature = "std")))]
+use alloc::rc::Rc;
+
+#[cfg(feature = "std")]
+use std::sync::Arc;
+#[cfg(all(feature = "nightly", feature = "alloc", not(feature = "std")))]
+use alloc::arc::Arc;
+
+#[cfg(all(feature = "nightly", feature = "alloc", not(feature = "std")))]
+use alloc::boxed::Box;

 #[cfg(feature = "nightly")]
 use core::nonzero::{NonZero, Zeroable};

 #[cfg(feature = "nightly")]
-use std::num::Zero;
+use core::num::Zero;

 use de::{
    Deserialize,
@@ -38,6 +70,7 @@ use de::{
    VariantVisitor,
    Visitor,
 };
+use de::from_primitive::FromPrimitive;

 ///////////////////////////////////////////////////////////////////////////////

@@ -64,7 +97,7 @@ impl Deserialize for () {
    fn deserialize<D>(deserializer: &mut D) -> Result<(), D::Error>
        where D: Deserializer,
    {
-        deserializer.visit_unit(UnitVisitor)
+        deserializer.deserialize_unit(UnitVisitor)
    }
 }

@@ -85,10 +118,10 @@ impl Visitor for BoolVisitor {
    fn visit_str<E>(&mut self, s: &str) -> Result<bool, E>
        where E: Error,
    {
-        match s.trim() {
+        match s.trim_matches(::utils::Pattern_White_Space) {
            "true" => Ok(true),
            "false" => Ok(false),
-            _ => Err(Error::type_mismatch(Type::Bool)),
+            _ => Err(Error::invalid_type(Type::Bool)),
        }
    }
 }
@@ -97,7 +130,7 @@ impl Deserialize for bool {
    fn deserialize<D>(deserializer: &mut D) -> Result<bool, D::Error>
        where D: Deserializer,
    {
-        deserializer.visit_bool(BoolVisitor)
+        deserializer.deserialize_bool(BoolVisitor)
    }
 }

@@ -111,30 +144,30 @@ macro_rules! impl_deserialize_num_method {
        {
            match FromPrimitive::$from_method(v) {
                Some(v) => Ok(v),
-                None => Err(Error::type_mismatch($ty)),
+                None => Err(Error::invalid_type($ty)),
            }
        }
    }
 }

 /// A visitor that produces a primitive type.
-pub struct PrimitiveVisitor<T> {
+struct PrimitiveVisitor<T> {
    marker: PhantomData<T>,
 }

 impl<T> PrimitiveVisitor<T> {
    /// Construct a new `PrimitiveVisitor`.
    #[inline]
-    pub fn new() -> Self {
+    fn new() -> Self {
        PrimitiveVisitor {
            marker: PhantomData,
        }
    }
 }

-impl<
-    T: Deserialize + FromPrimitive + str::FromStr
-> Visitor for PrimitiveVisitor<T> {
+impl<T> Visitor for PrimitiveVisitor<T>
+    where T: Deserialize + FromPrimitive + str::FromStr
+{
    type Value = T;

    impl_deserialize_num_method!(isize, visit_isize, from_isize, Type::Isize);
@@ -151,11 +184,11 @@ impl<
    impl_deserialize_num_method!(f64, visit_f64, from_f64, Type::F64);

    #[inline]
-    fn visit_str<E>(&mut self, v: &str) -> Result<T, E>
+    fn visit_str<E>(&mut self, s: &str) -> Result<T, E>
        where E: Error,
    {
-        str::FromStr::from_str(v.trim()).or_else(|_| {
-            Err(Error::type_mismatch(Type::Str))
+        str::FromStr::from_str(s.trim_matches(::utils::Pattern_White_Space)).or_else(|_| {
+            Err(Error::invalid_type(Type::Str))
        })
    }
 }
@@ -173,18 +206,18 @@ macro_rules! impl_deserialize_num {
    }
 }

-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);
+impl_deserialize_num!(isize, deserialize_isize);
+impl_deserialize_num!(i8, deserialize_i8);
+impl_deserialize_num!(i16, deserialize_i16);
+impl_deserialize_num!(i32, deserialize_i32);
+impl_deserialize_num!(i64, deserialize_i64);
+impl_deserialize_num!(usize, deserialize_usize);
+impl_deserialize_num!(u8, deserialize_u8);
+impl_deserialize_num!(u16, deserialize_u16);
+impl_deserialize_num!(u32, deserialize_u32);
+impl_deserialize_num!(u64, deserialize_u64);
+impl_deserialize_num!(f32, deserialize_f32);
+impl_deserialize_num!(f64, deserialize_f64);

 ///////////////////////////////////////////////////////////////////////////////

@@ -207,7 +240,7 @@ impl Visitor for CharVisitor {
        let mut iter = v.chars();
        if let Some(v) = iter.next() {
            if iter.next().is_some() {
-                Err(Error::type_mismatch(Type::Char))
+                Err(Error::invalid_type(Type::Char))
            } else {
                Ok(v)
            }
@@ -222,14 +255,16 @@ impl Deserialize for char {
    fn deserialize<D>(deserializer: &mut D) -> Result<char, D::Error>
        where D: Deserializer,
    {
-        deserializer.visit_char(CharVisitor)
+        deserializer.deserialize_char(CharVisitor)
    }
 }

 ///////////////////////////////////////////////////////////////////////////////

+#[cfg(any(feature = "std", feature = "collections"))]
 struct StringVisitor;

+#[cfg(any(feature = "std", feature = "collections"))]
 impl Visitor for StringVisitor {
    type Value = String;

@@ -250,7 +285,7 @@ impl Visitor for StringVisitor {
    {
        match str::from_utf8(v) {
            Ok(s) => Ok(s.to_owned()),
-            Err(_) => Err(Error::type_mismatch(Type::String)),
+            Err(_) => Err(Error::invalid_type(Type::String)),
        }
    }

@@ -259,16 +294,17 @@ impl Visitor for StringVisitor {
    {
        match String::from_utf8(v) {
            Ok(s) => Ok(s),
-            Err(_) => Err(Error::type_mismatch(Type::String)),
+            Err(_) => Err(Error::invalid_type(Type::String)),
        }
    }
 }

+#[cfg(any(feature = "std", feature = "collections"))]
 impl Deserialize for String {
    fn deserialize<D>(deserializer: &mut D) -> Result<String, D::Error>
        where D: Deserializer,
    {
-        deserializer.visit_string(StringVisitor)
+        deserializer.deserialize_string(StringVisitor)
    }
 }

@@ -309,7 +345,34 @@ 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 })
+        deserializer.deserialize_option(OptionVisitor { marker: PhantomData })
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// A visitor that produces a `PhantomData`.
+pub struct PhantomDataVisitor<T> {
+    marker: PhantomData<T>,
+}
+
+impl<T> Visitor for PhantomDataVisitor<T> where T: Deserialize {
+    type Value = PhantomData<T>;
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<PhantomData<T>, E>
+        where E: Error,
+    {
+        Ok(PhantomData)
+    }
+}
+
+impl<T> Deserialize for PhantomData<T> where T: Deserialize {
+    fn deserialize<D>(deserializer: &mut D) -> Result<PhantomData<T>, D::Error>
+        where D: Deserializer,
+    {
+        let visitor = PhantomDataVisitor { marker: PhantomData };
+        deserializer.deserialize_unit_struct("PhantomData", visitor)
    }
 }

@@ -318,29 +381,30 @@ impl<T> Deserialize for Option<T> where T: Deserialize {
 macro_rules! seq_impl {
    (
        $ty:ty,
-        < $($constraints:ident),* >,
-        $visitor_name:ident,
+        $visitor_ty:ident < $($typaram:ident : $bound1:ident $(+ $bound2:ident)*),* >,
        $visitor:ident,
        $ctor:expr,
        $with_capacity:expr,
        $insert:expr
    ) => {
        /// A visitor that produces a sequence.
-        pub struct $visitor_name<T> {
-            marker: PhantomData<T>,
+        pub struct $visitor_ty<$($typaram),*> {
+            marker: PhantomData<$ty>,
        }

-        impl<T> $visitor_name<T> {
+        impl<$($typaram),*> $visitor_ty<$($typaram),*>
+            where $($typaram: $bound1 $(+ $bound2)*),*
+        {
            /// Construct a new sequence visitor.
            pub fn new() -> Self {
-                $visitor_name {
+                $visitor_ty {
                    marker: PhantomData,
                }
            }
        }

-        impl<T> Visitor for $visitor_name<T>
-            where T: $($constraints +)*,
+        impl<$($typaram),*> Visitor for $visitor_ty<$($typaram),*>
+            where $($typaram: $bound1 $(+ $bound2)*),*
        {
            type Value = $ty;

@@ -367,77 +431,77 @@ macro_rules! seq_impl {
            }
        }

-        impl<T> Deserialize for $ty
-            where T: $($constraints +)*,
+        impl<$($typaram),*> Deserialize for $ty
+            where $($typaram: $bound1 $(+ $bound2)*),*
        {
            fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
                where D: Deserializer,
            {
-                deserializer.visit_seq($visitor_name::new())
+                deserializer.deserialize_seq($visitor_ty::new())
            }
        }
    }
 }

+#[cfg(any(feature = "std", feature = "collections"))]
 seq_impl!(
    BinaryHeap<T>,
-    <Deserialize, Ord>,
-    BinaryHeapVisitor,
+    BinaryHeapVisitor<T: Deserialize + Ord>,
    visitor,
    BinaryHeap::new(),
    BinaryHeap::with_capacity(visitor.size_hint().0),
    BinaryHeap::push);

+#[cfg(any(feature = "std", feature = "collections"))]
 seq_impl!(
    BTreeSet<T>,
-    <Deserialize, Eq, Ord>,
-    BTreeSetVisitor,
+    BTreeSetVisitor<T: Deserialize + Eq + Ord>,
    visitor,
    BTreeSet::new(),
    BTreeSet::new(),
    BTreeSet::insert);

-#[cfg(feature = "nightly")]
+#[cfg(all(feature = "nightly", feature = "collections"))]
 seq_impl!(
    EnumSet<T>,
-    <Deserialize, CLike>,
-    EnumSetVisitor,
+    EnumSetVisitor<T: Deserialize + CLike>,
    visitor,
    EnumSet::new(),
    EnumSet::new(),
    EnumSet::insert);

+#[cfg(any(feature = "std", feature = "collections"))]
 seq_impl!(
    LinkedList<T>,
-    <Deserialize>,
-    LinkedListVisitor,
+    LinkedListVisitor<T: Deserialize>,
    visitor,
    LinkedList::new(),
    LinkedList::new(),
    LinkedList::push_back);

+#[cfg(feature = "std")]
 seq_impl!(
-    HashSet<T>,
-    <Deserialize, Eq, Hash>,
-    HashSetVisitor,
+    HashSet<T, S>,
+    HashSetVisitor<T: Deserialize + Eq + Hash,
+                   S: BuildHasher + Default>,
    visitor,
-    HashSet::new(),
-    HashSet::with_capacity(visitor.size_hint().0),
+    HashSet::with_hasher(S::default()),
+    HashSet::with_capacity_and_hasher(visitor.size_hint().0, S::default()),
    HashSet::insert);

+#[cfg(any(feature = "std", feature = "collections"))]
 seq_impl!(
    Vec<T>,
-    <Deserialize>,
-    VecVisitor,
+    VecVisitor<T: Deserialize>,
    visitor,
    Vec::new(),
    Vec::with_capacity(visitor.size_hint().0),
    Vec::push);

+#[cfg(any(feature = "std", feature = "collections"))]
 seq_impl!(
    VecDeque<T>,
-    <Deserialize>,
-    VecDequeVisitor,
+    VecDequeVisitor<T: Deserialize>,
    visitor,
    VecDeque::new(),
    VecDeque::with_capacity(visitor.size_hint().0),
@@ -483,7 +547,7 @@ impl<T> Deserialize for [T; 0]
    fn deserialize<D>(deserializer: &mut D) -> Result<[T; 0], D::Error>
        where D: Deserializer,
    {
-        deserializer.visit_seq(ArrayVisitor0::new())
+        deserializer.deserialize_seq(ArrayVisitor0::new())
    }
 }

@@ -529,7 +593,7 @@ macro_rules! array_impls {
                fn deserialize<D>(deserializer: &mut D) -> Result<[T; $len], D::Error>
                    where D: Deserializer,
                {
-                    deserializer.visit_seq($visitor::new())
+                    deserializer.deserialize_fixed_size_array($len, $visitor::new())
                }
            }
        )+
@@ -630,7 +694,7 @@ macro_rules! tuple_impls {
                fn deserialize<D>(deserializer: &mut D) -> Result<($($name,)+), D::Error>
                    where D: Deserializer,
                {
-                    deserializer.visit_tuple($len, $visitor::new())
+                    deserializer.deserialize_tuple($len, $visitor::new())
                }
            }
        )+
@@ -657,30 +721,29 @@ tuple_impls! {
 macro_rules! map_impl {
    (
        $ty:ty,
-        < $($constraints:ident),* >,
-        $visitor_name:ident,
+        $visitor_ty:ident < $($typaram:ident : $bound1:ident $(+ $bound2:ident)*),* >,
        $visitor:ident,
        $ctor:expr,
-        $with_capacity:expr,
-        $insert:expr
+        $with_capacity:expr
    ) => {
        /// A visitor that produces a map.
-        pub struct $visitor_name<K, V> {
+        pub struct $visitor_ty<$($typaram),*> {
            marker: PhantomData<$ty>,
        }

-        impl<K, V> $visitor_name<K, V> {
+        impl<$($typaram),*> $visitor_ty<$($typaram),*>
+            where $($typaram: $bound1 $(+ $bound2)*),*
+        {
            /// Construct a `MapVisitor*<T>`.
            pub fn new() -> Self {
-                $visitor_name {
+                $visitor_ty {
                    marker: PhantomData,
                }
            }
        }

-        impl<K, V> Visitor for $visitor_name<K, V>
-            where K: $($constraints +)*,
-                  V: Deserialize,
+        impl<$($typaram),*> Visitor for $visitor_ty<$($typaram),*>
+            where $($typaram: $bound1 $(+ $bound2)*),*
        {
            type Value = $ty;

@@ -698,7 +761,7 @@ macro_rules! map_impl {
                let mut values = $with_capacity;

                while let Some((key, value)) = try!($visitor.visit()) {
-                    $insert(&mut values, key, value);
+                    values.insert(key, value);
                }

                try!($visitor.end());
@@ -707,41 +770,125 @@ macro_rules! map_impl {
            }
        }

-        impl<K, V> Deserialize for $ty
-            where K: $($constraints +)*,
-                  V: Deserialize,
+        impl<$($typaram),*> Deserialize for $ty
+            where $($typaram: $bound1 $(+ $bound2)*),*
        {
            fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
                where D: Deserializer,
            {
-                deserializer.visit_map($visitor_name::new())
+                deserializer.deserialize_map($visitor_ty::new())
            }
        }
    }
 }

+#[cfg(any(feature = "std", feature = "collections"))]
 map_impl!(
    BTreeMap<K, V>,
-    <Deserialize, Eq, Ord>,
-    BTreeMapVisitor,
+    BTreeMapVisitor<K: Deserialize + Eq + Ord,
+                    V: Deserialize>,
    visitor,
    BTreeMap::new(),
-    BTreeMap::new(),
-    BTreeMap::insert);
+    BTreeMap::new());

+#[cfg(feature = "std")]
 map_impl!(
-    HashMap<K, V>,
-    <Deserialize, Eq, Hash>,
-    HashMapVisitor,
+    HashMap<K, V, S>,
+    HashMapVisitor<K: Deserialize + Eq + Hash,
+                   V: Deserialize,
+                   S: BuildHasher + Default>,
    visitor,
-    HashMap::new(),
-    HashMap::with_capacity(visitor.size_hint().0),
-    HashMap::insert);
+    HashMap::with_hasher(S::default()),
+    HashMap::with_capacity_and_hasher(visitor.size_hint().0, S::default()));

 ///////////////////////////////////////////////////////////////////////////////

+#[cfg(all(feature = "nightly", feature = "std"))]
+impl Deserialize for net::IpAddr {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer,
+    {
+        let s = try!(String::deserialize(deserializer));
+        match s.parse() {
+            Ok(s) => Ok(s),
+            Err(err) => Err(D::Error::invalid_value(&err.to_string())),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl Deserialize for net::Ipv4Addr {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer,
+    {
+        let s = try!(String::deserialize(deserializer));
+        match s.parse() {
+            Ok(s) => Ok(s),
+            Err(err) => Err(D::Error::invalid_value(&err.to_string())),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl Deserialize for net::Ipv6Addr {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer,
+    {
+        let s = try!(String::deserialize(deserializer));
+        match s.parse() {
+            Ok(s) => Ok(s),
+            Err(err) => Err(D::Error::invalid_value(&err.to_string())),
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[cfg(feature = "std")]
+impl Deserialize for net::SocketAddr {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer,
+    {
+        let s = try!(String::deserialize(deserializer));
+        match s.parse() {
+            Ok(s) => Ok(s),
+            Err(err) => Err(D::Error::invalid_value(&err.to_string())),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl Deserialize for net::SocketAddrV4 {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer,
+    {
+        let s = try!(String::deserialize(deserializer));
+        match s.parse() {
+            Ok(s) => Ok(s),
+            Err(err) => Err(D::Error::invalid_value(&err.to_string())),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl Deserialize for net::SocketAddrV6 {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer,
+    {
+        let s = try!(String::deserialize(deserializer));
+        match s.parse() {
+            Ok(s) => Ok(s),
+            Err(err) => Err(D::Error::invalid_value(&err.to_string())),
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[cfg(feature = "std")]
 struct PathBufVisitor;

+#[cfg(feature = "std")]
 impl Visitor for PathBufVisitor {
    type Value = path::PathBuf;

@@ -758,16 +905,18 @@ impl Visitor for PathBufVisitor {
    }
 }

+#[cfg(feature = "std")]
 impl Deserialize for path::PathBuf {
    fn deserialize<D>(deserializer: &mut D) -> Result<path::PathBuf, D::Error>
        where D: Deserializer,
    {
-        deserializer.visit(PathBufVisitor)
+        deserializer.deserialize_string(PathBufVisitor)
    }
 }

 ///////////////////////////////////////////////////////////////////////////////

+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<T: Deserialize> Deserialize for Box<T> {
    fn deserialize<D>(deserializer: &mut D) -> Result<Box<T>, D::Error>
        where D: Deserializer,
@@ -777,6 +926,17 @@ impl<T: Deserialize> Deserialize for Box<T> {
    }
 }

+#[cfg(any(feature = "std", feature = "collections"))]
+impl<T: Deserialize> Deserialize for Box<[T]> {
+    fn deserialize<D>(deserializer: &mut D) -> Result<Box<[T]>, D::Error>
+        where D: Deserializer,
+    {
+        let v: Vec<T> = try!(Deserialize::deserialize(deserializer));
+        Ok(v.into_boxed_slice())
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<T: Deserialize> Deserialize for Arc<T> {
    fn deserialize<D>(deserializer: &mut D) -> Result<Arc<T>, D::Error>
        where D: Deserializer,
@@ -786,6 +946,7 @@ impl<T: Deserialize> Deserialize for Arc<T> {
    }
 }

+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<T: Deserialize> Deserialize for Rc<T> {
    fn deserialize<D>(deserializer: &mut D) -> Result<Rc<T>, D::Error>
        where D: Deserializer,
@@ -795,6 +956,7 @@ impl<T: Deserialize> Deserialize for Rc<T> {
    }
 }

+#[cfg(any(feature = "std", feature = "collections"))]
 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>
@@ -812,7 +974,7 @@ impl<T> Deserialize for NonZero<T> where T: Deserialize + PartialEq + Zeroable +
    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"))
+            return Err(Error::invalid_value("expected a non-zero value"))
        }
        unsafe {
            Ok(NonZero::new(value))
@@ -841,7 +1003,10 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
                impl ::de::Visitor for FieldVisitor {
                    type Value = Field;

+                    #[cfg(any(feature = "std", feature = "collections"))]
                    fn visit_usize<E>(&mut self, value: usize) -> Result<Field, E> where E: Error {
+                        #[cfg(feature = "collections")]
+                        use collections::string::ToString;
                        match value {
                            0 => Ok(Field::Ok),
                            1 => Ok(Field::Err),
@@ -849,6 +1014,15 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
                        }
                    }

+                    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
+                    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("some number")),
+                        }
+                    }
+
                    fn visit_str<E>(&mut self, value: &str) -> Result<Field, E> where E: Error {
                        match value {
                            "Ok" => Ok(Field::Ok),
@@ -864,14 +1038,14 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
                            _ => {
                                match str::from_utf8(value) {
                                    Ok(value) => Err(Error::unknown_field(value)),
-                                    Err(_) => Err(Error::type_mismatch(Type::String)),
+                                    Err(_) => Err(Error::invalid_type(Type::String)),
                                }
                            }
                        }
                    }
                }

-                deserializer.visit(FieldVisitor)
+                deserializer.deserialize(FieldVisitor)
            }
        }

@@ -901,90 +1075,110 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {

        const VARIANTS: &'static [&'static str] = &["Ok", "Err"];

-        deserializer.visit_enum("Result", VARIANTS, Visitor(PhantomData))
+        deserializer.deserialize_enum("Result", VARIANTS, Visitor(PhantomData))
    }
 }

 ///////////////////////////////////////////////////////////////////////////////

-#[cfg(feature = "num-bigint")]
-impl Deserialize for ::num::bigint::BigInt {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+/// A target for deserializers that want to ignore data. Implements
+/// Deserialize and silently eats data given to it.
+pub struct IgnoredAny;
+
+impl Deserialize for IgnoredAny {
+    #[inline]
+    fn deserialize<D>(deserializer: &mut D) -> Result<IgnoredAny, D::Error>
        where D: Deserializer,
    {
-        use ::num::Num;
-        use ::num::bigint::BigInt;
+        struct IgnoredAnyVisitor;

-        struct BigIntVisitor;
+        impl Visitor for IgnoredAnyVisitor {
+            type Value = IgnoredAny;

-        impl Visitor for BigIntVisitor {
-            type Value = BigInt;
+            #[inline]
+            fn visit_bool<E>(&mut self, _: bool) -> Result<IgnoredAny, E> {
+                Ok(IgnoredAny)
+            }

-            fn visit_str<E>(&mut self, s: &str) -> Result<Self::Value, E>
+            #[inline]
+            fn visit_i64<E>(&mut self, _: i64) -> Result<IgnoredAny, E> {
+                Ok(IgnoredAny)
+            }
+
+            #[inline]
+            fn visit_u64<E>(&mut self, _: u64) -> Result<IgnoredAny, E> {
+                Ok(IgnoredAny)
+            }
+
+            #[inline]
+            fn visit_f64<E>(&mut self, _: f64) -> Result<IgnoredAny, E> {
+                Ok(IgnoredAny)
+            }
+
+            #[inline]
+            fn visit_str<E>(&mut self, _: &str) -> Result<IgnoredAny, E>
                where E: Error,
            {
-                match BigInt::from_str_radix(s, 10) {
-                    Ok(v) => Ok(v),
-                    Err(err) => Err(Error::invalid_value(&err.to_string())),
+                Ok(IgnoredAny)
+            }
+
+            #[inline]
+            fn visit_none<E>(&mut self) -> Result<IgnoredAny, E> {
+                Ok(IgnoredAny)
+            }
+
+            #[inline]
+            fn visit_some<D>(&mut self, _: &mut D) -> Result<IgnoredAny, D::Error>
+                where D: Deserializer,
+            {
+                Ok(IgnoredAny)
+            }
+
+            #[inline]
+            fn visit_newtype_struct<D>(&mut self, _: &mut D) -> Result<IgnoredAny, D::Error>
+                where D: Deserializer,
+            {
+                Ok(IgnoredAny)
+            }
+
+            #[inline]
+            fn visit_unit<E>(&mut self) -> Result<IgnoredAny, E> {
+                Ok(IgnoredAny)
+            }
+
+            #[inline]
+            fn visit_seq<V>(&mut self, mut visitor: V) -> Result<IgnoredAny, V::Error>
+                where V: SeqVisitor,
+            {
+                while let Some(_) = try!(visitor.visit::<IgnoredAny>()) {
+                    // Gobble
                }
+
+                try!(visitor.end());
+                Ok(IgnoredAny)
+            }
+
+            #[inline]
+            fn visit_map<V>(&mut self, mut visitor: V) -> Result<IgnoredAny, V::Error>
+                where V: MapVisitor,
+            {
+                while let Some((_, _)) = try!(visitor.visit::<IgnoredAny, IgnoredAny>()) {
+                    // Gobble
+                }
+
+                try!(visitor.end());
+                Ok(IgnoredAny)
+            }
+
+            #[inline]
+            fn visit_bytes<E>(&mut self, _: &[u8]) -> Result<IgnoredAny, E>
+                where E: Error,
+            {
+                Ok(IgnoredAny)
            }
        }

-        deserializer.visit(BigIntVisitor)
-    }
-}
-
-#[cfg(feature = "num-bigint")]
-impl Deserialize for ::num::bigint::BigUint {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
-        where D: Deserializer,
-    {
-        use ::num::Num;
-        use ::num::bigint::BigUint;
-
-        struct BigUintVisitor;
-
-        impl Visitor for BigUintVisitor {
-            type Value = ::num::bigint::BigUint;
-
-            fn visit_str<E>(&mut self, s: &str) -> Result<Self::Value, E>
-                where E: Error,
-            {
-                match BigUint::from_str_radix(s, 10) {
-                    Ok(v) => Ok(v),
-                    Err(err) => Err(Error::invalid_value(&err.to_string())),
-                }
-            }
-        }
-
-        deserializer.visit(BigUintVisitor)
-    }
-}
-
-#[cfg(feature = "num-complex")]
-impl<T> Deserialize for ::num::complex::Complex<T>
-    where T: Deserialize + Clone + ::num::Num
-{
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
-        where D: Deserializer,
-    {
-        let (re, im) = try!(Deserialize::deserialize(deserializer));
-        Ok(::num::complex::Complex::new(re, im))
-    }
-}
-
-#[cfg(feature = "num-rational")]
-impl<T> Deserialize for ::num::rational::Ratio<T>
-    where T: Deserialize + Clone + ::num::Integer + PartialOrd
-{
-    fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
-        where D: Deserializer,
-    {
-        let (numer, denom) = try!(Deserialize::deserialize(deserializer));
-        if denom == ::num::Zero::zero() {
-            Err(Error::invalid_value("denominator is zero"))
-        } else {
-            Ok(::num::rational::Ratio::new_raw(numer, denom))
-        }
+        // TODO maybe not necessary with impl specialization
+        deserializer.deserialize_ignored_any(IgnoredAnyVisitor)
    }
 }
@@ -1,43 +1,76 @@
 //! Generic deserialization framework.

+#[cfg(feature = "std")]
+use std::error;
+#[cfg(not(feature = "std"))]
+use error;
+
+#[cfg(all(not(feature = "std"), feature = "collections"))]
+use collections::{String, Vec};
+
 pub mod impls;
 pub mod value;
+mod from_primitive;

 ///////////////////////////////////////////////////////////////////////////////

 /// `Error` is a trait that allows a `Deserialize` to generically create a
 /// `Deserializer` error.
-pub trait Error: Sized {
+pub trait Error: Sized + error::Error {
    /// Raised when there is general error when deserializing a type.
-    fn syntax(msg: &str) -> Self;
+    #[cfg(any(feature = "std", feature = "collections"))]
+    fn custom<T: Into<String>>(msg: T) -> Self;

-    /// Raised when a fixed sized sequence or map was passed in the wrong amount of arguments.
-    fn length_mismatch(_len: usize) -> Self {
-        Error::syntax("incorrect length")
-    }
-
-    /// Raised when a `Deserialize` was passed an incorrect type.
-    fn type_mismatch(_type: Type) -> Self {
-        Error::syntax("incorrect type")
-    }
-
-    /// Raised when a `Deserialize` was passed an incorrect value.
-    fn invalid_value(msg: &str) -> Self {
-        Error::syntax(msg)
-    }
+    /// Raised when there is general error when deserializing a type.
+    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
+    fn custom<T: Into<&'static str>>(msg: T) -> Self;

    /// Raised when a `Deserialize` type unexpectedly hit the end of the stream.
    fn end_of_stream() -> Self;

-    /// Raised when a `Deserialize` struct type received an unexpected struct field.
-    fn unknown_field(field: &str) -> Self;
+    /// Raised when a `Deserialize` was passed an incorrect type.
+    fn invalid_type(ty: Type) -> Self {
+        Error::custom(format!("Invalid type. Expected `{:?}`", ty))
+    }

-    /// Raised when a `Deserialize` struct type did not receive a field.
-    fn missing_field(field: &'static str) -> Self;
+    /// Raised when a `Deserialize` was passed an incorrect value.
+    fn invalid_value(msg: &str) -> Self {
+        Error::custom(format!("Invalid value: {}", msg))
+    }
+
+    /// Raised when a fixed sized sequence or map was passed in the wrong amount of arguments.
+    ///
+    /// The parameter `len` is the number of arguments found in the serialization. The sequence
+    /// may either expect more arguments or less arguments.
+    fn invalid_length(len: usize) -> Self {
+        Error::custom(format!("Invalid length: {}", len))
+    }
+
+    /// Raised when a `Deserialize` enum type received an unexpected variant.
+    fn unknown_variant(field: &str) -> Self {
+        Error::custom(format!("Unknown variant `{}`", field))
+    }
+
+    /// Raised when a `Deserialize` struct type received an unexpected struct field.
+    fn unknown_field(field: &str) -> Self {
+        Error::custom(format!("Unknown field `{}`", field))
+    }
+
+    /// raised when a `deserialize` struct type did not receive a field.
+    fn missing_field(field: &'static str) -> Self {
+        Error::custom(format!("Missing field `{}`", field))
+    }
+
+    /// Raised when a `Deserialize` struct type received more than one of the
+    /// same struct field.
+    fn duplicate_field(field: &'static str) -> Self {
+        Error::custom(format!("Duplicate field `{}`", field))
+    }
 }

 /// `Type` represents all the primitive types that can be deserialized. This is used by
-/// `Error::kind_mismatch`.
+/// `Error::invalid_type`.
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
 pub enum Type {
    /// Represents a `bool` type.
    Bool,
@@ -111,12 +144,18 @@ pub enum Type {
    /// Represents a struct type.
    Struct,

+    /// Represents a struct field name.
+    FieldName,
+
    /// Represents a tuple type.
    Tuple,

    /// Represents an `enum` type.
    Enum,

+    /// Represents an enum variant name.
+    VariantName,
+
    /// Represents a struct variant.
    StructVariant,

@@ -144,272 +183,295 @@ pub trait Deserialize: Sized {
 /// `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
+/// 1) The `deserialize` method. File formats like JSON embed the type of its construct in its 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.
+/// 2) The `deserialize_*` methods. File formats like bincode do not embed in its format how to
+///    decode its values. It relies instead on the `Deserialize` type to hint to the `Deserializer`
+///    with the `deserialize_*` methods how it should parse the next value. One downside though to
+///    only supporting the `deserialize_*` types is that it does not allow for deserializing into a
+///    generic `json::Value`-esque type.
 pub trait Deserializer {
    /// The error type that can be returned if some error occurs during deserialization.
    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>
+    fn deserialize<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>
+    fn deserialize_bool<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit(visitor)
+        self.deserialize(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>
+    fn deserialize_usize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit_u64(visitor)
+        self.deserialize_u64(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>
+    fn deserialize_u8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit_u64(visitor)
+        self.deserialize_u64(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>
+    fn deserialize_u16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit_u64(visitor)
+        self.deserialize_u64(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>
+    fn deserialize_u32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit_u64(visitor)
+        self.deserialize_u64(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>
+    fn deserialize_u64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit(visitor)
+        self.deserialize(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>
+    fn deserialize_isize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit_i64(visitor)
+        self.deserialize_i64(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>
+    fn deserialize_i8<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit_i64(visitor)
+        self.deserialize_i64(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>
+    fn deserialize_i16<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit_i64(visitor)
+        self.deserialize_i64(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>
+    fn deserialize_i32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit_i64(visitor)
+        self.deserialize_i64(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>
+    fn deserialize_i64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit(visitor)
+        self.deserialize(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>
+    fn deserialize_f32<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit_f64(visitor)
+        self.deserialize_f64(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>
+    fn deserialize_f64<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit(visitor)
+        self.deserialize(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>
+    fn deserialize_char<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit(visitor)
+        self.deserialize(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>
+    fn deserialize_str<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit(visitor)
+        self.deserialize(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>
+    fn deserialize_string<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit_str(visitor)
+        self.deserialize_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>
+    fn deserialize_unit<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit(visitor)
+        self.deserialize(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>
+    fn deserialize_option<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit(visitor)
+        self.deserialize(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>
+    fn deserialize_seq<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit(visitor)
+        self.deserialize(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.
+    /// This method hints that the `Deserialize` type is expecting a fixed size array. This allows
+    /// deserializers to parse arrays that aren't tagged as arrays.
+    ///
+    /// By default, this deserializes arrays from a sequence.
    #[inline]
-    fn visit_map<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_fixed_size_array<V>(&mut self,
+                                       _len: usize,
+                                       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"))
+        self.deserialize(visitor)
    }

    /// 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>
+    fn deserialize_bytes<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor,
    {
-        self.visit_seq(visitor)
+        self.deserialize_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 {
-        ""
+    /// 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 deserialize_map<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.deserialize(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 deserialize_unit_struct<V>(&mut self,
+                                  _name: &'static str,
+                                  visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.deserialize_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 deserialize_newtype_struct<V>(&mut self,
+                                     name: &'static str,
+                                     visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.deserialize_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 deserialize_tuple_struct<V>(&mut self,
+                                   _name: &'static str,
+                                   len: usize,
+                                   visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.deserialize_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 deserialize_struct<V>(&mut self,
+                             _name: &'static str,
+                             _fields: &'static [&'static str],
+                             visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.deserialize_map(visitor)
+    }
+
+    /// This method hints that the `Deserialize` type is expecting some sort of struct field
+    /// name.  This allows deserializers to choose between &str, usize, or &[u8] to properly
+    /// deserialize a struct field.
+    #[inline]
+    fn deserialize_struct_field<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.deserialize(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 deserialize_tuple<V>(&mut self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        self.deserialize_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 deserialize_enum<V>(&mut self,
+                           _enum: &'static str,
+                           _variants: &'static [&'static str],
+                           _visitor: V) -> Result<V::Value, Self::Error>
+        where V: EnumVisitor,
+    {
+        Err(Error::invalid_type(Type::Enum))
+    }
+
+    /// This method hints that the `Deserialize` type needs to deserialize a value whose type
+    /// doesn't matter because it is ignored.
+    #[inline]
+    fn deserialize_ignored_any<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor
+    {
+        self.deserialize(visitor)
    }
 }

@@ -424,7 +486,7 @@ pub trait Visitor {
    fn visit_bool<E>(&mut self, _v: bool) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::type_mismatch(Type::Bool))
+        Err(Error::invalid_type(Type::Bool))
    }

    /// `visit_isize` deserializes a `isize` into a `Value`.
@@ -459,7 +521,7 @@ pub trait Visitor {
    fn visit_i64<E>(&mut self, _v: i64) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::type_mismatch(Type::I64))
+        Err(Error::invalid_type(Type::I64))
    }

    /// `visit_usize` deserializes a `usize` into a `Value`.
@@ -494,7 +556,7 @@ pub trait Visitor {
    fn visit_u64<E>(&mut self, _v: u64) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::type_mismatch(Type::U64))
+        Err(Error::invalid_type(Type::U64))
    }

    /// `visit_f32` deserializes a `f32` into a `Value`.
@@ -508,7 +570,7 @@ pub trait Visitor {
    fn visit_f64<E>(&mut self, _v: f64) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::type_mismatch(Type::F64))
+        Err(Error::invalid_type(Type::F64))
    }

    /// `visit_char` deserializes a `char` into a `Value`.
@@ -516,20 +578,21 @@ pub trait Visitor {
    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())
+        self.visit_str(::utils::encode_utf8(v).as_str())
    }

    /// `visit_str` deserializes a `&str` into a `Value`.
    fn visit_str<E>(&mut self, _v: &str) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::type_mismatch(Type::Str))
+        Err(Error::invalid_type(Type::Str))
    }

-    /// `visit_string` deserializes a `String` into a `Value`.
+    /// `visit_string` deserializes a `String` into a `Value`.  This allows a deserializer to avoid
+    /// a copy if it is deserializing a string from a `String` type.  By default it passes a `&str`
+    /// to the `visit_str` method.
    #[inline]
+    #[cfg(any(feature = "std", feature = "collections"))]
    fn visit_string<E>(&mut self, v: String) -> Result<Self::Value, E>
        where E: Error,
    {
@@ -540,7 +603,7 @@ pub trait Visitor {
    fn visit_unit<E>(&mut self) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::type_mismatch(Type::Unit))
+        Err(Error::invalid_type(Type::Unit))
    }

    /// `visit_unit_struct` deserializes a unit struct into a `Value`.
@@ -555,45 +618,46 @@ pub trait Visitor {
    fn visit_none<E>(&mut self) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::type_mismatch(Type::Option))
+        Err(Error::invalid_type(Type::Option))
    }

    /// `visit_some` deserializes a value into a `Value`.
    fn visit_some<D>(&mut self, _deserializer: &mut D) -> Result<Self::Value, D::Error>
        where D: Deserializer,
    {
-        Err(Error::type_mismatch(Type::Option))
+        Err(Error::invalid_type(Type::Option))
    }

    /// `visit_newtype_struct` deserializes a value into a `Value`.
    fn visit_newtype_struct<D>(&mut self, _deserializer: &mut D) -> Result<Self::Value, D::Error>
        where D: Deserializer,
    {
-        Err(Error::type_mismatch(Type::NewtypeStruct))
+        Err(Error::invalid_type(Type::NewtypeStruct))
    }

    /// `visit_bool` deserializes a `SeqVisitor` into a `Value`.
    fn visit_seq<V>(&mut self, _visitor: V) -> Result<Self::Value, V::Error>
        where V: SeqVisitor,
    {
-        Err(Error::type_mismatch(Type::Seq))
+        Err(Error::invalid_type(Type::Seq))
    }

    /// `visit_map` deserializes a `MapVisitor` into a `Value`.
    fn visit_map<V>(&mut self, _visitor: V) -> Result<Self::Value, V::Error>
        where V: MapVisitor,
    {
-        Err(Error::type_mismatch(Type::Map))
+        Err(Error::invalid_type(Type::Map))
    }

    /// `visit_bytes` deserializes a `&[u8]` into a `Value`.
    fn visit_bytes<E>(&mut self, _v: &[u8]) -> Result<Self::Value, E>
        where E: Error,
    {
-        Err(Error::type_mismatch(Type::Bytes))
+        Err(Error::invalid_type(Type::Bytes))
    }

    /// `visit_byte_buf` deserializes a `Vec<u8>` into a `Value`.
+    #[cfg(any(feature = "std", feature = "collections"))]
    fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<Self::Value, E>
        where E: Error,
    {
@@ -690,7 +754,7 @@ pub trait MapVisitor {
        (0, None)
    }

-    /// Report that there 
+    /// Report that the struct has a field that wasn't deserialized
    fn missing_field<V>(&mut self, field: &'static str) -> Result<V, Self::Error>
        where V: Deserialize,
    {
@@ -761,7 +825,7 @@ pub trait VariantVisitor {

    /// `visit_unit` is called when deserializing a variant with no values.
    fn visit_unit(&mut self) -> Result<(), Self::Error> {
-        Err(Error::type_mismatch(Type::UnitVariant))
+        Err(Error::invalid_type(Type::UnitVariant))
    }

    /// `visit_newtype` is called when deserializing a variant with a single value. By default this
@@ -780,7 +844,7 @@ pub trait VariantVisitor {
                      _visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor
    {
-        Err(Error::type_mismatch(Type::TupleVariant))
+        Err(Error::invalid_type(Type::TupleVariant))
    }

    /// `visit_struct` is called when deserializing a struct-like variant.
@@ -789,7 +853,7 @@ pub trait VariantVisitor {
                       _visitor: V) -> Result<V::Value, Self::Error>
        where V: Visitor
    {
-        Err(Error::type_mismatch(Type::StructVariant))
+        Err(Error::invalid_type(Type::StructVariant))
    }
 }

@@ -821,8 +885,8 @@ impl<'a, T> VariantVisitor for &'a mut T where T: VariantVisitor {
    }

    fn visit_struct<V>(&mut self,
-                    fields: &'static [&'static str],
-                    visitor: V) -> Result<V::Value, T::Error>
+                       fields: &'static [&'static str],
+                       visitor: V) -> Result<V::Value, T::Error>
        where V: Visitor,
    {
        (**self).visit_struct(fields, visitor)
@@ -1,5 +1,6 @@
 //! This module supports deserializing from primitives with the `ValueDeserializer` trait.

+#[cfg(feature = "std")]
 use std::collections::{
    BTreeMap,
    BTreeSet,
@@ -10,9 +11,32 @@ use std::collections::{
    hash_map,
    hash_set,
 };
-use std::hash::Hash;
+#[cfg(feature = "std")]
 use std::vec;

+#[cfg(all(feature = "collections", not(feature = "std")))]
+use collections::{
+    BTreeMap,
+    BTreeSet,
+    Vec,
+    String,
+    btree_map,
+    btree_set,
+    vec,
+};
+
+#[cfg(all(feature = "nightly", feature = "collections"))]
+use collections::borrow::ToOwned;
+
+use core::hash::Hash;
+#[cfg(feature = "std")]
+use std::error;
+#[cfg(not(feature = "std"))]
+use error;
+
+use core::fmt;
+use core::marker::PhantomData;
+
 use de;
 use bytes;

@@ -21,32 +45,110 @@ use bytes;
 /// This represents all the possible errors that can occur using the `ValueDeserializer`.
 #[derive(Clone, Debug, PartialEq)]
 pub enum Error {
-    /// The value had some syntatic error.
-    SyntaxError,
+    /// The value had some custom error.
+    #[cfg(any(feature = "std", feature = "collections"))]
+    Custom(String),
+    /// The value had some custom error.
+    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
+    Custom(&'static str),
+
+    /// The value had an incorrect type.
+    InvalidType(de::Type),
+
+    /// The value had an invalid length.
+    InvalidLength(usize),
+
+    /// The value is invalid and cannot be deserialized.
+    #[cfg(any(feature = "std", feature = "collections"))]
+    InvalidValue(String),
+    /// The value is invalid and cannot be deserialized.
+    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
+    InvalidValue(&'static str),

    /// EOF while deserializing a value.
-    EndOfStreamError,
+    EndOfStream,
+
+    /// Unknown variant in enum.
+    #[cfg(any(feature = "std", feature = "collections"))]
+    UnknownVariant(String),
+    /// Unknown variant in enum.
+    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
+    UnknownVariant(&'static str),

    /// Unknown field in struct.
-    UnknownFieldError(String),
+    #[cfg(any(feature = "std", feature = "collections"))]
+    UnknownField(String),
+    /// Unknown field in struct.
+    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
+    UnknownField(&'static str),

    /// Struct is missing a field.
-    MissingFieldError(&'static str),
+    MissingField(&'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) }
+    #[cfg(any(feature = "std", feature = "collections"))]
+    fn custom<T: Into<String>>(msg: T) -> Self { Error::Custom(msg.into()) }
+
+    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
+    fn custom<T: Into<&'static str>>(msg: T) -> Self { Error::Custom(msg.into()) }
+
+    fn end_of_stream() -> Self { Error::EndOfStream }
+    fn invalid_type(ty: de::Type) -> Self { Error::InvalidType(ty) }
+
+    #[cfg(any(feature = "std", feature = "collections"))]
+    fn invalid_value(msg: &str) -> Self { Error::InvalidValue(msg.to_owned()) }
+
+    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
+    fn invalid_value(msg: &str) -> Self { Error::InvalidValue("invalid value") }
+
+    fn invalid_length(len: usize) -> Self { Error::InvalidLength(len) }
+
+    #[cfg(any(feature = "std", feature = "collections"))]
+    fn unknown_variant(variant: &str) -> Self { Error::UnknownVariant(String::from(variant)) }
+    #[cfg(any(feature = "std", feature = "collections"))]
+    fn unknown_field(field: &str) -> Self { Error::UnknownField(String::from(field)) }
+
+    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
+    fn unknown_variant(variant: &str) -> Self { Error::UnknownVariant("unknown variant") }
+    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
+    fn unknown_field(field: &str) -> Self { Error::UnknownField("unknown field") }
+    fn missing_field(field: &'static str) -> Self { Error::MissingField(field) }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        match *self {
+            Error::Custom(ref s) => write!(formatter, "{}", s),
+            Error::EndOfStream => formatter.write_str("End of stream"),
+            Error::InvalidType(ty) => write!(formatter, "Invalid type, expected `{:?}`", ty),
+            Error::InvalidValue(ref value) => write!(formatter, "Invalid value: {}", value),
+            Error::InvalidLength(len) => write!(formatter, "Invalid length: {}", len),
+            Error::UnknownVariant(ref variant) => {
+                write!(formatter, "Unknown variant: {}", variant)
+            }
+            Error::UnknownField(ref field) => write!(formatter, "Unknown field: {}", field),
+            Error::MissingField(ref field) => write!(formatter, "Missing field: {}", field),
+        }
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
 }

 ///////////////////////////////////////////////////////////////////////////////

 /// This trait converts primitive types into a deserializer.
-pub trait ValueDeserializer {
+pub trait ValueDeserializer<E: de::Error = Error> {
    /// The actual deserializer type.
-    type Deserializer: de::Deserializer<Error=Error>;
+    type Deserializer: de::Deserializer<Error=E>;

    /// Convert this value into a deserializer.
    fn into_deserializer(self) -> Self::Deserializer;
@@ -54,27 +156,31 @@ pub trait ValueDeserializer {

 ///////////////////////////////////////////////////////////////////////////////

-impl ValueDeserializer for () {
-    type Deserializer = UnitDeserializer;
+impl<E> ValueDeserializer<E> for ()
+    where E: de::Error,
+{
+    type Deserializer = UnitDeserializer<E>;

-    fn into_deserializer(self) -> UnitDeserializer {
-        UnitDeserializer
+    fn into_deserializer(self) -> UnitDeserializer<E> {
+        UnitDeserializer(PhantomData)
    }
 }

 /// A helper deserializer that deserializes a `()`.
-pub struct UnitDeserializer;
+pub struct UnitDeserializer<E>(PhantomData<E>);

-impl de::Deserializer for UnitDeserializer {
-    type Error = Error;
+impl<E> de::Deserializer for UnitDeserializer<E>
+    where E: de::Error
+{
+    type Error = E;

-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
        where V: de::Visitor,
    {
        visitor.visit_unit()
    }

-    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn deserialize_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
        where V: de::Visitor,
    {
        visitor.visit_none()
@@ -86,20 +192,24 @@ impl de::Deserializer for UnitDeserializer {
 macro_rules! primitive_deserializer {
    ($ty:ty, $name:ident, $method:ident) => {
        /// A helper deserializer that deserializes a number.
-        pub struct $name(Option<$ty>);
+        pub struct $name<E>(Option<$ty>, PhantomData<E>);

-        impl ValueDeserializer for $ty {
-            type Deserializer = $name;
+        impl<E> ValueDeserializer<E> for $ty
+            where E: de::Error,
+        {
+            type Deserializer = $name<E>;

-            fn into_deserializer(self) -> $name {
-                $name(Some(self))
+            fn into_deserializer(self) -> $name<E> {
+                $name(Some(self), PhantomData)
            }
        }

-        impl de::Deserializer for $name {
-            type Error = Error;
+        impl<E> de::Deserializer for $name<E>
+            where E: de::Error,
+        {
+            type Error = E;

-            fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+            fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
                where V: de::Visitor,
            {
                match self.0.take() {
@@ -129,20 +239,24 @@ primitive_deserializer!(char, CharDeserializer, visit_char);
 ///////////////////////////////////////////////////////////////////////////////

 /// A helper deserializer that deserializes a `&str`.
-pub struct StrDeserializer<'a>(Option<&'a str>);
+pub struct StrDeserializer<'a, E>(Option<&'a str>, PhantomData<E>);

-impl<'a> ValueDeserializer for &'a str {
-    type Deserializer = StrDeserializer<'a>;
+impl<'a, E> ValueDeserializer<E> for &'a str
+    where E: de::Error,
+{
+    type Deserializer = StrDeserializer<'a, E>;

-    fn into_deserializer(self) -> StrDeserializer<'a> {
-        StrDeserializer(Some(self))
+    fn into_deserializer(self) -> StrDeserializer<'a, E> {
+        StrDeserializer(Some(self), PhantomData)
    }
 }

-impl<'a> de::Deserializer for StrDeserializer<'a> {
-    type Error = Error;
+impl<'a, E> de::Deserializer for StrDeserializer<'a, E>
+    where E: de::Error,
+{
+    type Error = E;

-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
        where V: de::Visitor,
    {
        match self.0.take() {
@@ -151,26 +265,28 @@ impl<'a> de::Deserializer for StrDeserializer<'a> {
        }
    }

-    fn visit_enum<V>(&mut self,
+    fn deserialize_enum<V>(&mut self,
                     _name: &str,
                     _variants: &'static [&'static str],
-                     mut visitor: V) -> Result<V::Value, Error>
+                     mut visitor: V) -> Result<V::Value, Self::Error>
        where V: de::EnumVisitor,
    {
        visitor.visit(self)
    }
 }

-impl<'a> de::VariantVisitor for StrDeserializer<'a> {
-    type Error = Error;
+impl<'a, E> de::VariantVisitor for StrDeserializer<'a, E>
+    where E: de::Error,
+{
+    type Error = E;

-    fn visit_variant<T>(&mut self) -> Result<T, Error>
+    fn visit_variant<T>(&mut self) -> Result<T, Self::Error>
        where T: de::Deserialize,
    {
        de::Deserialize::deserialize(self)
    }

-    fn visit_unit(&mut self) -> Result<(), Error> {
+    fn visit_unit(&mut self) -> Result<(), Self::Error> {
        Ok(())
    }
 }
@@ -178,20 +294,27 @@ impl<'a> de::VariantVisitor for StrDeserializer<'a> {
 ///////////////////////////////////////////////////////////////////////////////

 /// A helper deserializer that deserializes a `String`.
-pub struct StringDeserializer(Option<String>);
+#[cfg(any(feature = "std", feature = "collections"))]
+pub struct StringDeserializer<E>(Option<String>, PhantomData<E>);

-impl ValueDeserializer for String {
-    type Deserializer = StringDeserializer;
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<E> ValueDeserializer<E> for String
+    where E: de::Error,
+{
+    type Deserializer = StringDeserializer<E>;

-    fn into_deserializer(self) -> StringDeserializer {
-        StringDeserializer(Some(self))
+    fn into_deserializer(self) -> StringDeserializer<E> {
+        StringDeserializer(Some(self), PhantomData)
    }
 }

-impl de::Deserializer for StringDeserializer {
-    type Error = Error;
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<E> de::Deserializer for StringDeserializer<E>
+    where E: de::Error,
+{
+    type Error = E;

-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
        where V: de::Visitor,
    {
        match self.0.take() {
@@ -200,26 +323,29 @@ impl de::Deserializer for StringDeserializer {
        }
    }

-    fn visit_enum<V>(&mut self,
+    fn deserialize_enum<V>(&mut self,
                     _name: &str,
                     _variants: &'static [&'static str],
-                     mut visitor: V) -> Result<V::Value, Error>
+                     mut visitor: V) -> Result<V::Value, Self::Error>
        where V: de::EnumVisitor,
    {
        visitor.visit(self)
    }
 }

-impl<'a> de::VariantVisitor for StringDeserializer {
-    type Error = Error;
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<'a, E> de::VariantVisitor for StringDeserializer<E>
+    where E: de::Error,
+{
+    type Error = E;

-    fn visit_variant<T>(&mut self) -> Result<T, Error>
+    fn visit_variant<T>(&mut self) -> Result<T, Self::Error>
        where T: de::Deserialize,
    {
        de::Deserialize::deserialize(self)
    }

-    fn visit_unit(&mut self) -> Result<(), Error> {
+    fn visit_unit(&mut self) -> Result<(), Self::Error> {
        Ok(())
    }
 }
@@ -227,41 +353,47 @@ impl<'a> de::VariantVisitor for StringDeserializer {
 ///////////////////////////////////////////////////////////////////////////////

 /// A helper deserializer that deserializes a sequence.
-pub struct SeqDeserializer<I> {
+pub struct SeqDeserializer<I, E> {
    iter: I,
    len: usize,
+    marker: PhantomData<E>,
 }

-impl<I> SeqDeserializer<I> {
+impl<I, E> SeqDeserializer<I, E>
+    where E: de::Error,
+{
    /// Construct a new `SeqDeserializer<I>`.
    pub fn new(iter: I, len: usize) -> Self {
        SeqDeserializer {
            iter: iter,
            len: len,
+            marker: PhantomData,
        }
    }
 }

-impl<I, T> de::Deserializer for SeqDeserializer<I>
+impl<I, T, E> de::Deserializer for SeqDeserializer<I, E>
    where I: Iterator<Item=T>,
-          T: ValueDeserializer,
+          T: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Error = Error;
+    type Error = E;

-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
        where V: de::Visitor,
    {
        visitor.visit_seq(self)
    }
 }

-impl<I, T> de::SeqVisitor for SeqDeserializer<I>
+impl<I, T, E> de::SeqVisitor for SeqDeserializer<I, E>
    where I: Iterator<Item=T>,
-          T: ValueDeserializer,
+          T: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Error = Error;
+    type Error = E;

-    fn visit<V>(&mut self) -> Result<Option<V>, Error>
+    fn visit<V>(&mut self) -> Result<Option<V>, Self::Error>
        where V: de::Deserialize
    {
        match self.iter.next() {
@@ -274,11 +406,11 @@ impl<I, T> de::SeqVisitor for SeqDeserializer<I>
        }
    }

-    fn end(&mut self) -> Result<(), Error> {
+    fn end(&mut self) -> Result<(), Self::Error> {
        if self.len == 0 {
            Ok(())
        } else {
-            Err(de::Error::length_mismatch(self.len))
+            Err(de::Error::invalid_length(self.len))
        }
    }

@@ -289,34 +421,40 @@ impl<I, T> de::SeqVisitor for SeqDeserializer<I>

 ///////////////////////////////////////////////////////////////////////////////

-impl<T> ValueDeserializer for Vec<T>
-    where T: ValueDeserializer,
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<T, E> ValueDeserializer<E> for Vec<T>
+    where T: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Deserializer = SeqDeserializer<vec::IntoIter<T>>;
+    type Deserializer = SeqDeserializer<vec::IntoIter<T>, E>;

-    fn into_deserializer(self) -> SeqDeserializer<vec::IntoIter<T>> {
+    fn into_deserializer(self) -> Self::Deserializer {
        let len = self.len();
        SeqDeserializer::new(self.into_iter(), len)
    }
 }

-impl<T> ValueDeserializer for BTreeSet<T>
-    where T: ValueDeserializer + Eq + Ord,
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<T, E> ValueDeserializer<E> for BTreeSet<T>
+    where T: ValueDeserializer<E> + Eq + Ord,
+          E: de::Error,
 {
-    type Deserializer = SeqDeserializer<btree_set::IntoIter<T>>;
+    type Deserializer = SeqDeserializer<btree_set::IntoIter<T>, E>;

-    fn into_deserializer(self) -> SeqDeserializer<btree_set::IntoIter<T>> {
+    fn into_deserializer(self) -> Self::Deserializer {
        let len = self.len();
        SeqDeserializer::new(self.into_iter(), len)
    }
 }

-impl<T> ValueDeserializer for HashSet<T>
-    where T: ValueDeserializer + Eq + Hash,
+#[cfg(feature = "std")]
+impl<T, E> ValueDeserializer<E> for HashSet<T>
+    where T: ValueDeserializer<E> + Eq + Hash,
+          E: de::Error,
 {
-    type Deserializer = SeqDeserializer<hash_set::IntoIter<T>>;
+    type Deserializer = SeqDeserializer<hash_set::IntoIter<T>, E>;

-    fn into_deserializer(self) -> SeqDeserializer<hash_set::IntoIter<T>> {
+    fn into_deserializer(self) -> Self::Deserializer {
        let len = self.len();
        SeqDeserializer::new(self.into_iter(), len)
    }
@@ -324,21 +462,56 @@ impl<T> ValueDeserializer for HashSet<T>

 ///////////////////////////////////////////////////////////////////////////////

+/// A helper deserializer that deserializes a sequence using a `SeqVisitor`.
+pub struct SeqVisitorDeserializer<V_, E> {
+    visitor: V_,
+    marker: PhantomData<E>,
+}
+
+impl<V_, E> SeqVisitorDeserializer<V_, E>
+    where V_: de::SeqVisitor<Error = E>,
+          E: de::Error,
+{
+    /// Construct a new `SeqVisitorDeserializer<V_, E>`.
+    pub fn new(visitor: V_) -> Self {
+        SeqVisitorDeserializer{
+            visitor: visitor,
+            marker: PhantomData
+        }
+    }
+}
+
+impl<V_, E> de::Deserializer for SeqVisitorDeserializer<V_, E>
+    where V_: de::SeqVisitor<Error = E>,
+          E: de::Error,
+{
+    type Error = E;
+
+    fn deserialize<V: de::Visitor>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error> {
+        visitor.visit_seq(&mut self.visitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 /// A helper deserializer that deserializes a map.
-pub struct MapDeserializer<I, K, V>
+pub struct MapDeserializer<I, K, V, E>
    where I: Iterator<Item=(K, V)>,
-          K: ValueDeserializer,
-          V: ValueDeserializer,
+          K: ValueDeserializer<E>,
+          V: ValueDeserializer<E>,
+          E: de::Error,
 {
    iter: I,
    value: Option<V>,
    len: usize,
+    marker: PhantomData<E>,
 }

-impl<I, K, V> MapDeserializer<I, K, V>
+impl<I, K, V, E> MapDeserializer<I, K, V, E>
    where I: Iterator<Item=(K, V)>,
-          K: ValueDeserializer,
-          V: ValueDeserializer,
+          K: ValueDeserializer<E>,
+          V: ValueDeserializer<E>,
+          E: de::Error,
 {
    /// Construct a new `MapDeserializer<I, K, V>`.
    pub fn new(iter: I, len: usize) -> Self {
@@ -346,32 +519,35 @@ impl<I, K, V> MapDeserializer<I, K, V>
            iter: iter,
            value: None,
            len: len,
+            marker: PhantomData,
        }
    }
 }

-impl<I, K, V> de::Deserializer for MapDeserializer<I, K, V>
+impl<I, K, V, E> de::Deserializer for MapDeserializer<I, K, V, E>
    where I: Iterator<Item=(K, V)>,
-          K: ValueDeserializer,
-          V: ValueDeserializer,
+          K: ValueDeserializer<E>,
+          V: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Error = Error;
+    type Error = E;

-    fn visit<V_>(&mut self, mut visitor: V_) -> Result<V_::Value, Error>
+    fn deserialize<V_>(&mut self, mut visitor: V_) -> Result<V_::Value, Self::Error>
        where V_: de::Visitor,
    {
        visitor.visit_map(self)
    }
 }

-impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
+impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
    where I: Iterator<Item=(K, V)>,
-          K: ValueDeserializer,
-          V: ValueDeserializer,
+          K: ValueDeserializer<E>,
+          V: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Error = Error;
+    type Error = E;

-    fn visit_key<T>(&mut self) -> Result<Option<T>, Error>
+    fn visit_key<T>(&mut self) -> Result<Option<T>, Self::Error>
        where T: de::Deserialize,
    {
        match self.iter.next() {
@@ -385,7 +561,7 @@ impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
        }
    }

-    fn visit_value<T>(&mut self) -> Result<T, Error>
+    fn visit_value<T>(&mut self) -> Result<T, Self::Error>
        where T: de::Deserialize,
    {
        match self.value.take() {
@@ -393,15 +569,17 @@ impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
                let mut de = value.into_deserializer();
                de::Deserialize::deserialize(&mut de)
            }
-            None => Err(de::Error::syntax("expected a map value"))
+            None => {
+                Err(de::Error::end_of_stream())
+            }
        }
    }

-    fn end(&mut self) -> Result<(), Error> {
+    fn end(&mut self) -> Result<(), Self::Error> {
        if self.len == 0 {
            Ok(())
        } else {
-            Err(de::Error::length_mismatch(self.len))
+            Err(de::Error::invalid_length(self.len))
        }
    }

@@ -412,25 +590,29 @@ impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>

 ///////////////////////////////////////////////////////////////////////////////

-impl<K, V> ValueDeserializer for BTreeMap<K, V>
-    where K: ValueDeserializer + Eq + Ord,
-          V: ValueDeserializer,
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<K, V, E> ValueDeserializer<E> for BTreeMap<K, V>
+    where K: ValueDeserializer<E> + Eq + Ord,
+          V: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Deserializer = MapDeserializer<btree_map::IntoIter<K, V>, K, V>;
+    type Deserializer = MapDeserializer<btree_map::IntoIter<K, V>, K, V, E>;

-    fn into_deserializer(self) -> MapDeserializer<btree_map::IntoIter<K, V>, K, V> {
+    fn into_deserializer(self) -> Self::Deserializer {
        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,
+#[cfg(feature = "std")]
+impl<K, V, E> ValueDeserializer<E> for HashMap<K, V>
+    where K: ValueDeserializer<E> + Eq + Hash,
+          V: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Deserializer = MapDeserializer<hash_map::IntoIter<K, V>, K, V>;
+    type Deserializer = MapDeserializer<hash_map::IntoIter<K, V>, K, V, E>;

-    fn into_deserializer(self) -> MapDeserializer<hash_map::IntoIter<K, V>, K, V> {
+    fn into_deserializer(self) -> Self::Deserializer {
        let len = self.len();
        MapDeserializer::new(self.into_iter(), len)
    }
@@ -438,22 +620,57 @@ impl<K, V> ValueDeserializer for HashMap<K, V>

 ///////////////////////////////////////////////////////////////////////////////

-impl<'a> ValueDeserializer for bytes::Bytes<'a>
-{
-    type Deserializer = BytesDeserializer<'a>;
+/// A helper deserializer that deserializes a map using a `MapVisitor`.
+pub struct MapVisitorDeserializer<V_, E> {
+    visitor: V_,
+    marker: PhantomData<E>,
+}

-    fn into_deserializer(self) -> BytesDeserializer<'a> {
-        BytesDeserializer(Some(self.into()))
+impl<V_, E> MapVisitorDeserializer<V_, E>
+    where V_: de::MapVisitor<Error = E>,
+          E: de::Error,
+{
+    /// Construct a new `MapVisitorDeserializer<V_, E>`.
+    pub fn new(visitor: V_) -> Self {
+        MapVisitorDeserializer{
+            visitor: visitor,
+            marker: PhantomData
+        }
+    }
+}
+
+impl<V_, E> de::Deserializer for MapVisitorDeserializer<V_, E>
+    where V_: de::MapVisitor<Error = E>,
+          E: de::Error,
+{
+    type Error = E;
+
+    fn deserialize<V: de::Visitor>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error> {
+        visitor.visit_map(&mut self.visitor)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+impl<'a, E> ValueDeserializer<E> for bytes::Bytes<'a>
+    where E: de::Error,
+{
+    type Deserializer = BytesDeserializer<'a, E>;
+
+    fn into_deserializer(self) -> BytesDeserializer<'a, E> {
+        BytesDeserializer(Some(self.into()), PhantomData)
    }
 }

 /// A helper deserializer that deserializes a `&[u8]`.
-pub struct BytesDeserializer<'a> (Option<&'a [u8]>);
+pub struct BytesDeserializer<'a, E> (Option<&'a [u8]>, PhantomData<E>);

-impl<'a> de::Deserializer for BytesDeserializer<'a> {
-    type Error = Error;
+impl<'a, E> de::Deserializer for BytesDeserializer<'a, E>
+    where E: de::Error
+{
+    type Error = E;

-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
        where V: de::Visitor,
    {
        match self.0.take() {
@@ -466,22 +683,28 @@ impl<'a> de::Deserializer for BytesDeserializer<'a> {

 ///////////////////////////////////////////////////////////////////////////////

-impl ValueDeserializer for bytes::ByteBuf
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<E> ValueDeserializer<E> for bytes::ByteBuf
+    where E: de::Error,
 {
-    type Deserializer = ByteBufDeserializer;
+    type Deserializer = ByteBufDeserializer<E>;

    fn into_deserializer(self) -> Self::Deserializer {
-        ByteBufDeserializer(Some(self.into()))
+        ByteBufDeserializer(Some(self.into()), PhantomData)
    }
 }

 /// A helper deserializer that deserializes a `Vec<u8>`.
-pub struct ByteBufDeserializer(Option<Vec<u8>>);
+#[cfg(any(feature = "std", feature = "collections"))]
+pub struct ByteBufDeserializer<E>(Option<Vec<u8>>, PhantomData<E>);

-impl de::Deserializer for ByteBufDeserializer {
-    type Error = Error;
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<E> de::Deserializer for ByteBufDeserializer<E>
+    where E: de::Error,
+{
+    type Error = E;

-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
        where V: de::Visitor,
    {
        match self.0.take() {
@@ -0,0 +1,44 @@
+//! A stand-in for `std::error`
+use core::any::TypeId;
+use core::fmt::{Debug, Display};
+
+
+/// A stand-in for `std::error::Error`, which requires no allocation.
+#[cfg(feature = "nightly")]
+pub trait Error: Debug + Display + ::core::marker::Reflect {
+    /// A short description of the error.
+    ///
+    /// The description should not contain newlines or sentence-ending
+    /// punctuation, to facilitate embedding in larger user-facing
+    /// strings.
+    fn description(&self) -> &str;
+
+    /// The lower-level cause of this error, if any.
+    fn cause(&self) -> Option<&Error> { None }
+
+    /// Get the `TypeId` of `self`
+    #[doc(hidden)]
+    fn type_id(&self) -> TypeId where Self: 'static {
+        TypeId::of::<Self>()
+    }
+}
+
+/// A stand-in for `std::error::Error`, which requires no allocation.
+#[cfg(not(feature = "nightly"))]
+pub trait Error: Debug + Display {
+    /// A short description of the error.
+    ///
+    /// The description should not contain newlines or sentence-ending
+    /// punctuation, to facilitate embedding in larger user-facing
+    /// strings.
+    fn description(&self) -> &str;
+
+    /// The lower-level cause of this error, if any.
+    fn cause(&self) -> Option<&Error> { None }
+
+    /// Stubbed! Returns type_id of `()`
+    #[doc(hidden)]
+    fn type_id(&self) -> TypeId where Self: 'static {
+        TypeId::of::<()>()
+    }
+}
@@ -10,25 +10,46 @@
 //! [github repository](https://github.com/serde-rs/serde)

 #![doc(html_root_url="https://serde-rs.github.io/serde/serde")]
-#![cfg_attr(feature = "nightly", feature(collections, enumset, nonzero, plugin, step_trait,
-                                         zero_one))]
-#![cfg_attr(feature = "nightly", plugin(clippy))]
-#![cfg_attr(feature = "nightly", allow(linkedlist))]
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(feature = "nightly", feature(reflect_marker, unicode, nonzero, plugin, step_trait, zero_one))]
+#![cfg_attr(feature = "alloc", feature(alloc))]
+#![cfg_attr(feature = "collections", feature(collections, enumset))]
+#![cfg_attr(feature = "nightly-testing", plugin(clippy))]
+#![cfg_attr(feature = "nightly-testing", allow(linkedlist))]
+
+#![cfg_attr(any(not(feature = "std"), feature = "nightly"), allow(unused_variables, unused_imports, unused_features, dead_code))]

 #![deny(missing_docs)]

-extern crate num;
-
-#[cfg(feature = "nightly")]
+#[cfg(all(feature = "nightly", feature = "collections"))]
 extern crate collections;

-#[cfg(feature = "nightly")]
-extern crate core;
+#[cfg(all(feature = "nightly", feature = "alloc"))]
+extern crate alloc;
+
+#[cfg(feature = "std")]
+mod core {
+    pub use std::{ops, hash, fmt, cmp, marker, mem, i8, i16, i32, i64, u8, u16, u32, u64, isize,
+            usize, f32, f64, char, str, num, slice, iter};
+    #[cfg(feature = "nightly")]
+    extern crate core;
+    #[cfg(feature = "nightly")]
+    pub use self::core::nonzero;
+}

 pub use ser::{Serialize, Serializer};
 pub use de::{Deserialize, Deserializer, Error};

+#[cfg(not(feature = "std"))]
+macro_rules! format {
+    ($s:expr, $($rest:tt)*) => ($s)
+}
+
 pub mod bytes;
 pub mod de;
+#[cfg(feature = "std")]
 pub mod iter;
 pub mod ser;
+#[cfg(not(feature = "std"))]
+pub mod error;
+mod utils;
@@ -1,6 +1,11 @@
 //! Implementations for all of Rust's builtin types.

+#[cfg(feature = "std")]
 use std::borrow::Cow;
+#[cfg(all(feature = "collections", not(feature = "std")))]
+use collections::borrow::Cow;
+
+#[cfg(feature = "std")]
 use std::collections::{
    BinaryHeap,
    BTreeMap,
@@ -10,23 +15,53 @@ use std::collections::{
    HashSet,
    VecDeque,
 };
-#[cfg(feature = "nightly")]
+#[cfg(all(feature = "collections", not(feature = "std")))]
+use collections::{
+    BinaryHeap,
+    BTreeMap,
+    BTreeSet,
+    LinkedList,
+    VecDeque,
+    String,
+    Vec,
+};
+
+#[cfg(all(feature = "nightly", feature = "collections"))]
 use collections::enum_set::{CLike, EnumSet};
-use std::hash::Hash;
+#[cfg(all(feature = "nightly", feature = "collections"))]
+use collections::borrow::ToOwned;
+
+use core::hash::{Hash, BuildHasher};
 #[cfg(feature = "nightly")]
-use std::iter;
+use core::iter;
+#[cfg(feature = "std")]
+use std::net;
 #[cfg(feature = "nightly")]
-use std::num;
+use core::num;
 #[cfg(feature = "nightly")]
-use std::ops;
+use core::ops;
+#[cfg(feature = "std")]
 use std::path;
+#[cfg(feature = "std")]
 use std::rc::Rc;
+#[cfg(all(feature = "alloc", not(feature = "std")))]
+use alloc::rc::Rc;
+
+#[cfg(feature = "std")]
 use std::sync::Arc;
+#[cfg(all(feature = "alloc", not(feature = "std")))]
+use alloc::arc::Arc;
+
+#[cfg(all(feature = "alloc", not(feature = "std")))]
+use alloc::boxed::Box;
+
+use core::marker::PhantomData;

 #[cfg(feature = "nightly")]
 use core::nonzero::{NonZero, Zeroable};

 use super::{
+    Error,
    Serialize,
    Serializer,
    SeqVisitor,
@@ -48,20 +83,20 @@ macro_rules! impl_visit {
    }
 }

-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_visit!(bool, serialize_bool);
+impl_visit!(isize, serialize_isize);
+impl_visit!(i8, serialize_i8);
+impl_visit!(i16, serialize_i16);
+impl_visit!(i32, serialize_i32);
+impl_visit!(i64, serialize_i64);
+impl_visit!(usize, serialize_usize);
+impl_visit!(u8, serialize_u8);
+impl_visit!(u16, serialize_u16);
+impl_visit!(u32, serialize_u32);
+impl_visit!(u64, serialize_u64);
+impl_visit!(f32, serialize_f32);
+impl_visit!(f64, serialize_f64);
+impl_visit!(char, serialize_char);

 ///////////////////////////////////////////////////////////////////////////////

@@ -70,10 +105,11 @@ impl Serialize for str {
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        serializer.visit_str(self)
+        serializer.serialize_str(self)
    }
 }

+#[cfg(any(feature = "std", feature = "collections"))]
 impl Serialize for String {
    #[inline]
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -91,8 +127,8 @@ impl<T> Serialize for Option<T> where T: Serialize {
        where S: Serializer,
    {
        match *self {
-            Some(ref value) => serializer.visit_some(value),
-            None => serializer.visit_none(),
+            Some(ref value) => serializer.serialize_some(value),
+            None => serializer.serialize_none(),
        }
    }
 }
@@ -104,7 +140,7 @@ impl<T> SeqVisitor for Option<T> where T: Serialize {
    {
        match self.take() {
            Some(value) => {
-                try!(serializer.visit_seq_elt(value));
+                try!(serializer.serialize_seq_elt(value));
                Ok(Some(()))
            }
            None => Ok(None),
@@ -119,6 +155,17 @@ impl<T> SeqVisitor for Option<T> where T: Serialize {

 ///////////////////////////////////////////////////////////////////////////////

+impl<T> Serialize for PhantomData<T> {
+    #[inline]
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        serializer.serialize_unit_struct("PhantomData")
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 /// A `serde::Visitor` for sequence iterators.
 ///
 /// # Examples
@@ -133,7 +180,7 @@ impl<T> SeqVisitor for Option<T> where T: Serialize {
 ///     fn serialize<S>(&self, ser: &mut S) -> Result<(), S::Error>
 ///         where S: Serializer,
 ///     {
-///         ser.visit_seq(SeqIteratorVisitor::new(
+///         ser.serialize_seq(SeqIteratorVisitor::new(
 ///             self.0.iter(),
 ///             Some(self.0.len()),
 ///         ))
@@ -168,7 +215,7 @@ impl<T, Iter> SeqVisitor for SeqIteratorVisitor<Iter>
    {
        match self.iter.next() {
            Some(value) => {
-                try!(serializer.visit_seq_elt(value));
+                try!(serializer.serialize_seq_elt(value));
                Ok(Some(()))
            }
            None => Ok(None),
@@ -190,10 +237,12 @@ impl<T> Serialize for [T]
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+        serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
    }
 }

+///////////////////////////////////////////////////////////////////////////////
+
 macro_rules! array_impls {
    ($len:expr) => {
        impl<T> Serialize for [T; $len] where T: Serialize {
@@ -201,7 +250,8 @@ macro_rules! array_impls {
            fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
                where S: Serializer,
            {
-                serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some($len)))
+                let visitor = SeqIteratorVisitor::new(self.iter(), Some($len));
+                serializer.serialize_fixed_size_array(visitor)
            }
        }
    }
@@ -243,6 +293,7 @@ array_impls!(32);

 ///////////////////////////////////////////////////////////////////////////////

+#[cfg(any(feature = "std", feature = "collections"))]
 impl<T> Serialize for BinaryHeap<T>
    where T: Serialize + Ord
 {
@@ -250,10 +301,11 @@ impl<T> Serialize for BinaryHeap<T>
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+        serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
    }
 }

+#[cfg(any(feature = "std", feature = "collections"))]
 impl<T> Serialize for BTreeSet<T>
    where T: Serialize + Ord,
 {
@@ -261,11 +313,11 @@ impl<T> Serialize for BTreeSet<T>
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+        serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
    }
 }

-#[cfg(feature = "nightly")]
+#[cfg(all(feature = "nightly", feature = "collections"))]
 impl<T> Serialize for EnumSet<T>
    where T: Serialize + CLike
 {
@@ -273,21 +325,24 @@ impl<T> Serialize for EnumSet<T>
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+        serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
    }
 }

-impl<T> Serialize for HashSet<T>
+#[cfg(feature = "std")]
+impl<T, H> Serialize for HashSet<T, H>
    where T: Serialize + Eq + Hash,
+          H: BuildHasher,
 {
    #[inline]
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+        serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
    }
 }

+#[cfg(any(feature = "std", feature = "collections"))]
 impl<T> Serialize for LinkedList<T>
    where T: Serialize,
 {
@@ -295,7 +350,7 @@ impl<T> Serialize for LinkedList<T>
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        serializer.visit_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
+        serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
    }
 }

@@ -309,10 +364,11 @@ impl<A> Serialize for ops::Range<A>
        where S: Serializer,
    {
        let len = iter::Step::steps_between(&self.start, &self.end, &A::one());
-        serializer.visit_seq(SeqIteratorVisitor::new(self.clone(), len))
+        serializer.serialize_seq(SeqIteratorVisitor::new(self.clone(), len))
    }
 }

+#[cfg(any(feature = "std", feature = "collections"))]
 impl<T> Serialize for Vec<T> where T: Serialize {
    #[inline]
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -322,12 +378,13 @@ impl<T> Serialize for Vec<T> where T: Serialize {
    }
 }

+#[cfg(any(feature = "std", feature = "collections"))]
 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())))
+        serializer.serialize_seq(SeqIteratorVisitor::new(self.iter(), Some(self.len())))
    }
 }

@@ -338,7 +395,7 @@ impl Serialize for () {
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        serializer.visit_unit()
+        serializer.serialize_unit()
    }
 }

@@ -382,7 +439,7 @@ macro_rules! tuple_impls {
                        $(
                            $state => {
                                self.state += 1;
-                                Ok(Some(try!(serializer.visit_tuple_elt(&e!(self.tuple.$idx)))))
+                                Ok(Some(try!(serializer.serialize_tuple_elt(&e!(self.tuple.$idx)))))
                            }
                        )+
                        _ => {
@@ -401,7 +458,7 @@ macro_rules! tuple_impls {
            {
                #[inline]
                fn serialize<S: Serializer>(&self, serializer: &mut S) -> Result<(), S::Error> {
-                    serializer.visit_tuple($TupleVisitor::new(self))
+                    serializer.serialize_tuple($TupleVisitor::new(self))
                }
            }
        )+
@@ -530,7 +587,7 @@ tuple_impls! {
 ///     fn serialize<S>(&self, ser: &mut S) -> Result<(), S::Error>
 ///         where S: Serializer,
 ///     {
-///         ser.visit_map(MapIteratorVisitor::new(
+///         ser.serialize_map(MapIteratorVisitor::new(
 ///             self.0.iter(),
 ///             Some(self.0.len()),
 ///         ))
@@ -566,7 +623,7 @@ impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
    {
        match self.iter.next() {
            Some((key, value)) => {
-                try!(serializer.visit_map_elt(key, value));
+                try!(serializer.serialize_map_elt(key, value));
                Ok(Some(()))
            }
            None => Ok(None)
@@ -581,6 +638,7 @@ impl<K, V, I> MapVisitor for MapIteratorVisitor<I>

 ///////////////////////////////////////////////////////////////////////////////

+#[cfg(any(feature = "std", feature = "collections"))]
 impl<K, V> Serialize for BTreeMap<K, V>
    where K: Serialize + Ord,
          V: Serialize,
@@ -589,19 +647,21 @@ impl<K, V> Serialize for BTreeMap<K, V>
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
+        serializer.serialize_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
    }
 }

-impl<K, V> Serialize for HashMap<K, V>
+#[cfg(feature = "std")]
+impl<K, V, H> Serialize for HashMap<K, V, H>
    where K: Serialize + Eq + Hash,
          V: Serialize,
+          H: BuildHasher,
 {
    #[inline]
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        serializer.visit_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
+        serializer.serialize_map(MapIteratorVisitor::new(self.iter(), Some(self.len())))
    }
 }

@@ -625,6 +685,7 @@ impl<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize {
    }
 }

+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<T: ?Sized> Serialize for Box<T> where T: Serialize {
    #[inline]
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -634,6 +695,7 @@ impl<T: ?Sized> Serialize for Box<T> where T: Serialize {
    }
 }

+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<T> Serialize for Rc<T> where T: Serialize, {
    #[inline]
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -643,6 +705,7 @@ impl<T> Serialize for Rc<T> where T: Serialize, {
    }
 }

+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<T> Serialize for Arc<T> where T: Serialize, {
    #[inline]
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -652,6 +715,7 @@ impl<T> Serialize for Arc<T> where T: Serialize, {
    }
 }

+#[cfg(any(feature = "std", feature = "collections"))]
 impl<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned, {
    #[inline]
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -667,10 +731,10 @@ 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)
+                serializer.serialize_newtype_variant("Result", 0, "Ok", value)
            }
            Result::Err(ref value) => {
-                serializer.visit_newtype_variant("Result", 1, "Err", value)
+                serializer.serialize_newtype_variant("Result", 1, "Err", value)
            }
        }
    }
@@ -678,19 +742,88 @@ impl<T, E> Serialize for Result<T, E> where T: Serialize, E: Serialize {

 ///////////////////////////////////////////////////////////////////////////////

+#[cfg(all(feature = "std", feature = "nightly"))]
+impl Serialize for net::IpAddr {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        match *self {
+            net::IpAddr::V4(ref addr) => addr.serialize(serializer),
+            net::IpAddr::V6(ref addr) => addr.serialize(serializer),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl Serialize for net::Ipv4Addr {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_string().serialize(serializer)
+    }
+}
+
+#[cfg(feature = "std")]
+impl Serialize for net::Ipv6Addr {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_string().serialize(serializer)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[cfg(feature = "std")]
+impl Serialize for net::SocketAddr {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        match *self {
+            net::SocketAddr::V4(ref addr) => addr.serialize(serializer),
+            net::SocketAddr::V6(ref addr) => addr.serialize(serializer),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl Serialize for net::SocketAddrV4 {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_string().serialize(serializer)
+    }
+}
+
+#[cfg(feature = "std")]
+impl Serialize for net::SocketAddrV6 {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_string().serialize(serializer)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+#[cfg(feature = "std")]
 impl Serialize for path::Path {
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        self.to_str().unwrap().serialize(serializer)
+        match self.to_str() {
+            Some(s) => s.serialize(serializer),
+            None => Err(Error::invalid_value("Path contains invalid UTF-8 characters")),
+        }
    }
 }

+#[cfg(feature = "std")]
 impl Serialize for path::PathBuf {
    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
        where S: Serializer,
    {
-        self.to_str().unwrap().serialize(serializer)
+        self.as_path().serialize(serializer)
    }
 }

@@ -700,37 +833,3 @@ impl<T> Serialize for NonZero<T> where T: Serialize + Zeroable {
        (**self).serialize(serializer)
    }
 }
-
-///////////////////////////////////////////////////////////////////////////////
-
-#[cfg(feature = "num-bigint")]
-impl Serialize for ::num::bigint::BigInt {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer {
-        self.to_str_radix(10).serialize(serializer)
-    }
-}
-
-#[cfg(feature = "num-bigint")]
-impl Serialize for ::num::bigint::BigUint {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer {
-        self.to_str_radix(10).serialize(serializer)
-    }
-}
-
-#[cfg(feature = "num-complex")]
-impl<T> Serialize for ::num::complex::Complex<T>
-    where T: Serialize + Clone + ::num::Num
-{
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer {
-        (&self.re, &self.im).serialize(serializer)
-    }
-}
-
-#[cfg(feature = "num-rational")]
-impl<T> Serialize for ::num::rational::Ratio<T>
-    where T: Serialize + Clone + ::num::Integer + PartialOrd
-{
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error> where S: Serializer {
-        (self.numer(), self.denom()).serialize(serializer)
-    }
-}
@@ -1,9 +1,36 @@
 //! Generic serialization framework.

+#[cfg(feature = "std")]
+use std::error;
+#[cfg(not(feature = "std"))]
+use error;
+
+#[cfg(all(feature = "collections", not(feature = "std")))]
+use collections::String;
+
 pub mod impls;

 ///////////////////////////////////////////////////////////////////////////////

+/// `Error` is a trait that allows a `Serialize` to generically create a
+/// `Serializer` error.
+pub trait Error: Sized + error::Error {
+    /// Raised when there is general error when deserializing a type.
+    #[cfg(any(feature = "std", feature = "collections"))]
+    fn custom<T: Into<String>>(msg: T) -> Self;
+
+    /// Raised when there is general error when deserializing a type.
+    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
+    fn custom<T: Into<&'static str>>(msg: T) -> Self;
+
+    /// Raised when a `Serialize` was passed an incorrect value.
+    fn invalid_value(msg: &str) -> Self {
+        Error::custom(format!("invalid value: {}", msg))
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 /// A trait that describes a type that can be serialized by a `Serializer`.
 pub trait Serialize {
    /// Serializes this value into this serializer.
@@ -16,249 +43,257 @@ pub trait Serialize {
 /// A trait that describes a type that can serialize a stream of values into the underlying format.
 pub trait Serializer {
    /// The error type that can be returned if some error occurs during serialization.
-    type Error;
+    type Error: Error;

-    /// `visit_bool` serializes a `bool` value.
-    fn visit_bool(&mut self, v: bool) -> Result<(), Self::Error>;
+    /// Serializes a `bool` value.
+    fn serialize_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.
+    /// Serializes a `isize` value. By default it casts the value to a `i64` and
+    /// passes it to the `serialize_i64` method.
    #[inline]
-    fn visit_isize(&mut self, v: isize) -> Result<(), Self::Error> {
-        self.visit_i64(v as i64)
+    fn serialize_isize(&mut self, v: isize) -> Result<(), Self::Error> {
+        self.serialize_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.
+    /// Serializes a `i8` value. By default it casts the value to a `i64` and
+    /// passes it to the `serialize_i64` method.
    #[inline]
-    fn visit_i8(&mut self, v: i8) -> Result<(), Self::Error> {
-        self.visit_i64(v as i64)
+    fn serialize_i8(&mut self, v: i8) -> Result<(), Self::Error> {
+        self.serialize_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.
+    /// Serializes a `i16` value. By default it casts the value to a `i64` and
+    /// passes it to the `serialize_i64` method.
    #[inline]
-    fn visit_i16(&mut self, v: i16) -> Result<(), Self::Error> {
-        self.visit_i64(v as i64)
+    fn serialize_i16(&mut self, v: i16) -> Result<(), Self::Error> {
+        self.serialize_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.
+    /// Serializes a `i32` value. By default it casts the value to a `i64` and
+    /// passes it to the `serialize_i64` method.
    #[inline]
-    fn visit_i32(&mut self, v: i32) -> Result<(), Self::Error> {
-        self.visit_i64(v as i64)
+    fn serialize_i32(&mut self, v: i32) -> Result<(), Self::Error> {
+        self.serialize_i64(v as i64)
    }

-    /// `visit_i64` serializes a `i64` value.
+    /// Serializes a `i64` value.
    #[inline]
-    fn visit_i64(&mut self, v: i64) -> Result<(), Self::Error>;
+    fn serialize_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.
+    /// Serializes a `usize` value. By default it casts the value to a `u64` and
+    /// passes it to the `serialize_u64` method.
    #[inline]
-    fn visit_usize(&mut self, v: usize) -> Result<(), Self::Error> {
-        self.visit_u64(v as u64)
+    fn serialize_usize(&mut self, v: usize) -> Result<(), Self::Error> {
+        self.serialize_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.
+    /// Serializes a `u8` value. By default it casts the value to a `u64` and passes
+    /// it to the `serialize_u64` method.
    #[inline]
-    fn visit_u8(&mut self, v: u8) -> Result<(), Self::Error> {
-        self.visit_u64(v as u64)
+    fn serialize_u8(&mut self, v: u8) -> Result<(), Self::Error> {
+        self.serialize_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.
+    /// Serializes a `u32` value. By default it casts the value to a `u64` and passes
+    /// it to the `serialize_u64` method.
    #[inline]
-    fn visit_u16(&mut self, v: u16) -> Result<(), Self::Error> {
-        self.visit_u64(v as u64)
+    fn serialize_u16(&mut self, v: u16) -> Result<(), Self::Error> {
+        self.serialize_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.
+    /// Serializes a `u32` value. By default it casts the value to a `u64` and passes
+    /// it to the `serialize_u64` method.
    #[inline]
-    fn visit_u32(&mut self, v: u32) -> Result<(), Self::Error> {
-        self.visit_u64(v as u64)
+    fn serialize_u32(&mut self, v: u32) -> Result<(), Self::Error> {
+        self.serialize_u64(v as u64)
    }

-    /// `visit_u64` serializes a `u64` value.
+    /// `Serializes a `u64` value.
    #[inline]
-    fn visit_u64(&mut self, v: u64) -> Result<(), Self::Error>;
+    fn serialize_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.
+    /// Serializes a `f32` value. By default it casts the value to a `f64` and passes
+    /// it to the `serialize_f64` method.
    #[inline]
-    fn visit_f32(&mut self, v: f32) -> Result<(), Self::Error> {
-        self.visit_f64(v as f64)
+    fn serialize_f32(&mut self, v: f32) -> Result<(), Self::Error> {
+        self.serialize_f64(v as f64)
    }

-    /// `visit_f64` serializes a `f64` value.
-    fn visit_f64(&mut self, v: f64) -> Result<(), Self::Error>;
+    /// Serializes a `f64` value.
+    fn serialize_f64(&mut self, v: f64) -> Result<(), Self::Error>;

-    /// `visit_char` serializes a character. By default it serializes it as a `&str` containing a
+    /// 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())
+    fn serialize_char(&mut self, v: char) -> Result<(), Self::Error> {
+        self.serialize_str(::utils::encode_utf8(v).as_str())
    }

-    /// `visit_str` serializes a `&str`.
-    fn visit_str(&mut self, value: &str) -> Result<(), Self::Error>;
+    /// Serializes a `&str`.
+    fn serialize_str(&mut self, value: &str) -> Result<(), Self::Error>;

-    /// `visit_bytes` is a hook that enables those serialization formats that support serializing
+    /// 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 serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> {
+        self.serialize_seq(impls::SeqIteratorVisitor::new(value.iter(), Some(value.len())))
    }

    /// Serializes a `()` value.
-    fn visit_unit(&mut self) -> Result<(), Self::Error>;
+    fn serialize_unit(&mut self) -> Result<(), Self::Error>;

    /// Serializes a unit struct value.
    ///
    /// By default, unit structs are serialized as a `()`.
    #[inline]
-    fn visit_unit_struct(&mut self, _name: &'static str) -> Result<(), Self::Error> {
-        self.visit_unit()
+    fn serialize_unit_struct(&mut self, _name: &'static str) -> Result<(), Self::Error> {
+        self.serialize_unit()
    }

    /// Serializes a unit variant, otherwise known as a variant with no arguments.
    ///
    /// By default, unit variants are serialized as a `()`.
    #[inline]
-    fn visit_unit_variant(&mut self,
-                          _name: &'static str,
-                          _variant_index: usize,
-                          _variant: &'static str) -> Result<(), Self::Error> {
-        self.visit_unit()
+    fn serialize_unit_variant(&mut self,
+                              _name: &'static str,
+                              _variant_index: usize,
+                              _variant: &'static str) -> Result<(), Self::Error> {
+        self.serialize_unit()
    }

-    /// The `visit_newtype_struct` allows a tuple struct with a single element, also known as a
+    /// 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>
+    fn serialize_newtype_struct<T>(&mut self,
+                                   name: &'static str,
+                                   value: T) -> Result<(), Self::Error>
        where T: Serialize,
    {
-        self.visit_tuple_struct(name, Some(value))
+        self.serialize_tuple_struct(name, Some(value))
    }

-    /// The `visit_newtype_variant` allows a variant with a single item to be more efficiently
+    /// 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>
+    fn serialize_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(
+        self.serialize_tuple_variant(
            name,
            variant_index,
            variant,
            Some(value))
    }

-    /// Serializes a `None` value.
-    fn visit_none(&mut self) -> Result<(), Self::Error>;
+    /// Serializes a `None` value..serialize
+    fn serialize_none(&mut self) -> Result<(), Self::Error>;

    /// Serializes a `Some(...)` value.
-    fn visit_some<V>(&mut self, value: V) -> Result<(), Self::Error>
+    fn serialize_some<V>(&mut self, value: V) -> Result<(), Self::Error>
        where V: Serialize;

    /// Serializes a sequence.
    ///
    /// Callees of this method need to construct a `SeqVisitor`, which iterates through each item
    /// in the sequence.
-    fn visit_seq<V>(&mut self, visitor: V) -> Result<(), Self::Error>
+    fn serialize_seq<V>(&mut self, visitor: V) -> Result<(), Self::Error>
        where V: SeqVisitor;

    /// Serializes a sequence element.
-    fn visit_seq_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+    fn serialize_seq_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
        where T: Serialize;

    /// Serializes a tuple.
    ///
    /// By default this serializes a tuple as a sequence.
    #[inline]
-    fn visit_tuple<V>(&mut self, visitor: V) -> Result<(), Self::Error>
+    fn serialize_tuple<V>(&mut self, visitor: V) -> Result<(), Self::Error>
        where V: SeqVisitor,
    {
-        self.visit_seq(visitor)
+        self.serialize_seq(visitor)
    }

    /// Serializes a tuple element.
    ///
    /// By default, tuples are serialized as a sequence.
    #[inline]
-    fn visit_tuple_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+    fn serialize_tuple_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
        where T: Serialize
    {
-        self.visit_seq_elt(value)
+        self.serialize_seq_elt(value)
+    }
+
+    /// Serializes a fixed-size array.
+    ///
+    /// By default this serializes an array as a sequence.
+    #[inline]
+    fn serialize_fixed_size_array<V>(&mut self, visitor: V) -> Result<(), Self::Error>
+        where V: SeqVisitor,
+    {
+        self.serialize_seq(visitor)
    }

    /// Serializes a tuple struct.
    ///
    /// By default, tuple structs are serialized as a tuple.
    #[inline]
-    fn visit_tuple_struct<V>(&mut self,
-                             _name: &'static str,
-                             visitor: V) -> Result<(), Self::Error>
+    fn serialize_tuple_struct<V>(&mut self,
+                                 _name: &'static str,
+                                 visitor: V) -> Result<(), Self::Error>
        where V: SeqVisitor,
    {
-        self.visit_tuple(visitor)
+        self.serialize_tuple(visitor)
    }

    /// Serializes a tuple struct element.
    ///
    /// By default, tuple struct elements are serialized as a tuple element.
    #[inline]
-    fn visit_tuple_struct_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+    fn serialize_tuple_struct_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
        where T: Serialize
    {
-        self.visit_tuple_elt(value)
+        self.serialize_tuple_elt(value)
    }

    /// Serializes a tuple variant.
    ///
    /// By default, tuple variants are serialized as a tuple struct.
    #[inline]
-    fn visit_tuple_variant<V>(&mut self,
-                              _name: &'static str,
-                              _variant_index: usize,
-                              variant: &'static str,
-                              visitor: V) -> Result<(), Self::Error>
+    fn serialize_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)
+        self.serialize_tuple_struct(variant, visitor)
    }

    /// Serializes a tuple element.
    ///
    /// By default, tuples are serialized as a sequence.
    #[inline]
-    fn visit_tuple_variant_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+    fn serialize_tuple_variant_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
        where T: Serialize
    {
-        self.visit_tuple_struct_elt(value)
+        self.serialize_tuple_struct_elt(value)
    }

    /// Serializes a map.
    ///
    /// Callees of this method need to construct a `MapVisitor`, which iterates through each item
    /// in the map.
-    fn visit_map<V>(&mut self, visitor: V) -> Result<(), Self::Error>
+    fn serialize_map<V>(&mut self, visitor: V) -> Result<(), Self::Error>
        where V: MapVisitor;

    /// Serializes a map element (key-value pair).
-    fn visit_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error>
+    fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error>
        where K: Serialize,
              V: Serialize;

@@ -266,63 +301,55 @@ pub trait Serializer {
    ///
    /// By default, structs are serialized as a map with the field name as the key.
    #[inline]
-    fn visit_struct<V>(&mut self,
-                       _name: &'static str,
-                       visitor: V) -> Result<(), Self::Error>
+    fn serialize_struct<V>(&mut self,
+                           _name: &'static str,
+                           visitor: V) -> Result<(), Self::Error>
        where V: MapVisitor,
    {
-        self.visit_map(visitor)
+        self.serialize_map(visitor)
    }

    /// Serializes an element of a struct.
    ///
    /// By default, struct elements are serialized as a map element with the field name as the key.
    #[inline]
-    fn visit_struct_elt<V>(&mut self,
-                           key: &'static str,
-                           value: V) -> Result<(), Self::Error>
+    fn serialize_struct_elt<V>(&mut self,
+                               key: &'static str,
+                               value: V) -> Result<(), Self::Error>
        where V: Serialize,
    {
-        self.visit_map_elt(key, value)
+        self.serialize_map_elt(key, value)
    }

    /// Serializes a struct variant.
    ///
    /// By default, struct variants are serialized as a struct.
    #[inline]
-    fn visit_struct_variant<V>(&mut self,
-                               _name: &'static str,
-                               _variant_index: usize,
-                               variant: &'static str,
-                               visitor: V) -> Result<(), Self::Error>
+    fn serialize_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)
+        self.serialize_struct(variant, visitor)
    }

    /// Serializes an element of a struct variant.
    ///
    /// By default, struct variant elements are serialized as a struct element.
    #[inline]
-    fn visit_struct_variant_elt<V>(&mut self,
-                                   key: &'static str,
-                                   value: V) -> Result<(), Self::Error>
+    fn serialize_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 {
-        ""
+        self.serialize_struct_elt(key, value)
    }
 }

 /// A trait that is used by a `Serialize` to iterate through a sequence.
-#[cfg_attr(feature = "nightly", allow(len_without_is_empty))]
+#[cfg_attr(feature = "nightly-testing", allow(len_without_is_empty))]
 pub trait SeqVisitor {
    /// Serializes a sequence item in the serializer.
    ///
@@ -339,7 +366,7 @@ pub trait SeqVisitor {
 }

 /// A trait that is used by a `Serialize` to iterate through a map.
-#[cfg_attr(feature = "nightly", allow(len_without_is_empty))]
+#[cfg_attr(feature = "nightly-testing", allow(len_without_is_empty))]
 pub trait MapVisitor {
    /// Serializes a map item in the serializer.
    ///
@@ -0,0 +1,72 @@
+//! Private utility functions
+
+const TAG_CONT: u8    = 0b1000_0000;
+const TAG_TWO_B: u8   = 0b1100_0000;
+const TAG_THREE_B: u8 = 0b1110_0000;
+const TAG_FOUR_B: u8  = 0b1111_0000;
+const MAX_ONE_B: u32   =     0x80;
+const MAX_TWO_B: u32   =    0x800;
+const MAX_THREE_B: u32 =  0x10000;
+
+#[inline]
+pub fn encode_utf8(c: char) -> EncodeUtf8 {
+    let code = c as u32;
+    let mut buf = [0; 4];
+    let pos = if code < MAX_ONE_B {
+        buf[3] = code as u8;
+        3
+    } else if code < MAX_TWO_B {
+        buf[2] = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
+        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
+        2
+    } else if code < MAX_THREE_B {
+        buf[1] = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
+        buf[2] = (code >>  6 & 0x3F) as u8 | TAG_CONT;
+        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
+        1
+    } else {
+        buf[0] = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
+        buf[1] = (code >> 12 & 0x3F) as u8 | TAG_CONT;
+        buf[2] = (code >>  6 & 0x3F) as u8 | TAG_CONT;
+        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
+        0
+    };
+    EncodeUtf8 { buf: buf, pos: pos }
+}
+
+pub struct EncodeUtf8 {
+    buf: [u8; 4],
+    pos: usize,
+}
+
+impl EncodeUtf8 {
+    // FIXME: use this from_utf8_unchecked, since we know it can never fail
+    pub fn as_str(&self) -> &str {
+        ::core::str::from_utf8(&self.buf[self.pos..]).unwrap()
+    }
+}
+
+#[allow(non_upper_case_globals)]
+const Pattern_White_Space_table: &'static [(char, char)] = &[
+    ('\u{9}', '\u{d}'), ('\u{20}', '\u{20}'), ('\u{85}', '\u{85}'), ('\u{200e}', '\u{200f}'),
+    ('\u{2028}', '\u{2029}')
+];
+
+fn bsearch_range_table(c: char, r: &'static [(char, char)]) -> bool {
+    use core::cmp::Ordering::{Equal, Less, Greater};
+    r.binary_search_by(|&(lo, hi)| {
+        if c < lo {
+            Greater
+        } else if hi < c {
+            Less
+        } else {
+            Equal
+        }
+    })
+    .is_ok()
+}
+
+#[allow(non_snake_case)]
+pub fn Pattern_White_Space(c: char) -> bool {
+    bsearch_range_table(c, Pattern_White_Space_table)
+}
@@ -1,27 +1,29 @@
 [package]
 name = "serde_codegen"
-version = "0.6.11"
+version = "0.7.10"
 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"
-documentation = "https://serde-rs.github.io/serde/serde_codegen/serde_codegen/index.html"
-build = "build.rs"
+documentation = "https://github.com/serde-rs/serde"
 keywords = ["serde", "serialization"]
+build = "build.rs"
+include = ["Cargo.toml", "build.rs", "src/**/*.rs", "src/lib.rs.in"]

 [features]
 default = ["with-syntex"]
-nightly = ["clippy", "quasi_macros"]
+nightly = ["quasi_macros"]
+nightly-testing = ["clippy"]
 with-syntex = ["quasi/with-syntex", "quasi_codegen", "quasi_codegen/with-syntex", "syntex", "syntex_syntax"]

 [build-dependencies]
-quasi_codegen = { version = "^0.4.0", optional = true }
-syntex = { version = "^0.26.0", optional = true }
+quasi_codegen = { version = "^0.12.0", optional = true }
+syntex = { version = "^0.33.0", optional = true }

 [dependencies]
-aster = { version = "^0.10.0", default-features = false }
-clippy = { version = "^0.0.37", optional = true }
-quasi = { version = "^0.4.0", default-features = false }
-quasi_macros = { version = "^0.4.0", optional = true }
-syntex = { version = "^0.26.0", optional = true }
-syntex_syntax = { version = "^0.26.0", optional = true }
+aster = { version = "^0.18.0", default-features = false }
+clippy = { version = "^0.*", optional = true }
+quasi = { version = "^0.12.0", default-features = false }
+quasi_macros = { version = "^0.12.0", optional = true }
+syntex = { version = "^0.35.0", optional = true }
+syntex_syntax = { version = "^0.35.0", optional = true }
@@ -8,13 +8,11 @@ mod inner {

    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();
+        quasi_codegen::expand(&src, &dst).unwrap();
    }
 }

@@ -1,317 +1,592 @@
-use std::collections::HashMap;
-use std::collections::HashSet;
-
-use syntax::ast;
+use std::rc::Rc;
+use syntax::ast::{self, TokenTree};
 use syntax::attr;
+use syntax::codemap::Span;
 use syntax::ext::base::ExtCtxt;
-use syntax::print::pprust::meta_item_to_string;
+use syntax::fold::Folder;
+use syntax::parse::parser::{Parser, PathStyle};
+use syntax::parse::token::{self, InternedString};
+use syntax::parse;
+use syntax::print::pprust::{lit_to_string, meta_item_to_string};
 use syntax::ptr::P;

-use aster;
+use aster::AstBuilder;
+
+use error::Error;

-/// Represents field name information
 #[derive(Debug)]
-pub enum FieldNames {
-    Global(P<ast::Expr>),
-    Format{
-        formats: HashMap<P<ast::Expr>, P<ast::Expr>>,
-        default: P<ast::Expr>,
+pub struct Name {
+    ident: ast::Ident,
+    serialize_name: Option<InternedString>,
+    deserialize_name: Option<InternedString>,
+}
+
+impl Name {
+    fn new(ident: ast::Ident) -> Self {
+        Name {
+            ident: ident,
+            serialize_name: None,
+            deserialize_name: None,
+        }
+    }
+
+    /// Return the container name for the container when serializing.
+    pub fn serialize_name(&self) -> InternedString {
+        match self.serialize_name {
+            Some(ref name) => name.clone(),
+            None => self.ident.name.as_str(),
+        }
+    }
+
+    /// Return the container name expression for the container when deserializing.
+    pub fn serialize_name_expr(&self) -> P<ast::Expr> {
+        AstBuilder::new().expr().str(self.serialize_name())
+    }
+
+    /// Return the container name for the container when deserializing.
+    pub fn deserialize_name(&self) -> InternedString {
+        match self.deserialize_name {
+            Some(ref name) => name.clone(),
+            None => self.ident.name.as_str(),
+        }
+    }
+
+    /// Return the container name expression for the container when deserializing.
+    pub fn deserialize_name_expr(&self) -> P<ast::Expr> {
+        AstBuilder::new().expr().str(self.deserialize_name())
+    }
+}
+
+/// Represents container (e.g. struct) attribute information
+#[derive(Debug)]
+pub struct ContainerAttrs {
+    name: Name,
+    deny_unknown_fields: bool,
+    ser_bound: Option<Vec<ast::WherePredicate>>,
+    de_bound: Option<Vec<ast::WherePredicate>>,
+}
+
+impl ContainerAttrs {
+    /// Extract out the `#[serde(...)]` attributes from an item.
+    pub fn from_item(cx: &ExtCtxt, item: &ast::Item) -> Result<Self, Error> {
+        let mut container_attrs = ContainerAttrs {
+            name: Name::new(item.ident),
+            deny_unknown_fields: false,
+            ser_bound: None,
+            de_bound: None,
+        };
+
+        for meta_items in item.attrs().iter().filter_map(get_serde_meta_items) {
+            for meta_item in meta_items {
+                match meta_item.node {
+                    // Parse `#[serde(rename="foo")]`
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"rename" => {
+                        let s = try!(get_str_from_lit(cx, name, lit));
+                        container_attrs.name.serialize_name = Some(s.clone());
+                        container_attrs.name.deserialize_name = Some(s);
+                    }
+
+                    // Parse `#[serde(rename(serialize="foo", deserialize="bar"))]`
+                    ast::MetaItemKind::List(ref name, ref meta_items) if name == &"rename" => {
+                        let (ser_name, de_name) = try!(get_renames(cx, meta_items));
+                        if ser_name.is_some() {
+                            container_attrs.name.serialize_name = ser_name;
+                        }
+                        if de_name.is_some() {
+                            container_attrs.name.deserialize_name = de_name;
+                        }
+                    }
+
+                    // Parse `#[serde(deny_unknown_fields)]`
+                    ast::MetaItemKind::Word(ref name) if name == &"deny_unknown_fields" => {
+                        container_attrs.deny_unknown_fields = true;
+                    }
+
+                    // Parse `#[serde(bound="D: Serialize")]`
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"bound" => {
+                        let where_predicates = try!(parse_lit_into_where(cx, name, lit));
+                        container_attrs.ser_bound = Some(where_predicates.clone());
+                        container_attrs.de_bound = Some(where_predicates);
+                    }
+
+                    // Parse `#[serde(bound(serialize="D: Serialize", deserialize="D: Deserialize"))]`
+                    ast::MetaItemKind::List(ref name, ref meta_items) if name == &"bound" => {
+                        let (ser_bound, de_bound) = try!(get_where_predicates(cx, meta_items));
+                        if ser_bound.is_some() {
+                            container_attrs.ser_bound = ser_bound;
+                        }
+                        if de_bound.is_some() {
+                            container_attrs.de_bound = de_bound;
+                        }
+                    }
+
+                    _ => {
+                        cx.span_err(
+                            meta_item.span,
+                            &format!("unknown serde container attribute `{}`",
+                                     meta_item_to_string(meta_item)));
+
+                        return Err(Error);
+                    }
+                }
+            }
+        }
+
+        Ok(container_attrs)
+    }
+
+    pub fn name(&self) -> &Name {
+        &self.name
+    }
+
+    pub fn deny_unknown_fields(&self) -> bool {
+        self.deny_unknown_fields
+    }
+
+    pub fn ser_bound(&self) -> Option<&[ast::WherePredicate]> {
+        self.ser_bound.as_ref().map(|vec| &vec[..])
+    }
+
+    pub fn de_bound(&self) -> Option<&[ast::WherePredicate]> {
+        self.de_bound.as_ref().map(|vec| &vec[..])
+    }
+}
+
+/// Represents variant attribute information
+#[derive(Debug)]
+pub struct VariantAttrs {
+    name: Name,
+}
+
+impl VariantAttrs {
+    pub fn from_variant(cx: &ExtCtxt, variant: &ast::Variant) -> Result<Self, Error> {
+        let mut variant_attrs = VariantAttrs {
+            name: Name::new(variant.node.name),
+        };
+
+        for meta_items in variant.node.attrs.iter().filter_map(get_serde_meta_items) {
+            for meta_item in meta_items {
+                match meta_item.node {
+                    // Parse `#[serde(rename="foo")]`
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"rename" => {
+                        let s = try!(get_str_from_lit(cx, name, lit));
+                        variant_attrs.name.serialize_name = Some(s.clone());
+                        variant_attrs.name.deserialize_name = Some(s);
+                    }
+
+                    // Parse `#[serde(rename(serialize="foo", deserialize="bar"))]`
+                    ast::MetaItemKind::List(ref name, ref meta_items) if name == &"rename" => {
+                        let (ser_name, de_name) = try!(get_renames(cx, meta_items));
+                        if ser_name.is_some() {
+                            variant_attrs.name.serialize_name = ser_name;
+                        }
+                        if de_name.is_some() {
+                            variant_attrs.name.deserialize_name = de_name;
+                        }
+                    }
+
+                    _ => {
+                        cx.span_err(
+                            meta_item.span,
+                            &format!("unknown serde variant attribute `{}`",
+                                     meta_item_to_string(meta_item)));
+
+                        return Err(Error);
+                    }
+                }
+            }
+        }
+
+        Ok(variant_attrs)
+    }
+
+    pub fn name(&self) -> &Name {
+        &self.name
    }
 }

 /// Represents field attribute information
 #[derive(Debug)]
 pub struct FieldAttrs {
+    name: Name,
    skip_serializing_field: bool,
-    skip_serializing_field_if_empty: bool,
-    skip_serializing_field_if_none: bool,
-    names: FieldNames,
-    use_default: bool,
+    skip_deserializing_field: bool,
+    skip_serializing_if: Option<ast::Path>,
+    default: FieldDefault,
+    serialize_with: Option<ast::Path>,
+    deserialize_with: Option<ast::Path>,
+    ser_bound: Option<Vec<ast::WherePredicate>>,
+    de_bound: Option<Vec<ast::WherePredicate>>,
+}
+
+/// Represents the default to use for a field when deserializing.
+#[derive(Debug, PartialEq)]
+pub enum FieldDefault {
+    /// Field must always be specified because it does not have a default.
+    None,
+    /// The default is given by `std::default::Default::default()`.
+    Default,
+    /// The default is given by this function.
+    Path(ast::Path),
 }

 impl FieldAttrs {
-    /// 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, .. } => {
-                let mut set = HashSet::new();
-                for (fmt, _) in formats.iter() {
-                    set.insert(fmt.clone());
-                };
-                set
-            },
-            _ => HashSet::new()
-        }
-    }
+    /// Extract out the `#[serde(...)]` attributes from a struct field.
+    pub fn from_field(cx: &ExtCtxt,
+                      index: usize,
+                      field: &ast::StructField) -> Result<Self, Error> {
+        let builder = AstBuilder::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(ref name) => name.clone(),
-            FieldNames::Format { ref formats, ref default } => {
-                let arms = formats.iter()
-                    .map(|(fmt, lit)| {
-                        quote_arm!(cx, $fmt => { $lit })
-                    })
-                    .collect::<Vec<_>>();
-                quote_expr!(cx,
-                    match S::format() {
-                        $arms
-                        _ => { $default }
+        let field_ident = match field.ident {
+            Some(ident) => ident,
+            None => builder.id(index.to_string()),
+        };
+
+        let mut field_attrs = FieldAttrs {
+            name: Name::new(field_ident),
+            skip_serializing_field: false,
+            skip_deserializing_field: false,
+            skip_serializing_if: None,
+            default: FieldDefault::None,
+            serialize_with: None,
+            deserialize_with: None,
+            ser_bound: None,
+            de_bound: None,
+        };
+
+        for meta_items in field.attrs.iter().filter_map(get_serde_meta_items) {
+            for meta_item in meta_items {
+                match meta_item.node {
+                    // Parse `#[serde(rename="foo")]`
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"rename" => {
+                        let s = try!(get_str_from_lit(cx, name, lit));
+                        field_attrs.name.serialize_name = Some(s.clone());
+                        field_attrs.name.deserialize_name = Some(s);
                    }
-                )
-            },
-        }
-    }

-    /// 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 { ref default, .. } => default,
-        }
-    }
+                    // Parse `#[serde(rename(serialize="foo", deserialize="bar"))]`
+                    ast::MetaItemKind::List(ref name, ref meta_items) if name == &"rename" => {
+                        let (ser_name, de_name) = try!(get_renames(cx, meta_items));
+                        if ser_name.is_some() {
+                            field_attrs.name.serialize_name = ser_name;
+                        }
+                        if de_name.is_some() {
+                            field_attrs.name.deserialize_name = de_name;
+                        }
+                    }

-    /// 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)
+                    // Parse `#[serde(default)]`
+                    ast::MetaItemKind::Word(ref name) if name == &"default" => {
+                        field_attrs.default = FieldDefault::Default;
+                    }
+
+                    // Parse `#[serde(default="...")]`
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"default" => {
+                        let path = try!(parse_lit_into_path(cx, name, lit));
+                        field_attrs.default = FieldDefault::Path(path);
+                    }
+
+                    // Parse `#[serde(skip_serializing)]`
+                    ast::MetaItemKind::Word(ref name) if name == &"skip_serializing" => {
+                        field_attrs.skip_serializing_field = true;
+                    }
+
+                    // Parse `#[serde(skip_deserializing)]`
+                    ast::MetaItemKind::Word(ref name) if name == &"skip_deserializing" => {
+                        field_attrs.skip_deserializing_field = true;
+
+                        // Initialize field to Default::default() unless a different
+                        // default is specified by `#[serde(default="...")]`
+                        if field_attrs.default == FieldDefault::None {
+                            field_attrs.default = FieldDefault::Default;
+                        }
+                    }
+
+                    // Parse `#[serde(skip_serializing_if="...")]`
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"skip_serializing_if" => {
+                        let path = try!(parse_lit_into_path(cx, name, lit));
+                        field_attrs.skip_serializing_if = Some(path);
+                    }
+
+                    // Parse `#[serde(serialize_with="...")]`
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"serialize_with" => {
+                        let path = try!(parse_lit_into_path(cx, name, lit));
+                        field_attrs.serialize_with = Some(path);
+                    }
+
+                    // Parse `#[serde(deserialize_with="...")]`
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"deserialize_with" => {
+                        let path = try!(parse_lit_into_path(cx, name, lit));
+                        field_attrs.deserialize_with = Some(path);
+                    }
+
+                    // Parse `#[serde(bound="D: Serialize")]`
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"bound" => {
+                        let where_predicates = try!(parse_lit_into_where(cx, name, lit));
+                        field_attrs.ser_bound = Some(where_predicates.clone());
+                        field_attrs.de_bound = Some(where_predicates);
+                    }
+
+                    // Parse `#[serde(bound(serialize="D: Serialize", deserialize="D: Deserialize"))]`
+                    ast::MetaItemKind::List(ref name, ref meta_items) if name == &"bound" => {
+                        let (ser_bound, de_bound) = try!(get_where_predicates(cx, meta_items));
+                        if ser_bound.is_some() {
+                            field_attrs.ser_bound = ser_bound;
+                        }
+                        if de_bound.is_some() {
+                            field_attrs.de_bound = de_bound;
+                        }
+                    }
+
+                    _ => {
+                        cx.span_err(
+                            meta_item.span,
+                            &format!("unknown serde field attribute `{}`",
+                                     meta_item_to_string(meta_item)));
+
+                        return Err(Error);
+                    }
+                }
            }
        }
+
+        Ok(field_attrs)
    }

-    /// Predicate for using a field's default value
-    pub fn use_default(&self) -> bool {
-        self.use_default
+    pub fn name(&self) -> &Name {
+        &self.name
    }

-    /// Predicate for ignoring a field when serializing a value
    pub fn skip_serializing_field(&self) -> bool {
        self.skip_serializing_field
    }

-    pub fn skip_serializing_field_if_empty(&self) -> bool {
-        self.skip_serializing_field_if_empty
+    pub fn skip_deserializing_field(&self) -> bool {
+        self.skip_deserializing_field
    }

-    pub fn skip_serializing_field_if_none(&self) -> bool {
-        self.skip_serializing_field_if_none
+    pub fn skip_serializing_if(&self) -> Option<&ast::Path> {
+        self.skip_serializing_if.as_ref()
+    }
+
+    pub fn default(&self) -> &FieldDefault {
+        &self.default
+    }
+
+    pub fn serialize_with(&self) -> Option<&ast::Path> {
+        self.serialize_with.as_ref()
+    }
+
+    pub fn deserialize_with(&self) -> Option<&ast::Path> {
+        self.deserialize_with.as_ref()
+    }
+
+    pub fn ser_bound(&self) -> Option<&[ast::WherePredicate]> {
+        self.ser_bound.as_ref().map(|vec| &vec[..])
+    }
+
+    pub fn de_bound(&self) -> Option<&[ast::WherePredicate]> {
+        self.de_bound.as_ref().map(|vec| &vec[..])
    }
 }

-pub struct FieldAttrsBuilder<'a> {
-    cx: &'a ExtCtxt<'a>,
-    builder: &'a aster::AstBuilder,
-    skip_serializing_field: bool,
-    skip_serializing_field_if_empty: bool,
-    skip_serializing_field_if_none: bool,
-    name: Option<P<ast::Expr>>,
-    format_rename: HashMap<P<ast::Expr>, P<ast::Expr>>,
-    use_default: bool,
+
+/// Zip together fields and `#[serde(...)]` attributes on those fields.
+pub fn fields_with_attrs(
+    cx: &ExtCtxt,
+    fields: &[ast::StructField],
+) -> Result<Vec<(ast::StructField, FieldAttrs)>, Error> {
+    fields.iter()
+        .enumerate()
+        .map(|(i, field)| {
+            let attrs = try!(FieldAttrs::from_field(cx, i, field));
+            Ok((field.clone(), attrs))
+        })
+        .collect()
 }

-impl<'a> FieldAttrsBuilder<'a> {
-    pub fn new(cx: &'a ExtCtxt<'a>,
-               builder: &'a aster::AstBuilder) -> FieldAttrsBuilder<'a> {
-        FieldAttrsBuilder {
-            cx: cx,
-            builder: builder,
-            skip_serializing_field: false,
-            skip_serializing_field_if_empty: false,
-            skip_serializing_field_if_none: false,
-            name: None,
-            format_rename: HashMap::new(),
-            use_default: false,
-        }
-    }
+fn get_ser_and_de<T, F>(
+    cx: &ExtCtxt,
+    attribute: &str,
+    items: &[P<ast::MetaItem>],
+    f: F
+) -> Result<(Option<T>, Option<T>), Error>
+    where F: Fn(&ExtCtxt, &str, &ast::Lit) -> Result<T, Error>,
+{
+    let mut ser_item = None;
+    let mut de_item = None;

-    pub fn field(mut self, field: &ast::StructField) -> Result<FieldAttrsBuilder<'a>, ()> {
-        match field.node.kind {
-            ast::NamedField(name, _) => {
-                self.name = Some(self.builder.expr().str(name));
+    for item in items {
+        match item.node {
+            ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"serialize" => {
+                let s = try!(f(cx, name, lit));
+                ser_item = Some(s);
            }
-            ast::UnnamedField(_) => { }
-        };

-        self.attrs(&field.node.attrs)
-    }
-
-    pub fn attrs(mut self, attrs: &[ast::Attribute]) -> Result<FieldAttrsBuilder<'a>, ()> {
-        for attr in attrs {
-            self = try!(self.attr(attr));
-        }
-
-        Ok(self)
-    }
-
-    pub fn attr(mut self, attr: &ast::Attribute) -> Result<FieldAttrsBuilder<'a>, ()> {
-        match attr.node.value.node {
-            ast::MetaList(ref name, ref items) if name == &"serde" => {
-                attr::mark_used(&attr);
-                for item in items {
-                    self = try!(self.meta_item(item));
-                }
-
-                Ok(self)
+            ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"deserialize" => {
+                let s = try!(f(cx, name, lit));
+                de_item = Some(s);
            }
+
            _ => {
-                Ok(self)
+                cx.span_err(
+                    item.span,
+                    &format!("unknown {} attribute `{}`",
+                             attribute,
+                             meta_item_to_string(item)));
+
+                return Err(Error);
            }
        }
    }

-    pub fn meta_item(mut self, meta_item: &P<ast::MetaItem>) -> Result<FieldAttrsBuilder<'a>, ()> {
-        match meta_item.node {
-            ast::MetaNameValue(ref name, ref lit) if name == &"rename" => {
-                let expr = self.builder.expr().build_lit(P(lit.clone()));
+    Ok((ser_item, de_item))
+}

-                Ok(self.name(expr))
-            }
-            ast::MetaList(ref name, ref items) if name == &"rename" => {
-                for item in items {
-                    match item.node {
-                        ast::MetaNameValue(ref name, ref lit) => {
-                            let name = self.builder.expr().str(name);
-                            let expr = self.builder.expr().build_lit(P(lit.clone()));
+fn get_renames(
+    cx: &ExtCtxt,
+    items: &[P<ast::MetaItem>],
+) -> Result<(Option<InternedString>, Option<InternedString>), Error> {
+    get_ser_and_de(cx, "rename", items, get_str_from_lit)
+}

-                            self = self.format_rename(name, expr);
-                        }
-                        _ => { }
-                    }
-                }
+fn get_where_predicates(
+    cx: &ExtCtxt,
+    items: &[P<ast::MetaItem>],
+) -> Result<(Option<Vec<ast::WherePredicate>>, Option<Vec<ast::WherePredicate>>), Error> {
+    get_ser_and_de(cx, "bound", items, parse_lit_into_where)
+}

-                Ok(self)
+pub fn get_serde_meta_items(attr: &ast::Attribute) -> Option<&[P<ast::MetaItem>]> {
+    match attr.node.value.node {
+        ast::MetaItemKind::List(ref name, ref items) if name == &"serde" => {
+            attr::mark_used(&attr);
+            Some(items)
+        }
+        _ => None
+    }
+}
+
+/// This syntax folder rewrites tokens to say their spans are coming from a macro context.
+struct Respanner<'a, 'b: 'a> {
+    cx: &'a ExtCtxt<'b>,
+}
+
+impl<'a, 'b> Folder for Respanner<'a, 'b> {
+    fn fold_tt(&mut self, tt: &TokenTree) -> TokenTree {
+        match *tt {
+            TokenTree::Token(span, ref tok) => {
+                TokenTree::Token(
+                    self.new_span(span),
+                    self.fold_token(tok.clone())
+                )
            }
-            ast::MetaWord(ref name) if name == &"default" => {
-                Ok(self.default())
+            TokenTree::Delimited(span, ref delimed) => {
+                TokenTree::Delimited(
+                    self.new_span(span),
+                    Rc::new(ast::Delimited {
+                        delim: delimed.delim,
+                        open_span: delimed.open_span,
+                        tts: self.fold_tts(&delimed.tts),
+                        close_span: delimed.close_span,
+                    })
+                )
            }
-            ast::MetaWord(ref name) if name == &"skip_serializing" => {
-                Ok(self.skip_serializing_field())
-            }
-            ast::MetaWord(ref name) if name == &"skip_serializing_if_empty" => {
-                Ok(self.skip_serializing_field_if_empty())
-            }
-            ast::MetaWord(ref name) if name == &"skip_serializing_if_none" => {
-                Ok(self.skip_serializing_field_if_none())
-            }
-            _ => {
-                self.cx.span_err(
-                    meta_item.span,
-                    &format!("unknown serde field attribute `{}`",
-                             meta_item_to_string(meta_item)));
-                Err(())
+            TokenTree::Sequence(span, ref seq) => {
+                TokenTree::Sequence(
+                    self.new_span(span),
+                    Rc::new(ast::SequenceRepetition {
+                        tts: self.fold_tts(&seq.tts),
+                        separator: seq.separator.clone().map(|tok| self.fold_token(tok)),
+                        ..**seq
+                    })
+                )
            }
        }
    }

-    pub fn skip_serializing_field(mut self) -> FieldAttrsBuilder<'a> {
-        self.skip_serializing_field = true;
-        self
-    }
-
-    pub fn skip_serializing_field_if_empty(mut self) -> FieldAttrsBuilder<'a> {
-        self.skip_serializing_field_if_empty = true;
-        self
-    }
-
-    pub fn skip_serializing_field_if_none(mut self) -> FieldAttrsBuilder<'a> {
-        self.skip_serializing_field_if_none = true;
-        self
-    }
-
-    pub fn name(mut self, name: P<ast::Expr>) -> FieldAttrsBuilder<'a> {
-        self.name = Some(name);
-        self
-    }
-
-    pub fn format_rename(mut self, format: P<ast::Expr>, name: P<ast::Expr>) -> FieldAttrsBuilder<'a> {
-        self.format_rename.insert(format, name);
-        self
-    }
-
-    pub fn default(mut self) -> FieldAttrsBuilder<'a> {
-        self.use_default = true;
-        self
-    }
-
-    pub fn build(self) -> FieldAttrs {
-        let name = self.name.expect("here");
-        let names = if self.format_rename.is_empty() {
-            FieldNames::Global(name)
-        } else {
-            FieldNames::Format {
-                formats: self.format_rename,
-                default: name,
-            }
-        };
-
-        FieldAttrs {
-            skip_serializing_field: self.skip_serializing_field,
-            skip_serializing_field_if_empty: self.skip_serializing_field_if_empty,
-            skip_serializing_field_if_none: self.skip_serializing_field_if_none,
-            names: names,
-            use_default: self.use_default,
+    fn new_span(&mut self, span: Span) -> Span {
+        Span {
+            lo: span.lo,
+            hi: span.hi,
+            expn_id: self.cx.backtrace(),
        }
    }
 }

-/// Represents container (e.g. struct) attribute information
-#[derive(Debug)]
-pub struct ContainerAttrs;
+fn get_str_from_lit(cx: &ExtCtxt, name: &str, lit: &ast::Lit) -> Result<InternedString, Error> {
+    match lit.node {
+        ast::LitKind::Str(ref s, _) => Ok(s.clone()),
+        _ => {
+            cx.span_err(
+                lit.span,
+                &format!("serde annotation `{}` must be a string, not `{}`",
+                         name,
+                         lit_to_string(lit)));

-pub struct ContainerAttrsBuilder<'a> {
-    cx: &'a ExtCtxt<'a>,
+            return Err(Error);
+        }
+    }
 }

-impl<'a> ContainerAttrsBuilder<'a> {
-    pub fn new(cx: &'a ExtCtxt) -> Self {
-        ContainerAttrsBuilder {
-            cx: cx,
+// If we just parse a string literal from an attibute, any syntax errors in the
+// source will only have spans that point inside the string and not back to the
+// attribute. So to have better error reporting, we'll first parse the string
+// into a token tree. Then we'll update those spans to say they're coming from a
+// macro context that originally came from the attribnute, and then finally
+// parse them into an expression or where-clause.
+fn parse_string_via_tts<T, F>(cx: &ExtCtxt, name: &str, string: String, action: F) -> Result<T, Error>
+    where F: for<'a> Fn(&'a mut Parser) -> parse::PResult<'a, T>,
+{
+    let tts = panictry!(parse::parse_tts_from_source_str(
+        format!("<serde {} expansion>", name),
+        string,
+        cx.cfg(),
+        cx.parse_sess()));
+
+    // Respan the spans to say they are all coming from this macro.
+    let tts = Respanner { cx: cx }.fold_tts(&tts);
+
+    let mut parser = parse::new_parser_from_tts(cx.parse_sess(), cx.cfg(), tts);
+
+    let path = match action(&mut parser) {
+        Ok(path) => path,
+        Err(mut e) => {
+            e.emit();
+            return Err(Error);
+        }
+    };
+
+    // Make sure to error out if there are trailing characters in the stream.
+    match parser.expect(&token::Eof) {
+        Ok(()) => { }
+        Err(mut e) => {
+            e.emit();
+            return Err(Error);
        }
    }

-    pub fn attrs(mut self, attrs: &[ast::Attribute]) -> Result<Self, ()> {
-        for attr in attrs {
-            self = try!(self.attr(attr));
-        }
-
-        Ok(self)
-    }
-
-    pub fn attr(mut self, attr: &ast::Attribute) -> Result<Self, ()> {
-        match attr.node.value.node {
-            ast::MetaList(ref name, ref items) if name == &"serde" => {
-                attr::mark_used(&attr);
-                for item in items {
-                    self = try!(self.meta_item(item));
-                }
-
-                Ok(self)
-            }
-            _ => {
-                Ok(self)
-            }
-        }
-    }
-
-    pub fn meta_item(self, meta_item: &P<ast::MetaItem>) -> Result<Self, ()> {
-        match meta_item.node {
-            _ => {
-                self.cx.span_err(
-                    meta_item.span,
-                    &format!("unknown serde container attribute `{}`",
-                             meta_item_to_string(meta_item)));
-                Err(())
-            }
-        }
-    }
-
-    pub fn build(self) -> ContainerAttrs {
-        ContainerAttrs
-    }
+    Ok(path)
+}
+
+fn parse_lit_into_path(cx: &ExtCtxt, name: &str, lit: &ast::Lit) -> Result<ast::Path, Error> {
+    let string = try!(get_str_from_lit(cx, name, lit)).to_string();
+
+    parse_string_via_tts(cx, name, string, |parser| {
+        parser.parse_path(PathStyle::Type)
+    })
+}
+
+fn parse_lit_into_where(cx: &ExtCtxt, name: &str, lit: &ast::Lit) -> Result<Vec<ast::WherePredicate>, Error> {
+    let string = try!(get_str_from_lit(cx, name, lit));
+    if string.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let where_string = format!("where {}", string);
+
+    parse_string_via_tts(cx, name, where_string, |parser| {
+        let where_clause = try!(parser.parse_where_clause());
+        Ok(where_clause.predicates)
+    })
 }
@@ -0,0 +1,238 @@
+use std::collections::HashSet;
+
+use aster::AstBuilder;
+
+use syntax::ast;
+use syntax::ext::base::ExtCtxt;
+use syntax::ptr::P;
+use syntax::visit;
+
+use attr;
+use error::Error;
+
+// Remove the default from every type parameter because in the generated impls
+// they look like associated types: "error: associated type bindings are not
+// allowed here".
+pub fn without_defaults(generics: &ast::Generics) -> ast::Generics {
+    ast::Generics {
+        ty_params: generics.ty_params.iter().map(|ty_param| {
+            ast::TyParam {
+                default: None,
+                .. ty_param.clone()
+            }}).collect(),
+        .. generics.clone()
+    }
+}
+
+pub fn with_where_predicates(
+    builder: &AstBuilder,
+    generics: &ast::Generics,
+    predicates: &[ast::WherePredicate],
+) -> ast::Generics {
+    builder.from_generics(generics.clone())
+        .with_predicates(predicates.to_vec())
+        .build()
+}
+
+pub fn with_where_predicates_from_fields<F>(
+    cx: &ExtCtxt,
+    builder: &AstBuilder,
+    item: &ast::Item,
+    generics: &ast::Generics,
+    from_field: F,
+) -> Result<ast::Generics, Error>
+    where F: Fn(&attr::FieldAttrs) -> Option<&[ast::WherePredicate]>,
+{
+    Ok(builder.from_generics(generics.clone())
+        .with_predicates(
+            try!(all_fields_with_attrs(cx, item))
+                .iter()
+                .flat_map(|&(_, ref attrs)| from_field(attrs))
+                .flat_map(|predicates| predicates.to_vec()))
+        .build())
+}
+
+pub fn with_bound<F>(
+    cx: &ExtCtxt,
+    builder: &AstBuilder,
+    item: &ast::Item,
+    generics: &ast::Generics,
+    filter: F,
+    bound: &ast::Path,
+) -> Result<ast::Generics, Error>
+    where F: Fn(&attr::FieldAttrs) -> bool,
+{
+    Ok(builder.from_generics(generics.clone())
+        .with_predicates(
+            try!(all_fields_with_attrs(cx, item))
+                .iter()
+                .filter(|&&(_, ref attrs)| filter(attrs))
+                .map(|&(ref field, _)| &field.ty)
+                // TODO this filter can be removed later, see comment on function
+                .filter(|ty| contains_generic(ty, generics))
+                .filter(|ty| !contains_recursion(ty, item.ident))
+                .map(|ty| strip_reference(ty))
+                .map(|ty| builder.where_predicate()
+                    // the type that is being bounded e.g. T
+                    .bound().build(ty.clone())
+                    // the bound e.g. Serialize
+                    .bound().trait_(bound.clone()).build()
+                    .build()))
+        .build())
+}
+
+fn all_fields_with_attrs(
+    cx: &ExtCtxt,
+    item: &ast::Item,
+) -> Result<Vec<(ast::StructField, attr::FieldAttrs)>, Error> {
+    let fields: Vec<ast::StructField> =
+        all_variants(cx, item).iter()
+            .flat_map(|variant_data| all_struct_fields(variant_data))
+            .cloned()
+            .collect();
+
+    attr::fields_with_attrs(cx, &fields)
+}
+
+fn all_variants<'a>(cx: &ExtCtxt, item: &'a ast::Item) -> Vec<&'a ast::VariantData> {
+    match item.node {
+        ast::ItemKind::Struct(ref variant_data, _) => {
+            vec![variant_data]
+        }
+        ast::ItemKind::Enum(ref enum_def, _) => {
+            enum_def.variants.iter()
+                .map(|variant| &variant.node.data)
+                .collect()
+        }
+        _ => {
+            cx.span_bug(item.span, "expected Item to be Struct or Enum");
+        }
+    }
+}
+
+fn all_struct_fields(variant_data: &ast::VariantData) -> &[ast::StructField] {
+    match *variant_data {
+        ast::VariantData::Struct(ref fields, _) |
+        ast::VariantData::Tuple(ref fields, _) => {
+            fields
+        }
+        ast::VariantData::Unit(_) => {
+            &[]
+        }
+    }
+}
+
+// Rust <1.7 enforces that `where` clauses involve generic type parameters. The
+// corresponding compiler error is E0193. It is no longer enforced in Rust >=1.7
+// so this filtering can be removed in the future when we stop supporting <1.7.
+//
+// E0193 means we must not generate a `where` clause like `i32: Serialize`
+// because even though i32 implements Serialize, i32 is not a generic type
+// parameter. Clauses like `T: Serialize` and `Option<T>: Serialize` are okay.
+// This function decides whether a given type references any of the generic type
+// parameters in the input `Generics`.
+fn contains_generic(ty: &ast::Ty, generics: &ast::Generics) -> bool {
+    struct FindGeneric<'a> {
+        generic_names: &'a HashSet<ast::Name>,
+        found_generic: bool,
+    }
+    impl<'a, 'v> visit::Visitor<'v> for FindGeneric<'a> {
+        fn visit_path(&mut self, path: &'v ast::Path, _id: ast::NodeId) {
+            if !path.global
+                    && path.segments.len() == 1
+                    && self.generic_names.contains(&path.segments[0].identifier.name) {
+                self.found_generic = true;
+            } else {
+                visit::walk_path(self, path);
+            }
+        }
+    }
+
+    let generic_names: HashSet<_> = generics.ty_params.iter()
+        .map(|ty_param| ty_param.ident.name)
+        .collect();
+
+    let mut visitor = FindGeneric {
+        generic_names: &generic_names,
+        found_generic: false,
+    };
+    visit::walk_ty(&mut visitor, ty);
+    visitor.found_generic
+}
+
+// We do not attempt to generate any bounds based on field types that are
+// directly recursive, as in:
+//
+//    struct Test<D> {
+//        next: Box<Test<D>>,
+//    }
+//
+// This does not catch field types that are mutually recursive with some other
+// type. For those, we require bounds to be specified by a `bound` attribute if
+// the inferred ones are not correct.
+//
+//    struct Test<D> {
+//        #[serde(bound="D: Serialize + Deserialize")]
+//        next: Box<Other<D>>,
+//    }
+//    struct Other<D> {
+//        #[serde(bound="D: Serialize + Deserialize")]
+//        next: Box<Test<D>>,
+//    }
+fn contains_recursion(ty: &ast::Ty, ident: ast::Ident) -> bool {
+    struct FindRecursion {
+        ident: ast::Ident,
+        found_recursion: bool,
+    }
+    impl<'v> visit::Visitor<'v> for FindRecursion {
+        fn visit_path(&mut self, path: &'v ast::Path, _id: ast::NodeId) {
+            if !path.global
+                    && path.segments.len() == 1
+                    && path.segments[0].identifier == self.ident {
+                self.found_recursion = true;
+            } else {
+                visit::walk_path(self, path);
+            }
+        }
+    }
+
+    let mut visitor = FindRecursion {
+        ident: ident,
+        found_recursion: false,
+    };
+    visit::walk_ty(&mut visitor, ty);
+    visitor.found_recursion
+}
+
+// This is required to handle types that use both a reference and a value of
+// the same type, as in:
+//
+//    enum Test<'a, T> where T: 'a {
+//        Lifetime(&'a T),
+//        NoLifetime(T),
+//    }
+//
+// Preserving references, we would generate an impl like:
+//
+//    impl<'a, T> Serialize for Test<'a, T>
+//        where &'a T: Serialize,
+//              T: Serialize { ... }
+//
+// And taking a reference to one of the elements would fail with:
+//
+//    error: cannot infer an appropriate lifetime for pattern due
+//    to conflicting requirements [E0495]
+//        Test::NoLifetime(ref v) => { ... }
+//                         ^~~~~
+//
+// Instead, we strip references before adding `T: Serialize` bounds in order to
+// generate:
+//
+//    impl<'a, T> Serialize for Test<'a, T>
+//        where T: Serialize { ... }
+fn strip_reference(mut ty: &P<ast::Ty>) -> &P<ast::Ty> {
+    while let ast::TyKind::Rptr(_, ref mut_ty) = ty.node {
+        ty = &mut_ty.ty;
+    }
+    ty
+}
@@ -0,0 +1,2 @@
+/// Error returned if failed to parse attribute.
+pub struct Error;
@@ -1,30 +0,0 @@
-use syntax::ast;
-use syntax::ext::base::ExtCtxt;
-
-use aster;
-use attr;
-
-pub fn struct_field_attrs(
-    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    fields: &[ast::StructField],
-) -> Result<Vec<attr::FieldAttrs>, ()> {
-    let mut attrs = vec![];
-    for field in fields {
-        let builder = attr::FieldAttrsBuilder::new(cx, builder);
-        let builder = try!(builder.field(field));
-        let attr = builder.build();
-        attrs.push(attr);
-    }
-
-    Ok(attrs)
-}
-
-pub fn container_attrs(
-    cx: &ExtCtxt,
-    container: &ast::Item,
-) -> Result<attr::ContainerAttrs, ()> {
-    let builder = attr::ContainerAttrsBuilder::new(cx);
-    let builder = try!(builder.attrs(container.attrs()));
-    Ok(builder.build())
-}
@@ -1,5 +1,7 @@
-#![cfg_attr(feature = "nightly", plugin(clippy))]
-#![cfg_attr(feature = "nightly", allow(used_underscore_binding))]
+#![cfg_attr(feature = "nightly-testing", plugin(clippy))]
+#![cfg_attr(feature = "nightly-testing", feature(plugin))]
+#![cfg_attr(feature = "nightly-testing", allow(too_many_arguments))]
+#![cfg_attr(feature = "nightly-testing", allow(used_underscore_binding))]
 #![cfg_attr(not(feature = "with-syntex"), feature(rustc_private, plugin))]
 #![cfg_attr(not(feature = "with-syntex"), plugin(quasi_macros))]

@@ -10,14 +12,21 @@ extern crate quasi;
 extern crate syntex;

 #[cfg(feature = "with-syntex")]
+#[macro_use]
 extern crate syntex_syntax as syntax;

 #[cfg(not(feature = "with-syntex"))]
+#[macro_use]
 extern crate syntax;

 #[cfg(not(feature = "with-syntex"))]
 extern crate rustc_plugin;

+#[cfg(feature = "with-syntex")]
+use std::io;
+#[cfg(feature = "with-syntex")]
+use std::path::Path;
+
 #[cfg(not(feature = "with-syntex"))]
 use syntax::feature_gate::AttributeType;

@@ -27,18 +36,20 @@ include!(concat!(env!("OUT_DIR"), "/lib.rs"));
 #[cfg(not(feature = "with-syntex"))]
 include!("lib.rs.in");

+#[cfg(feature = "with-syntex")]
+pub fn expand<S, D>(src: S, dst: D) -> io::Result<()>
+    where S: AsRef<Path>,
+          D: AsRef<Path>,
+{
+    let mut registry = syntex::Registry::new();
+    register(&mut registry);
+    registry.expand("", src.as_ref(), dst.as_ref())
+}
+
 #[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 {
@@ -48,7 +59,7 @@ pub fn register(reg: &mut syntex::Registry) {
        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; }
+                    ast::MetaItemKind::List(ref n, _) if n == &"serde" => { return None; }
                    _ => {}
                }

@@ -62,6 +73,14 @@ pub fn register(reg: &mut syntex::Registry) {

        fold::Folder::fold_crate(&mut StripAttributeFolder, krate)
    }
+
+    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);
 }

 #[cfg(not(feature = "with-syntex"))]
@@ -1,4 +1,5 @@
 mod attr;
+mod bound;
 mod de;
-mod field;
+mod error;
 mod ser;
@@ -8,10 +8,11 @@ use syntax::ast::{
 use syntax::ast;
 use syntax::codemap::Span;
 use syntax::ext::base::{Annotatable, ExtCtxt};
-use syntax::ext::build::AstBuilder;
 use syntax::ptr::P;

-use field;
+use attr;
+use bound;
+use error::Error;

 pub fn expand_derive_serialize(
    cx: &mut ExtCtxt,
@@ -32,48 +33,105 @@ pub fn expand_derive_serialize(

    let builder = aster::AstBuilder::new().span(span);

-    let generics = match item.node {
-        ast::ItemStruct(_, ref generics) => generics,
-        ast::ItemEnum(_, ref generics) => generics,
-        _ => {
-            cx.span_err(
-                meta_item.span,
-                "`#[derive(Serialize)]` may only be applied to structs and enums");
-            return;
-        }
-    };
-
-    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 = match serialize_body(cx, &builder, &item, &impl_generics, ty.clone()) {
-        Ok(body) => body,
-        Err(()) => {
+    let impl_item = match serialize_item(cx, &builder, &item) {
+        Ok(item) => item,
+        Err(Error) => {
            // An error occured, but it should have been reported already.
            return;
        }
    };

+    push(Annotatable::Item(impl_item))
+}
+
+fn serialize_item(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    item: &Item,
+) -> Result<P<ast::Item>, Error> {
+    let generics = match item.node {
+        ast::ItemKind::Struct(_, ref generics) => generics,
+        ast::ItemKind::Enum(_, ref generics) => generics,
+        _ => {
+            cx.span_err(
+                item.span,
+                "`#[derive(Serialize)]` may only be applied to structs and enums");
+            return Err(Error);
+        }
+    };
+
+    let container_attrs = try!(attr::ContainerAttrs::from_item(cx, item));
+
+    let impl_generics = try!(build_impl_generics(cx, builder, item, generics, &container_attrs));
+
+    let ty = builder.ty().path()
+        .segment(item.ident).with_generics(impl_generics.clone()).build()
+        .build();
+
+    let body = try!(serialize_body(cx,
+                                   &builder,
+                                   &item,
+                                   &impl_generics,
+                                   ty.clone(),
+                                   &container_attrs));
+
    let where_clause = &impl_generics.where_clause;

-    let impl_item = quote_item!(cx,
-        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();
+    let dummy_const = builder.id(format!("_IMPL_SERIALIZE_FOR_{}", item.ident));

-    push(Annotatable::Item(impl_item))
+    Ok(quote_item!(cx,
+        #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
+        const $dummy_const: () = {
+            extern crate serde as _serde;
+            #[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())
+}
+
+// All the generics in the input, plus a bound `T: Serialize` for each generic
+// field type that will be serialized by us.
+fn build_impl_generics(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    item: &Item,
+    generics: &ast::Generics,
+    container_attrs: &attr::ContainerAttrs,
+) -> Result<ast::Generics, Error> {
+    let generics = bound::without_defaults(generics);
+
+    let generics = try!(bound::with_where_predicates_from_fields(
+        cx, builder, item, &generics,
+        |attrs| attrs.ser_bound()));
+
+    match container_attrs.ser_bound() {
+        Some(predicates) => {
+            let generics = bound::with_where_predicates(builder, &generics, predicates);
+            Ok(generics)
+        }
+        None => {
+            let generics = try!(bound::with_bound(cx, builder, item, &generics,
+                needs_serialize_bound,
+                &builder.path().ids(&["_serde", "ser", "Serialize"]).build()));
+            Ok(generics)
+        }
+    }
+}
+
+// Fields with a `skip_serializing` or `serialize_with` attribute are not
+// serialized by us so we do not generate a bound. Fields with a `bound`
+// attribute specify their own bound so we do not generate one. All other fields
+// may need a `T: Serialize` bound where T is the type of the field.
+fn needs_serialize_bound(attrs: &attr::FieldAttrs) -> bool {
+    !attrs.skip_serializing_field()
+        && attrs.serialize_with().is_none()
+        && attrs.ser_bound().is_none()
 }

 fn serialize_body(
@@ -82,24 +140,21 @@ fn serialize_body(
    item: &Item,
    impl_generics: &ast::Generics,
    ty: P<ast::Ty>,
-) -> Result<P<ast::Expr>, ()> {
-    // Note: While we don't have any container attributes, we still want to try to
-    // parse them so we can report a proper error if we get passed an unknown attribute.
-    let _ = try!(field::container_attrs(cx, item));
-
+    container_attrs: &attr::ContainerAttrs,
+) -> Result<P<ast::Expr>, Error> {
    match item.node {
-        ast::ItemStruct(ref variant_data, _) => {
+        ast::ItemKind::Struct(ref variant_data, _) => {
            serialize_item_struct(
                cx,
                builder,
-                item,
                impl_generics,
                ty,
                item.span,
                variant_data,
+                container_attrs,
            )
        }
-        ast::ItemEnum(ref enum_def, _) => {
+        ast::ItemKind::Enum(ref enum_def, _) => {
            serialize_item_enum(
                cx,
                builder,
@@ -107,6 +162,7 @@ fn serialize_body(
                impl_generics,
                ty,
                enum_def,
+                container_attrs,
            )
        }
        _ => {
@@ -119,53 +175,55 @@ fn serialize_body(
 fn serialize_item_struct(
    cx: &ExtCtxt,
    builder: &aster::AstBuilder,
-    item: &Item,
    impl_generics: &ast::Generics,
    ty: P<ast::Ty>,
    span: Span,
    variant_data: &ast::VariantData,
-) -> Result<P<ast::Expr>, ()> {
+    container_attrs: &attr::ContainerAttrs,
+) -> Result<P<ast::Expr>, Error> {
    match *variant_data {
        ast::VariantData::Unit(_) => {
            serialize_unit_struct(
                cx,
-                &builder,
-                item.ident,
+                container_attrs,
            )
        }
        ast::VariantData::Tuple(ref fields, _) if fields.len() == 1 => {
            serialize_newtype_struct(
                cx,
                &builder,
-                item.ident,
+                impl_generics,
+                ty,
+                &fields[0],
+                container_attrs,
            )
        }
        ast::VariantData::Tuple(ref fields, _) => {
-            if fields.iter().any(|field| !field.node.kind.is_unnamed()) {
+            if fields.iter().any(|field| field.ident.is_some()) {
                cx.span_bug(span, "tuple struct has named fields")
            }

            serialize_tuple_struct(
                cx,
                &builder,
-                item.ident,
                impl_generics,
                ty,
-                fields.len(),
+                fields,
+                container_attrs,
            )
        }
        ast::VariantData::Struct(ref fields, _) => {
-            if fields.iter().any(|field| field.node.kind.is_unnamed()) {
+            if fields.iter().any(|field| field.ident.is_none()) {
                cx.span_bug(span, "struct has unnamed fields")
            }

            serialize_struct(
                cx,
                &builder,
-                item.ident,
                impl_generics,
                ty,
                fields,
+                container_attrs,
            )
        }
    }
@@ -173,37 +231,47 @@ fn serialize_item_struct(

 fn serialize_unit_struct(
    cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    type_ident: Ident
-) -> Result<P<ast::Expr>, ()> {
-    let type_name = builder.expr().str(type_ident);
+    container_attrs: &attr::ContainerAttrs,
+) -> Result<P<ast::Expr>, Error> {
+    let type_name = container_attrs.name().serialize_name_expr();

    Ok(quote_expr!(cx,
-        serializer.visit_unit_struct($type_name)
+        _serializer.serialize_unit_struct($type_name)
    ))
 }

 fn serialize_newtype_struct(
    cx: &ExtCtxt,
    builder: &aster::AstBuilder,
-    type_ident: Ident
-) -> Result<P<ast::Expr>, ()> {
-    let type_name = builder.expr().str(type_ident);
+    impl_generics: &ast::Generics,
+    container_ty: P<ast::Ty>,
+    field: &ast::StructField,
+    container_attrs: &attr::ContainerAttrs,
+) -> Result<P<ast::Expr>, Error> {
+    let type_name = container_attrs.name().serialize_name_expr();
+
+    let attrs = try!(attr::FieldAttrs::from_field(cx, 0, field));
+
+    let mut field_expr = quote_expr!(cx, &self.0);
+    if let Some(path) = attrs.serialize_with() {
+        field_expr = wrap_serialize_with(cx, builder,
+            &container_ty, impl_generics, &field.ty, path, field_expr);
+    }

    Ok(quote_expr!(cx,
-        serializer.visit_newtype_struct($type_name, &self.0)
+        _serializer.serialize_newtype_struct($type_name, $field_expr)
    ))
 }

 fn serialize_tuple_struct(
    cx: &ExtCtxt,
    builder: &aster::AstBuilder,
-    type_ident: Ident,
    impl_generics: &ast::Generics,
    ty: P<ast::Ty>,
-    fields: usize,
-) -> Result<P<ast::Expr>, ()> {
-    let (visitor_struct, visitor_impl) = serialize_tuple_struct_visitor(
+    fields: &[ast::StructField],
+    container_attrs: &attr::ContainerAttrs,
+) -> Result<P<ast::Expr>, Error> {
+    let (visitor_struct, visitor_impl) = try!(serialize_tuple_struct_visitor(
        cx,
        builder,
        ty.clone(),
@@ -211,16 +279,18 @@ fn serialize_tuple_struct(
            .ref_()
            .lifetime("'__a")
            .build_ty(ty.clone()),
+        builder.id("serialize_tuple_struct_elt"),
        fields,
        impl_generics,
-    );
+        false,
+    ));

-    let type_name = builder.expr().str(type_ident);
+    let type_name = container_attrs.name().serialize_name_expr();

    Ok(quote_expr!(cx, {
        $visitor_struct
        $visitor_impl
-        serializer.visit_tuple_struct($type_name, Visitor {
+        _serializer.serialize_tuple_struct($type_name, Visitor {
            value: self,
            state: 0,
            _structure_ty: ::std::marker::PhantomData::<&$ty>,
@@ -231,16 +301,11 @@ fn serialize_tuple_struct(
 fn serialize_struct(
    cx: &ExtCtxt,
    builder: &aster::AstBuilder,
-    type_ident: Ident,
    impl_generics: &ast::Generics,
    ty: P<ast::Ty>,
    fields: &[ast::StructField],
-) -> Result<P<ast::Expr>, ()> {
-    let value_exprs = fields.iter().map(|field| {
-        let name = field.node.ident().expect("struct has unnamed field");
-        quote_expr!(cx, &self.value.$name)
-    });
-
+    container_attrs: &attr::ContainerAttrs,
+) -> Result<P<ast::Expr>, Error> {
    let (visitor_struct, visitor_impl) = try!(serialize_struct_visitor(
        cx,
        builder,
@@ -249,17 +314,18 @@ fn serialize_struct(
            .ref_()
            .lifetime("'__a")
            .build_ty(ty.clone()),
+        builder.id("serialize_struct_elt"),
        fields,
        impl_generics,
-        value_exprs,
+        false,
    ));

-    let type_name = builder.expr().str(type_ident);
+    let type_name = container_attrs.name().serialize_name_expr();

    Ok(quote_expr!(cx, {
        $visitor_struct
        $visitor_impl
-        serializer.visit_struct($type_name, Visitor {
+        _serializer.serialize_struct($type_name, Visitor {
            value: self,
            state: 0,
            _structure_ty: ::std::marker::PhantomData::<&$ty>,
@@ -274,22 +340,25 @@ fn serialize_item_enum(
    impl_generics: &ast::Generics,
    ty: P<ast::Ty>,
    enum_def: &ast::EnumDef,
-) -> Result<P<ast::Expr>, ()> {
-    let mut arms = vec![];
-
-    for (variant_index, variant) in enum_def.variants.iter().enumerate() {
-        let arm = try!(serialize_variant(
-            cx,
-            builder,
-            type_ident,
-            impl_generics,
-            ty.clone(),
-            variant,
-            variant_index,
-        ));
-
-        arms.push(arm);
-    }
+    container_attrs: &attr::ContainerAttrs,
+) -> Result<P<ast::Expr>, Error> {
+    let arms: Vec<_> = try!(
+        enum_def.variants.iter()
+            .enumerate()
+            .map(|(variant_index, variant)| {
+                serialize_variant(
+                    cx,
+                    builder,
+                    type_ident,
+                    impl_generics,
+                    ty.clone(),
+                    variant,
+                    variant_index,
+                    container_attrs,
+                )
+            })
+            .collect()
+    );

    Ok(quote_expr!(cx,
        match *self {
@@ -306,21 +375,20 @@ fn serialize_variant(
    ty: P<ast::Ty>,
    variant: &ast::Variant,
    variant_index: usize,
-) -> Result<ast::Arm, ()> {
-    let type_name = builder.expr().str(type_ident);
+    container_attrs: &attr::ContainerAttrs,
+) -> Result<ast::Arm, Error> {
+    let type_name = container_attrs.name().serialize_name_expr();
+
    let variant_ident = variant.node.name;
-    let variant_name = builder.expr().str(variant_ident);
+    let variant_attrs = try!(attr::VariantAttrs::from_variant(cx, variant));
+    let variant_name = variant_attrs.name().serialize_name_expr();

    match variant.node.data {
        ast::VariantData::Unit(_) => {
-            let pat = builder.pat().enum_()
-                .id(type_ident).id(variant_ident).build()
-                .build();
-
            Ok(quote_arm!(cx,
-                $pat => {
-                    ::serde::ser::Serializer::visit_unit_variant(
-                        serializer,
+                $type_ident::$variant_ident => {
+                    _serde::ser::Serializer::serialize_unit_variant(
+                        _serializer,
                        $type_name,
                        $variant_index,
                        $variant_name,
@@ -329,23 +397,19 @@ fn serialize_variant(
            ))
        },
        ast::VariantData::Tuple(ref fields, _) if fields.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();
+            let expr = try!(serialize_newtype_variant(
+                cx,
+                builder,
+                type_name,
+                variant_index,
+                variant_name,
+                ty,
+                generics,
+                &fields[0],
+            ));

            Ok(quote_arm!(cx,
-                $pat => {
-                    ::serde::ser::Serializer::visit_newtype_variant(
-                        serializer,
-                        $type_name,
-                        $variant_index,
-                        $variant_name,
-                        __simple_value,
-                    )
-                }
+                $type_ident::$variant_ident(ref __simple_value) => { $expr }
            ))
        },
        ast::VariantData::Tuple(ref fields, _) => {
@@ -361,7 +425,7 @@ fn serialize_variant(
                )
                .build();

-            let expr = serialize_tuple_variant(
+            let expr = try!(serialize_tuple_variant(
                cx,
                builder,
                type_name,
@@ -371,7 +435,7 @@ fn serialize_variant(
                ty,
                fields,
                field_names,
-            );
+            ));

            Ok(quote_arm!(cx,
                $pat => { $expr }
@@ -388,9 +452,9 @@ fn serialize_variant(
                    field_names.iter()
                        .zip(fields.iter())
                        .map(|(id, field)| {
-                            let name = match field.node.kind {
-                                ast::NamedField(name, _) => name,
-                                ast::UnnamedField(_) => {
+                            let name = match field.ident {
+                                Some(name) => name,
+                                None => {
                                    cx.span_bug(field.span, "struct variant has unnamed fields")
                                }
                            };
@@ -403,13 +467,13 @@ fn serialize_variant(
            let expr = try!(serialize_struct_variant(
                cx,
                builder,
-                type_name,
                variant_index,
                variant_name,
                generics,
                ty,
                fields,
                field_names,
+                container_attrs,
            ));

            Ok(quote_arm!(cx,
@@ -419,6 +483,35 @@ fn serialize_variant(
    }
 }

+fn serialize_newtype_variant(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    type_name: P<ast::Expr>,
+    variant_index: usize,
+    variant_name: P<ast::Expr>,
+    container_ty: P<ast::Ty>,
+    generics: &ast::Generics,
+    field: &ast::StructField,
+) -> Result<P<ast::Expr>, Error> {
+    let attrs = try!(attr::FieldAttrs::from_field(cx, 0, field));
+
+    let mut field_expr = quote_expr!(cx, __simple_value);
+    if let Some(path) = attrs.serialize_with() {
+        field_expr = wrap_serialize_with(cx, builder,
+            &container_ty, generics, &field.ty, path, field_expr);
+    }
+
+    Ok(quote_expr!(cx,
+        _serde::ser::Serializer::serialize_newtype_variant(
+            _serializer,
+            $type_name,
+            $variant_index,
+            $variant_name,
+            $field_expr,
+        )
+    ))
+}
+
 fn serialize_tuple_variant(
    cx: &ExtCtxt,
    builder: &aster::AstBuilder,
@@ -429,26 +522,28 @@ fn serialize_tuple_variant(
    structure_ty: P<ast::Ty>,
    fields: &[ast::StructField],
    field_names: Vec<Ident>,
-) -> P<ast::Expr> {
+) -> Result<P<ast::Expr>, Error> {
    let variant_ty = builder.ty().tuple()
        .with_tys(
            fields.iter().map(|field| {
                builder.ty()
                    .ref_()
                    .lifetime("'__a")
-                    .build_ty(field.node.ty.clone())
+                    .build_ty(field.ty.clone())
            })
        )
        .build();

-    let (visitor_struct, visitor_impl) = serialize_tuple_struct_visitor(
+    let (visitor_struct, visitor_impl) = try!(serialize_tuple_struct_visitor(
        cx,
        builder,
        structure_ty.clone(),
        variant_ty,
-        fields.len(),
+        builder.id("serialize_tuple_variant_elt"),
+        fields,
        generics,
-    );
+        true,
+    ));

    let value_expr = builder.expr().tuple()
        .with_exprs(
@@ -458,69 +553,103 @@ fn serialize_tuple_variant(
        )
        .build();

-    quote_expr!(cx, {
+    Ok(quote_expr!(cx, {
        $visitor_struct
        $visitor_impl
-        serializer.visit_tuple_variant($type_name, $variant_index, $variant_name, Visitor {
+        _serializer.serialize_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>,
+    ty: P<ast::Ty>,
    fields: &[ast::StructField],
    field_names: Vec<Ident>,
-) -> Result<P<ast::Expr>, ()> {
-    let value_ty = builder.ty().tuple()
-        .with_tys(
-            fields.iter().map(|field| {
-                builder.ty()
-                    .ref_()
-                    .lifetime("'__a")
-                    .build_ty(field.node.ty.clone())
-            })
-        )
+    container_attrs: &attr::ContainerAttrs,
+) -> Result<P<ast::Expr>, Error> {
+    let variant_generics = builder.generics()
+        .with(generics.clone())
+        .add_lifetime_bound("'__serde_variant")
+        .lifetime_name("'__serde_variant")
        .build();

-    let value_expr = builder.expr().tuple()
-        .with_exprs(
-            field_names.iter().map(|field| {
-                builder.expr().id(field)
+    let variant_struct = builder.item().struct_("__VariantStruct")
+        .with_generics(variant_generics.clone())
+        .with_fields(
+            fields.iter().map(|field| {
+                builder.struct_field(field.ident.expect("struct has unnamed fields"))
+                    .with_attrs(field.attrs.iter().cloned())
+                    .ty()
+                    .ref_()
+                    .lifetime("'__serde_variant")
+                    .build_ty(field.ty.clone())
            })
        )
+        .field("__serde_container_ty")
+            .ty().phantom_data().build(ty.clone())
+        .build();
+
+    let variant_expr = builder.expr().struct_id("__VariantStruct")
+        .with_id_exprs(
+            fields.iter()
+                .zip(field_names.iter())
+                .map(|(field, field_name)| {
+                    (
+                        field.ident.expect("struct has unnamed fields"),
+                        builder.expr().id(field_name),
+                    )
+                })
+        )
+        .field("__serde_container_ty").path()
+            .global()
+            .id("std").id("marker")
+            .segment("PhantomData")
+                .with_ty(ty.clone())
+                .build()
+            .build()
+        .build();
+
+    let variant_ty = builder.ty().path()
+        .segment("__VariantStruct")
+            .with_generics(variant_generics.clone())
+            .build()
        .build();

    let (visitor_struct, visitor_impl) = try!(serialize_struct_visitor(
        cx,
        builder,
-        structure_ty.clone(),
-        value_ty,
+        variant_ty.clone(),
+        variant_ty.clone(),
+        builder.id("serialize_struct_variant_elt"),
        fields,
-        generics,
-        (0 .. field_names.len()).map(|i| {
-            builder.expr()
-                .tup_field(i)
-                .field("value").self_()
-        })
+        &variant_generics,
+        true,
    ));

+    let container_name = container_attrs.name().serialize_name_expr();
+
    Ok(quote_expr!(cx, {
+        $variant_struct
        $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>,
-        })
+        _serializer.serialize_struct_variant(
+            $container_name,
+            $variant_index,
+            $variant_name,
+            Visitor {
+                value: $variant_expr,
+                state: 0,
+                _structure_ty: ::std::marker::PhantomData,
+            },
+        )
    }))
 }

@@ -529,20 +658,34 @@ fn serialize_tuple_struct_visitor(
    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_();
+    serializer_method: ast::Ident,
+    fields: &[ast::StructField],
+    generics: &ast::Generics,
+    is_enum: bool,
+) -> Result<(P<ast::Item>, P<ast::Item>), Error> {
+    let fields_with_attrs = try!(attr::fields_with_attrs(cx, fields));
+
+    let arms: Vec<_> = fields_with_attrs.iter()
+        .enumerate()
+        .map(|(i, &(ref field, ref attrs))| {
+            let mut field_expr = builder.expr().tup_field(i).field("value").self_();
+            if !is_enum {
+                field_expr = quote_expr!(cx, &$field_expr);
+            }
+
+            let continue_if_skip = attrs.skip_serializing_if()
+                .map(|path| quote_stmt!(cx, if $path($field_expr) { continue }));
+
+            if let Some(path) = attrs.serialize_with() {
+                field_expr = wrap_serialize_with(cx, builder,
+                    &structure_ty, generics, &field.ty, path, field_expr);
+            }

            quote_arm!(cx,
                $i => {
                    self.state += 1;
-                    let v = try!(serializer.visit_tuple_struct_elt(&$expr));
-                    Ok(Some(v))
+                    $continue_if_skip
+                    Ok(Some(try!(_serializer.$serializer_method($field_expr))))
                }
            )
        })
@@ -559,7 +702,9 @@ fn serialize_tuple_struct_visitor(
        .strip_bounds()
        .build();

-    (
+    let nfields = fields.len();
+
+    Ok((
        quote_item!(cx,
            struct Visitor $visitor_impl_generics $where_clause {
                state: usize,
@@ -569,12 +714,12 @@ fn serialize_tuple_struct_visitor(
        ).unwrap(),

        quote_item!(cx,
-            impl $visitor_impl_generics ::serde::ser::SeqVisitor
+            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
+                fn visit<__S>(&mut self, _serializer: &mut __S) -> ::std::result::Result<Option<()>, __S::Error>
+                    where __S: _serde::ser::Serializer
                {
                    match self.state {
                        $arms
@@ -584,58 +729,54 @@ fn serialize_tuple_struct_visitor(

                #[inline]
                fn len(&self) -> Option<usize> {
-                    Some($fields)
+                    Some($nfields)
                }
            }
        ).unwrap(),
-    )
+    ))
 }

-fn serialize_struct_visitor<I>(
+fn serialize_struct_visitor(
    cx: &ExtCtxt,
    builder: &aster::AstBuilder,
    structure_ty: P<ast::Ty>,
    variant_ty: P<ast::Ty>,
+    serializer_method: ast::Ident,
    fields: &[ast::StructField],
    generics: &ast::Generics,
-    value_exprs: I,
-) -> Result<(P<ast::Item>, P<ast::Item>), ()>
-    where I: Iterator<Item=P<ast::Expr>>,
-{
-    let value_exprs = value_exprs.collect::<Vec<_>>();
+    is_enum: bool,
+) -> Result<(P<ast::Item>, P<ast::Item>), Error> {
+    let fields_with_attrs = try!(attr::fields_with_attrs(cx, fields));

-    let field_attrs = try!(field::struct_field_attrs(cx, builder, fields));
-
-    let arms: Vec<ast::Arm> = field_attrs.iter()
-        .zip(value_exprs.iter())
-        .filter(|&(ref field, _)| !field.skip_serializing_field())
+    let arms: Vec<ast::Arm> = fields_with_attrs.iter()
+        .filter(|&&(_, ref attrs)| !attrs.skip_serializing_field())
        .enumerate()
-        .map(|(i, (ref field, value_expr))| {
-            let key_expr = field.serializer_key_expr(cx);
+        .map(|(i, &(ref field, ref attrs))| {
+            let ident = field.ident.expect("struct has unnamed field");
+            let mut field_expr = quote_expr!(cx, self.value.$ident);
+            if !is_enum {
+                field_expr = quote_expr!(cx, &$field_expr);
+            }

-            let stmt = if field.skip_serializing_field_if_empty() {
-                quote_stmt!(cx, if ($value_expr).is_empty() { continue; })
-            } else if field.skip_serializing_field_if_none() {
-                quote_stmt!(cx, if ($value_expr).is_none() { continue; })
-            } else {
-                quote_stmt!(cx, {})
-            };
+            let key_expr = attrs.name().serialize_name_expr();
+
+            let continue_if_skip = attrs.skip_serializing_if()
+                .map(|path| quote_stmt!(cx, if $path($field_expr) { continue }));
+
+            if let Some(path) = attrs.serialize_with() {
+                field_expr = wrap_serialize_with(cx, builder,
+                    &structure_ty, generics, &field.ty, path, field_expr)
+            }
+
+            let expr = quote_expr!(cx,
+                _serializer.$serializer_method($key_expr, $field_expr)
+            );

            quote_arm!(cx,
                $i => {
                    self.state += 1;
-                    $stmt
-
-                    return Ok(
-                        Some(
-                            try!(
-                                serializer.visit_struct_elt(
-                                    $key_expr,
-                                    $value_expr,
-                                )
-                            )
-                        )
-                    );
+                    $continue_if_skip
+                    return Ok(Some(try!($expr)));
                }
            )
        })
@@ -652,17 +793,18 @@ fn serialize_struct_visitor<I>(
        .strip_bounds()
        .build();

-    let len = field_attrs.iter()
-        .zip(value_exprs.iter())
-        .map(|(field, value_expr)| {
-            if field.skip_serializing_field() {
-                quote_expr!(cx, 0)
-            } else if field.skip_serializing_field_if_empty() {
-                quote_expr!(cx, if ($value_expr).is_empty() { 0 } else { 1 })
-            } else if field.skip_serializing_field_if_none() {
-                quote_expr!(cx, if ($value_expr).is_none() { 0 } else { 1 })
-            } else {
-                quote_expr!(cx, 1)
+    let len = fields_with_attrs.iter()
+        .filter(|&&(_, ref attrs)| !attrs.skip_serializing_field())
+        .map(|&(ref field, ref attrs)| {
+            let ident = field.ident.expect("struct has unnamed fields");
+            let mut field_expr = quote_expr!(cx, self.value.$ident);
+            if !is_enum {
+                field_expr = quote_expr!(cx, &$field_expr);
+            }
+
+            match attrs.skip_serializing_if() {
+                Some(path) => quote_expr!(cx, if $path($field_expr) { 0 } else { 1 }),
+                None => quote_expr!(cx, 1),
            }
        })
        .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr));
@@ -678,12 +820,12 @@ fn serialize_struct_visitor<I>(

        quote_item!(cx,
            impl $visitor_impl_generics
-            ::serde::ser::MapVisitor
+            _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,
+                fn visit<__S>(&mut self, _serializer: &mut __S) -> ::std::result::Result<Option<()>, __S::Error>
+                    where __S: _serde::ser::Serializer,
                {
                    loop {
                        match self.state {
@@ -701,3 +843,46 @@ fn serialize_struct_visitor<I>(
        ).unwrap(),
    ))
 }
+
+fn wrap_serialize_with(
+    cx: &ExtCtxt,
+    builder: &aster::AstBuilder,
+    container_ty: &P<ast::Ty>,
+    generics: &ast::Generics,
+    field_ty: &P<ast::Ty>,
+    path: &ast::Path,
+    value: P<ast::Expr>,
+) -> P<ast::Expr> {
+    let where_clause = &generics.where_clause;
+
+    let wrapper_generics = builder.from_generics(generics.clone())
+        .add_lifetime_bound("'__a")
+        .lifetime_name("'__a")
+        .build();
+
+    let wrapper_ty = builder.path()
+        .segment("__SerializeWith")
+            .with_generics(wrapper_generics.clone())
+            .build()
+        .build();
+
+    quote_expr!(cx, {
+        struct __SerializeWith $wrapper_generics $where_clause {
+            value: &'__a $field_ty,
+            phantom: ::std::marker::PhantomData<$container_ty>,
+        }
+
+        impl $wrapper_generics _serde::ser::Serialize for $wrapper_ty $where_clause {
+            fn serialize<__S>(&self, __s: &mut __S) -> Result<(), __S::Error>
+                where __S: _serde::ser::Serializer
+            {
+                $path(self.value, __s)
+            }
+        }
+
+        __SerializeWith {
+            value: $value,
+            phantom: ::std::marker::PhantomData::<$container_ty>,
+        }
+    })
+}
@@ -1,23 +1,35 @@
 [package]
 name = "serde_macros"
-version = "0.6.11"
+version = "0.7.10"
 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"
 documentation = "https://github.com/serde-rs/serde"
 keywords = ["serde", "serialization"]
+include = ["Cargo.toml", "src/**/*.rs"]

 [lib]
 name = "serde_macros"
 plugin = true

+[features]
+nightly-testing = ["clippy", "serde/nightly-testing", "serde_codegen/nightly-testing"]
+
 [dependencies]
-clippy = "^0.0.37"
-serde_codegen = { version = "^0.6.10", path = "../serde_codegen", default-features = false, features = ["nightly"] }
+clippy = { version = "^0.*", optional = true }
+serde_codegen = { version = "^0.7.10", path = "../serde_codegen", default-features = false, features = ["nightly"] }

 [dev-dependencies]
-compiletest_rs = "^0.0.11"
-num = "^0.1.27"
+compiletest_rs = "^0.1.1"
+fnv = "1.0"
 rustc-serialize = "^0.3.16"
-serde = { version = "^0.6.10", path = "../serde", features = ["nightly", "num-impls"] }
+serde = { version = "^0.7.10", path = "../serde" }
+
+[[test]]
+name = "test"
+path = "tests/test.rs"
+
+[[bench]]
+name = "bench"
+path = "benches/bench.rs"
@@ -1,8 +1,7 @@
 #![feature(custom_attribute, custom_derive, plugin, test)]
-#![plugin(clippy)]
+#![cfg_attr(feature = "clippy", plugin(clippy))]
 #![plugin(serde_macros)]

-extern crate num;
 extern crate rustc_serialize;
 extern crate serde;
 extern crate test;
@@ -1,5 +1,6 @@
-#![feature(plugin, plugin_registrar, rustc_private)]
-#![plugin(clippy)]
+#![feature(plugin_registrar, rustc_private)]
+#![cfg_attr(feature = "clippy", feature(plugin))]
+#![cfg_attr(feature = "clippy", plugin(clippy))]

 extern crate serde_codegen;
 extern crate rustc_plugin;
@@ -1,7 +1,6 @@
 #![feature(test, custom_attribute, custom_derive, plugin)]
 #![plugin(serde_macros)]

-extern crate num;
 extern crate serde;
 extern crate test;

@@ -1,6 +1,6 @@
 [package]
 name = "serde_tests"
-version = "0.6.3"
+version = "0.7.10"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -11,21 +11,21 @@ keywords = ["serialization"]
 build = "build.rs"

 [features]
-nightly = ["clippy", "serde/nightly"]
+nightly-testing = ["clippy", "serde/nightly-testing", "serde_codegen/nightly-testing"]

 [build-dependencies]
-syntex = { version = "^0.26.0" }
-syntex_syntax = { version = "^0.26.0" }
+syntex = { version = "^0.35.0" }
+syntex_syntax = { version = "^0.35.0" }
 serde_codegen = { version = "*", path = "../serde_codegen", features = ["with-syntex"] }

 [dev-dependencies]
-num = "^0.1.27"
+fnv = "1.0"
 rustc-serialize = "^0.3.16"
-serde = { version = "*", path = "../serde", features = ["num-impls"] }
-syntex = "^0.26.0"
+serde = { version = "*", path = "../serde" }
+syntex = "^0.35.0"

 [dependencies]
-clippy = { version = "^0.0.37", optional = true }
+clippy = { version = "^0.*", optional = true }

 [[test]]
 name = "test"
@@ -2,7 +2,6 @@
 #![cfg_attr(feature = "nightly", feature(plugin))]
 #![cfg_attr(feature = "nightly", plugin(clippy))]

-extern crate num;
 extern crate rustc_serialize;
 extern crate serde;
 extern crate test;
@@ -1,7 +1,9 @@
 use test::Bencher;
-use rustc_serialize::{Decoder, Decodable};
+use std::error;
+use std::fmt;
+use rustc_serialize::Decodable;
 use serde;
-use serde::de::{Deserializer, Deserialize};
+use serde::de::Deserialize;

 //////////////////////////////////////////////////////////////////////////////

@@ -15,18 +17,34 @@ pub enum Animal {

 #[derive(Debug)]
 pub enum Error {
-    EndOfStreamError,
-    SyntaxError,
+    EndOfStream,
+    Syntax,
 }

 impl serde::de::Error for Error {
-    fn syntax(_: &str) -> Error { Error::SyntaxError }
+    fn custom<T: Into<String>>(_: T) -> Error { Error::Syntax }

-    fn end_of_stream() -> Error { Error::EndOfStreamError }
+    fn end_of_stream() -> Error { Error::EndOfStream }

-    fn unknown_field(_: &str) -> Error { Error::SyntaxError }
+    fn unknown_field(_: &str) -> Error { Error::Syntax }

-    fn missing_field(_: &'static str) -> Error { Error::SyntaxError }
+    fn missing_field(_: &'static str) -> Error { Error::Syntax }
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        formatter.write_str(format!("{:?}", self).as_ref())
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
 }

 //////////////////////////////////////////////////////////////////////////////
@@ -36,12 +54,11 @@ mod decoder {

    use super::{Animal, Error};
    use super::Animal::{Dog, Frog};
-    use self::State::{AnimalState, IsizeState, StringState};

    enum State {
-        AnimalState(Animal),
-        IsizeState(isize),
-        StringState(String),
+        Animal(Animal),
+        Isize(isize),
+        String(String),
    }

    pub struct AnimalDecoder {
@@ -53,7 +70,7 @@ mod decoder {
        #[inline]
        pub fn new(animal: Animal) -> AnimalDecoder {
            AnimalDecoder {
-                stack: vec!(AnimalState(animal)),
+                stack: vec!(State::Animal(animal)),
            }
        }
    }
@@ -61,35 +78,35 @@ mod decoder {
    impl Decoder for AnimalDecoder {
        type Error = Error;

-        fn error(&mut self, _: &str) -> Error { Error::SyntaxError }
+        fn error(&mut self, _: &str) -> Error { Error::Syntax }

        // Primitive types:
-        fn read_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) }
-        fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::SyntaxError) }
-        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) }
-        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) }
-        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) }
-        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError) }
+        fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) }
+        fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::Syntax) }
+        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
+        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
+        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
+        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
        #[inline]
        fn read_isize(&mut self) -> Result<isize, Error> {
            match self.stack.pop() {
-                Some(IsizeState(x)) => Ok(x),
-                _ => Err(Error::SyntaxError),
+                Some(State::Isize(x)) => Ok(x),
+                _ => Err(Error::Syntax),
            }
        }
-        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) }
-        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) }
-        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) }
-        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) }
-        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) }
-        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) }
-        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) }
-        fn read_char(&mut self) -> Result<char, Error> { Err(Error::SyntaxError) }
+        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
+        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
+        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
+        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
+        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
+        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
+        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
+        fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
        #[inline]
        fn read_str(&mut self) -> Result<String, Error> {
            match self.stack.pop() {
-                Some(StringState(x)) => Ok(x),
-                _ => Err(Error::SyntaxError),
+                Some(State::String(x)) => Ok(x),
+                _ => Err(Error::Syntax),
            }
        }

@@ -99,15 +116,15 @@ mod decoder {
            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
        {
            match self.stack.pop() {
-                Some(AnimalState(animal)) => {
-                    self.stack.push(AnimalState(animal));
+                Some(State::Animal(animal)) => {
+                    self.stack.push(State::Animal(animal));
                    if name == "Animal" {
                        f(self)
                    } else {
-                        Err(Error::SyntaxError)
+                        Err(Error::Syntax)
                    }
                }
-                _ => Err(Error::SyntaxError)
+                _ => Err(Error::Syntax)
            }
        }

@@ -116,18 +133,18 @@ mod decoder {
            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
        {
            let name = match self.stack.pop() {
-                Some(AnimalState(Dog)) => "Dog",
-                Some(AnimalState(Frog(x0, x1))) => {
-                    self.stack.push(IsizeState(x1));
-                    self.stack.push(StringState(x0));
+                Some(State::Animal(Dog)) => "Dog",
+                Some(State::Animal(Frog(x0, x1))) => {
+                    self.stack.push(State::Isize(x1));
+                    self.stack.push(State::String(x0));
                    "Frog"
                }
-                _ => { return Err(Error::SyntaxError); }
+                _ => { return Err(Error::Syntax); }
            };

            let idx = match names.iter().position(|n| *n == name) {
                Some(idx) => idx,
-                None => { return Err(Error::SyntaxError); }
+                None => { return Err(Error::Syntax); }
            };

            f(self, idx)
@@ -143,56 +160,56 @@ mod decoder {
        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        // Specialized types:
        fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut AnimalDecoder, bool) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        #[inline]
@@ -212,19 +229,19 @@ mod decoder {
        fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }
    }
 }
@@ -238,10 +255,10 @@ mod deserializer {

    #[derive(Debug)]
    enum State {
-        AnimalState(Animal),
-        IsizeState(isize),
-        StrState(&'static str),
-        StringState(String),
+        Animal(Animal),
+        Isize(isize),
+        Str(&'static str),
+        String(String),
        UnitState,
    }

@@ -253,7 +270,7 @@ mod deserializer {
        #[inline]
        pub fn new(animal: Animal) -> AnimalDeserializer {
            AnimalDeserializer {
-                stack: vec!(State::AnimalState(animal)),
+                stack: vec!(State::Animal(animal)),
            }
        }
    }
@@ -262,60 +279,60 @@ mod deserializer {
        type Error = Error;

        #[inline]
-        fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
            where V: de::Visitor,
        {
            match self.stack.pop() {
-                Some(State::IsizeState(value)) => {
+                Some(State::Isize(value)) => {
                    visitor.visit_isize(value)
                }
-                Some(State::StringState(value)) => {
+                Some(State::String(value)) => {
                    visitor.visit_string(value)
                }
-                Some(State::StrState(value)) => {
+                Some(State::Str(value)) => {
                    visitor.visit_str(value)
                }
                Some(State::UnitState) => {
                    visitor.visit_unit()
                }
                Some(_) => {
-                    Err(Error::SyntaxError)
+                    Err(Error::Syntax)
                }
                None => {
-                    Err(Error::EndOfStreamError)
+                    Err(Error::EndOfStream)
                }
            }
        }

        #[inline]
-        fn visit_enum<V>(&mut self,
+        fn deserialize_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)) => {
+                Some(State::Animal(Animal::Dog)) => {
                    self.stack.push(State::UnitState);
-                    self.stack.push(State::StrState("Dog"));
+                    self.stack.push(State::Str("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"));
+                Some(State::Animal(Animal::Frog(x0, x1))) => {
+                    self.stack.push(State::Isize(x1));
+                    self.stack.push(State::String(x0));
+                    self.stack.push(State::Str("Frog"));
                    visitor.visit(FrogVisitor {
                        de: self,
                        state: 0,
                    })
                }
                Some(_) => {
-                    Err(Error::SyntaxError)
+                    Err(Error::Syntax)
                }
                None => {
-                    Err(Error::EndOfStreamError)
+                    Err(Error::EndOfStream)
                }
            }
        }
@@ -387,7 +404,7 @@ mod deserializer {
            if self.state == 2 {
                Ok(())
            } else {
-                Err(Error::SyntaxError)
+                Err(Error::Syntax)
            }
        }

@@ -1,4 +1,6 @@
 use std::fmt::Debug;
+use std::fmt;
+use std::error;
 use std::collections::HashMap;
 use test::Bencher;

@@ -12,22 +14,37 @@ use serde::de::{Deserializer, Deserialize};
 #[derive(PartialEq, Debug)]
 pub enum Error {
    EndOfStream,
-    SyntaxError,
+    Syntax,
    MissingField,
 }

 impl serde::de::Error for Error {
-    fn syntax(_: &str) -> Error { Error::SyntaxError }
+    fn custom<T: Into<String>>(_: T) -> Error { Error::Syntax }

    fn end_of_stream() -> Error { Error::EndOfStream }

-    fn unknown_field(_: &str) -> Error { Error::SyntaxError }
+    fn unknown_field(_: &str) -> Error { Error::Syntax }

    fn missing_field(_: &'static str) -> Error {
        Error::MissingField
    }
 }

+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        formatter.write_str(format!("{:?}", self).as_ref())
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
 //////////////////////////////////////////////////////////////////////////////

 mod decoder {
@@ -36,11 +53,10 @@ mod decoder {
    use rustc_serialize;

    use super::Error;
-    use self::Value::{StringValue, IsizeValue};

    enum Value {
-        StringValue(String),
-        IsizeValue(isize),
+        String(String),
+        Isize(isize),
    }

    pub struct IsizeDecoder {
@@ -64,37 +80,37 @@ mod decoder {
        type Error = Error;

        fn error(&mut self, _msg: &str) -> Error {
-            Error::SyntaxError
+            Error::Syntax
        }

        // Primitive types:
-        fn read_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) }
-        fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::SyntaxError) }
-        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) }
-        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) }
-        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) }
-        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError) }
+        fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) }
+        fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::Syntax) }
+        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
+        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
+        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
+        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
        #[inline]
        fn read_isize(&mut self) -> Result<isize, Error> {
            match self.stack.pop() {
-                Some(IsizeValue(x)) => Ok(x),
-                Some(_) => Err(Error::SyntaxError),
+                Some(Value::Isize(x)) => Ok(x),
+                Some(_) => Err(Error::Syntax),
                None => Err(Error::EndOfStream),
            }
        }
-        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) }
-        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) }
-        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) }
-        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) }
-        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) }
-        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) }
-        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) }
-        fn read_char(&mut self) -> Result<char, Error> { Err(Error::SyntaxError) }
+        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
+        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
+        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
+        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
+        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
+        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
+        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
+        fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
        #[inline]
        fn read_str(&mut self) -> Result<String, Error> {
            match self.stack.pop() {
-                Some(StringValue(x)) => Ok(x),
-                Some(_) => Err(Error::SyntaxError),
+                Some(Value::String(x)) => Ok(x),
+                Some(_) => Err(Error::Syntax),
                None => Err(Error::EndOfStream),
            }
        }
@@ -103,86 +119,86 @@ mod decoder {
        fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        // Specialized types:
        fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder, bool) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_seq<T, F>(&mut self, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_seq_elt<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        #[inline]
@@ -198,12 +214,12 @@ mod decoder {
        {
            match self.iter.next() {
                Some((key, value)) => {
-                    self.stack.push(IsizeValue(value));
-                    self.stack.push(StringValue(key));
+                    self.stack.push(Value::Isize(value));
+                    self.stack.push(Value::String(key));
                    f(self)
                }
                None => {
-                    Err(Error::SyntaxError)
+                    Err(Error::Syntax)
                }
            }
        }
@@ -230,8 +246,8 @@ mod deserializer {
    #[derive(PartialEq, Debug)]
    enum State {
        StartState,
-        KeyState(String),
-        ValueState(isize),
+        Key(String),
+        Value(isize),
    }

    pub struct IsizeDeserializer {
@@ -252,17 +268,17 @@ mod deserializer {
    impl de::Deserializer for IsizeDeserializer {
        type Error = Error;

-        fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
            where V: de::Visitor,
        {
            match self.stack.pop() {
                Some(State::StartState) => {
                    visitor.visit_map(self)
                }
-                Some(State::KeyState(key)) => {
+                Some(State::Key(key)) => {
                    visitor.visit_string(key)
                }
-                Some(State::ValueState(value)) => {
+                Some(State::Value(value)) => {
                    visitor.visit_isize(value)
                }
                None => {
@@ -280,8 +296,8 @@ mod deserializer {
        {
            match self.iter.next() {
                Some((key, value)) => {
-                    self.stack.push(State::ValueState(value));
-                    self.stack.push(State::KeyState(key));
+                    self.stack.push(State::Value(value));
+                    self.stack.push(State::Key(key));
                    Ok(Some(try!(de::Deserialize::deserialize(self))))
                }
                None => {
@@ -298,7 +314,7 @@ mod deserializer {

        fn end(&mut self) -> Result<(), Error> {
            match self.iter.next() {
-                Some(_) => Err(Error::SyntaxError),
+                Some(_) => Err(Error::Syntax),
                None => Ok(()),
            }
        }
@@ -315,14 +331,14 @@ mod deserializer {
        #[inline]
        fn next(&mut self) -> Option<Result<de::Token, Error>> {
            match self.stack.pop() {
-                Some(StartState) => {
+                Some(State::StartState) => {
                    self.stack.push(KeyOrEndState);
                    Some(Ok(de::Token::MapStart(self.len)))
                }
-                Some(KeyOrEndState) => {
+                Some(State::KeyOrEndState) => {
                    match self.iter.next() {
                        Some((key, value)) => {
-                            self.stack.push(ValueState(value));
+                            self.stack.push(Value(value));
                            Some(Ok(de::Token::String(key)))
                        }
                        None => {
@@ -331,7 +347,7 @@ mod deserializer {
                        }
                    }
                }
-                Some(ValueState(x)) => {
+                Some(State::Value(x)) => {
                    self.stack.push(KeyOrEndState);
                    Some(Ok(de::Token::Isize(x)))
                }
@@ -353,24 +369,24 @@ mod deserializer {

        #[inline]
        fn syntax(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error {
-            SyntaxError
+            Syntax
        }

        #[inline]
        fn unexpected_name(&mut self, _token: de::Token) -> Error {
-            SyntaxError
+            Syntax
        }

        #[inline]
        fn conversion_error(&mut self, _token: de::Token) -> Error {
-            SyntaxError
+            Syntax
        }

        #[inline]
        fn missing_field<
            T: de::Deserialize<IsizeDeserializer, Error>
        >(&mut self, _field: &'static str) -> Result<T, Error> {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }
    }
 */
@@ -399,7 +415,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 (0 .. 3) {
+        for i in 0 .. 3 {
            m.insert(i.to_string(), i);
        }
        run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
@@ -410,7 +426,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 (0 .. 100) {
+        for i in 0 .. 100 {
            m.insert(i.to_string(), i);
        }
        run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
@@ -439,7 +455,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 (0 .. 3) {
+        for i in 0 .. 3 {
            m.insert(i.to_string(), i);
        }
        run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
@@ -450,7 +466,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 (0 .. 100) {
+        for i in 0 .. 100 {
            m.insert(i.to_string(), i);
        }
        run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
@@ -1,10 +1,12 @@
 use std::collections::HashMap;
 use test::Bencher;
+use std::fmt;
+use std::error;

-use rustc_serialize::{Decoder, Decodable};
+use rustc_serialize::Decodable;

 use serde;
-use serde::de::{Deserializer, Deserialize};
+use serde::de::Deserialize;

 //////////////////////////////////////////////////////////////////////////////

@@ -27,54 +29,57 @@ pub struct Outer {
 #[derive(Debug, PartialEq)]
 pub enum Error {
    EndOfStream,
-    SyntaxError,
+    Syntax,
    MissingField,
    OtherError,
 }

 impl serde::de::Error for Error {
-    fn syntax(_: &str) -> Error { Error::SyntaxError }
+    fn custom<T: Into<String>>(_: T) -> Error { Error::Syntax }

    fn end_of_stream() -> Error { Error::EndOfStream }

-    fn unknown_field(_: &str) -> Error { Error::SyntaxError }
+    fn unknown_field(_: &str) -> Error { Error::Syntax }

    fn missing_field(_: &'static str) -> Error {
        Error::MissingField
    }
 }

+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        formatter.write_str(format!("{:?}", self).as_ref())
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
+
 mod decoder {
    use std::collections::HashMap;
    use rustc_serialize::Decoder;

    use super::{Outer, Inner, Error};

-    use self::State::{
-        OuterState,
-        InnerState,
-        NullState,
-        UsizeState,
-        CharState,
-        StringState,
-        FieldState,
-        VecState,
-        MapState,
-        OptionState,
-    };
-
    #[derive(Debug)]
    enum State {
-        OuterState(Outer),
-        InnerState(Inner),
-        NullState,
-        UsizeState(usize),
-        CharState(char),
-        StringState(String),
-        FieldState(&'static str),
-        VecState(Vec<Inner>),
-        MapState(HashMap<String, Option<char>>),
-        OptionState(bool),
+        Outer(Outer),
+        Inner(Inner),
+        Null,
+        Usize(usize),
+        Char(char),
+        String(String),
+        Field(&'static str),
+        Vec(Vec<Inner>),
+        Map(HashMap<String, Option<char>>),
+        Option(bool),
    }

    pub struct OuterDecoder {
@@ -86,7 +91,7 @@ mod decoder {
        #[inline]
        pub fn new(animal: Outer) -> OuterDecoder {
            OuterDecoder {
-                stack: vec!(OuterState(animal)),
+                stack: vec!(State::Outer(animal)),
            }
        }
    }
@@ -102,41 +107,41 @@ mod decoder {
        #[inline]
        fn read_nil(&mut self) -> Result<(), Error> {
            match self.stack.pop() {
-                Some(NullState) => Ok(()),
-                _ => Err(Error::SyntaxError),
+                Some(State::Null) => Ok(()),
+                _ => Err(Error::Syntax),
            }
        }
        #[inline]
        fn read_usize(&mut self) -> Result<usize, Error> {
            match self.stack.pop() {
-                Some(UsizeState(value)) => Ok(value),
-                _ => Err(Error::SyntaxError),
+                Some(State::Usize(value)) => Ok(value),
+                _ => Err(Error::Syntax),
            }
        }
-        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) }
-        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) }
-        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) }
-        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError) }
-        fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::SyntaxError) }
-        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) }
-        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) }
-        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) }
-        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) }
-        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) }
-        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) }
-        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) }
+        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
+        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
+        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
+        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
+        fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::Syntax) }
+        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
+        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
+        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
+        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
+        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
+        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
+        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
        #[inline]
        fn read_char(&mut self) -> Result<char, Error> {
            match self.stack.pop() {
-                Some(CharState(c)) => Ok(c),
-                _ => Err(Error::SyntaxError),
+                Some(State::Char(c)) => Ok(c),
+                _ => Err(Error::Syntax),
            }
        }
        #[inline]
        fn read_str(&mut self) -> Result<String, Error> {
            match self.stack.pop() {
-                Some(StringState(value)) => Ok(value),
-                _ => Err(Error::SyntaxError),
+                Some(State::String(value)) => Ok(value),
+                _ => Err(Error::Syntax),
            }
        }

@@ -144,31 +149,31 @@ mod decoder {
        fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        #[inline]
@@ -176,31 +181,31 @@ mod decoder {
            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
        {
            match self.stack.pop() {
-                Some(OuterState(Outer { inner })) => {
+                Some(State::Outer(Outer { inner })) => {
                    if s_name == "Outer" {
-                        self.stack.push(VecState(inner));
-                        self.stack.push(FieldState("inner"));
+                        self.stack.push(State::Vec(inner));
+                        self.stack.push(State::Field("inner"));
                        f(self)
                    } else {
-                        Err(Error::SyntaxError)
+                        Err(Error::Syntax)
                    }
                }
-                Some(InnerState(Inner { a: (), b, c })) => {
+                Some(State::Inner(Inner { a: (), b, c })) => {
                    if s_name == "Inner" {
-                        self.stack.push(MapState(c));
-                        self.stack.push(FieldState("c"));
+                        self.stack.push(State::Map(c));
+                        self.stack.push(State::Field("c"));

-                        self.stack.push(UsizeState(b));
-                        self.stack.push(FieldState("b"));
+                        self.stack.push(State::Usize(b));
+                        self.stack.push(State::Field("b"));

-                        self.stack.push(NullState);
-                        self.stack.push(FieldState("a"));
+                        self.stack.push(State::Null);
+                        self.stack.push(State::Field("a"));
                        f(self)
                    } else {
-                        Err(Error::SyntaxError)
+                        Err(Error::Syntax)
                    }
                }
-                _ => Err(Error::SyntaxError),
+                _ => Err(Error::Syntax),
            }
        }
        #[inline]
@@ -208,39 +213,39 @@ mod decoder {
            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
        {
            match self.stack.pop() {
-                Some(FieldState(name)) => {
+                Some(State::Field(name)) => {
                    if f_name == name {
                        f(self)
                    } else {
-                        Err(Error::SyntaxError)
+                        Err(Error::Syntax)
                    }
                }
-                _ => Err(Error::SyntaxError)
+                _ => Err(Error::Syntax)
            }
        }

        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        // Specialized types:
@@ -249,8 +254,8 @@ mod decoder {
            F: FnOnce(&mut OuterDecoder, bool) -> Result<T, Error>,
        {
            match self.stack.pop() {
-                Some(OptionState(b)) => f(self, b),
-                _ => Err(Error::SyntaxError),
+                Some(State::Option(b)) => f(self, b),
+                _ => Err(Error::Syntax),
            }
        }

@@ -259,14 +264,14 @@ mod decoder {
            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
        {
            match self.stack.pop() {
-                Some(VecState(value)) => {
+                Some(State::Vec(value)) => {
                    let len = value.len();
                    for inner in value.into_iter().rev() {
-                        self.stack.push(InnerState(inner));
+                        self.stack.push(State::Inner(inner));
                    }
                    f(self, len)
                }
-                _ => Err(Error::SyntaxError)
+                _ => Err(Error::Syntax)
            }
        }
        #[inline]
@@ -281,23 +286,23 @@ mod decoder {
            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
        {
            match self.stack.pop() {
-                Some(MapState(map)) => {
+                Some(State::Map(map)) => {
                    let len = map.len();
                    for (key, value) in map {
                        match value {
                            Some(c) => {
-                                self.stack.push(CharState(c));
-                                self.stack.push(OptionState(true));
+                                self.stack.push(State::Char(c));
+                                self.stack.push(State::Option(true));
                            }
                            None => {
-                                self.stack.push(OptionState(false));
+                                self.stack.push(State::Option(false));
                            }
                        }
-                        self.stack.push(StringState(key));
+                        self.stack.push(State::String(key));
                    }
                    f(self, len)
                }
-                _ => Err(Error::SyntaxError),
+                _ => Err(Error::Syntax),
            }
        }
        #[inline]
@@ -328,16 +333,16 @@ mod deserializer {

    #[derive(Debug)]
    enum State {
-        OuterState(Outer),
-        InnerState(Inner),
-        StrState(&'static str),
-        NullState,
-        UsizeState(usize),
-        CharState(char),
-        StringState(String),
-        OptionState(bool),
-        VecState(Vec<Inner>),
-        MapState(HashMap<String, Option<char>>),
+        Outer(Outer),
+        Inner(Inner),
+        Str(&'static str),
+        Null,
+        Usize(usize),
+        Char(char),
+        String(String),
+        Option(bool),
+        Vec(Vec<Inner>),
+        Map(HashMap<String, Option<char>>),
    }

    pub struct OuterDeserializer {
@@ -348,7 +353,7 @@ mod deserializer {
        #[inline]
        pub fn new(outer: Outer) -> OuterDeserializer {
            OuterDeserializer {
-                stack: vec!(State::OuterState(outer)),
+                stack: vec!(State::Outer(outer)),
            }
        }
    }
@@ -356,81 +361,81 @@ mod deserializer {
    impl de::Deserializer for OuterDeserializer {
        type Error = Error;

-        fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
            where V: de::Visitor,
        {
            match self.stack.pop() {
-                Some(State::VecState(value)) => {
+                Some(State::Vec(value)) => {
                    visitor.visit_seq(OuterSeqVisitor {
                        de: self,
                        iter: value.into_iter(),
                    })
                }
-                Some(State::MapState(value)) => {
+                Some(State::Map(value)) => {
                    visitor.visit_map(MapVisitor {
                        de: self,
                        iter: value.into_iter(),
                    })
                }
-                Some(State::NullState) => {
+                Some(State::Null) => {
                    visitor.visit_unit()
                }
-                Some(State::UsizeState(x)) => {
+                Some(State::Usize(x)) => {
                    visitor.visit_usize(x)
                }
-                Some(State::CharState(x)) => {
+                Some(State::Char(x)) => {
                    visitor.visit_char(x)
                }
-                Some(State::StrState(x)) => {
+                Some(State::Str(x)) => {
                    visitor.visit_str(x)
                }
-                Some(State::StringState(x)) => {
+                Some(State::String(x)) => {
                    visitor.visit_string(x)
                }
-                Some(State::OptionState(false)) => {
+                Some(State::Option(false)) => {
                    visitor.visit_none()
                }
-                Some(State::OptionState(true)) => {
+                Some(State::Option(true)) => {
                    visitor.visit_some(self)
                }
-                Some(_) => Err(Error::SyntaxError),
+                Some(_) => Err(Error::Syntax),
                None => Err(Error::EndOfStream),
            }
        }

-        fn visit_struct<V>(&mut self,
+        fn deserialize_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 })) => {
+                Some(State::Outer(Outer { inner })) => {
                    if name != "Outer" {
-                        return Err(Error::SyntaxError);
+                        return Err(Error::Syntax);
                    }

-                    self.stack.push(State::VecState(inner));
-                    self.stack.push(State::StrState("inner"));
+                    self.stack.push(State::Vec(inner));
+                    self.stack.push(State::Str("inner"));

                    visitor.visit_map(OuterMapVisitor {
                        de: self,
                        state: 0,
                    })
                }
-                Some(State::InnerState(Inner { a: (), b, c })) => {
+                Some(State::Inner(Inner { a: (), b, c })) => {
                    if name != "Inner" {
-                        return Err(Error::SyntaxError);
+                        return Err(Error::Syntax);
                    }

-                    self.stack.push(State::MapState(c));
-                    self.stack.push(State::StrState("c"));
+                    self.stack.push(State::Map(c));
+                    self.stack.push(State::Str("c"));

-                    self.stack.push(State::UsizeState(b));
-                    self.stack.push(State::StrState("b"));
+                    self.stack.push(State::Usize(b));
+                    self.stack.push(State::Str("b"));

-                    self.stack.push(State::NullState);
-                    self.stack.push(State::StrState("a"));
+                    self.stack.push(State::Null);
+                    self.stack.push(State::Str("a"));

                    visitor.visit_map(InnerMapVisitor {
                        de: self,
@@ -438,7 +443,7 @@ mod deserializer {
                    })
                }
                _ => {
-                    Err(Error::SyntaxError)
+                    Err(Error::Syntax)
                }
            }
        }
@@ -476,7 +481,7 @@ mod deserializer {
            if self.state == 1 {
                Ok(())
            } else {
-                Err(Error::SyntaxError)
+                Err(Error::Syntax)
            }
        }

@@ -499,7 +504,7 @@ mod deserializer {
        {
            match self.iter.next() {
                Some(value) => {
-                    self.de.stack.push(State::InnerState(value));
+                    self.de.stack.push(State::Inner(value));
                    Ok(Some(try!(de::Deserialize::deserialize(self.de))))
                }
                None => {
@@ -510,7 +515,7 @@ mod deserializer {

        fn end(&mut self) -> Result<(), Error> {
            match self.iter.next() {
-                Some(_) => Err(Error::SyntaxError),
+                Some(_) => Err(Error::Syntax),
                None => Ok(()),
            }
        }
@@ -552,7 +557,7 @@ mod deserializer {
            if self.state == 3 {
                Ok(())
            } else {
-                Err(Error::SyntaxError)
+                Err(Error::Syntax)
            }
        }

@@ -575,14 +580,14 @@ mod deserializer {
        {
            match self.iter.next() {
                Some((key, Some(value))) => {
-                    self.de.stack.push(State::CharState(value));
-                    self.de.stack.push(State::OptionState(true));
-                    self.de.stack.push(State::StringState(key));
+                    self.de.stack.push(State::Char(value));
+                    self.de.stack.push(State::Option(true));
+                    self.de.stack.push(State::String(key));
                    Ok(Some(try!(de::Deserialize::deserialize(self.de))))
                }
                Some((key, None)) => {
-                    self.de.stack.push(State::OptionState(false));
-                    self.de.stack.push(State::StringState(key));
+                    self.de.stack.push(State::Option(false));
+                    self.de.stack.push(State::String(key));
                    Ok(Some(try!(de::Deserialize::deserialize(self.de))))
                }
                None => {
@@ -599,7 +604,7 @@ mod deserializer {

        fn end(&mut self) -> Result<(), Error> {
            match self.iter.next() {
-                Some(_) => Err(Error::SyntaxError),
+                Some(_) => Err(Error::Syntax),
                None => Ok(()),
            }
        }
@@ -1,4 +1,6 @@
 use std::fmt::Debug;
+use std::fmt;
+use std::error;
 use test::Bencher;

 use rustc_serialize::{Decoder, Decodable};
@@ -10,20 +12,35 @@ use serde::de::{Deserializer, Deserialize};

 #[derive(PartialEq, Debug)]
 pub enum Error {
-    EndOfStreamError,
-    SyntaxError,
+    EndOfStream,
+    Syntax,
 }

 impl serde::de::Error for Error {
-    fn syntax(_: &str) -> Error { Error::SyntaxError }
+    fn custom<T: Into<String>>(_: T) -> Error { Error::Syntax }

-    fn end_of_stream() -> Error { Error::EndOfStreamError }
+    fn end_of_stream() -> Error { Error::EndOfStream }

-    fn unknown_field(_: &str) -> Error { Error::SyntaxError }
+    fn unknown_field(_: &str) -> Error { Error::Syntax }

-    fn missing_field(_: &'static str) -> Error { Error::SyntaxError }
+    fn missing_field(_: &'static str) -> Error { Error::Syntax }
 }

+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        formatter.write_str(format!("{:?}", self).as_ref())
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
 //////////////////////////////////////////////////////////////////////////////

 mod decoder {
@@ -50,104 +67,104 @@ mod decoder {
    impl rustc_serialize::Decoder for UsizeDecoder {
        type Error = Error;

-        fn error(&mut self, _: &str) -> Error { Error::SyntaxError }
+        fn error(&mut self, _: &str) -> Error { Error::Syntax }

        // Primitive types:
-        fn read_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) }
+        fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) }
        #[inline]
        fn read_usize(&mut self) -> Result<usize, Error> {
            match self.iter.next() {
                Some(value) => Ok(value),
-                None => Err(Error::EndOfStreamError),
+                None => Err(Error::EndOfStream),
            }
        }
-        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) }
-        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) }
-        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) }
-        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError) }
-        fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::SyntaxError) }
-        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) }
-        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) }
-        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) }
-        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) }
-        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) }
-        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) }
-        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) }
-        fn read_char(&mut self) -> Result<char, Error> { Err(Error::SyntaxError) }
-        fn read_str(&mut self) -> Result<String, Error> { Err(Error::SyntaxError) }
+        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
+        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
+        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
+        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
+        fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::Syntax) }
+        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
+        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
+        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
+        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
+        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
+        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
+        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
+        fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
+        fn read_str(&mut self) -> Result<String, Error> { Err(Error::Syntax) }

        // Compound types:
        fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        // Specialized types:
        fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder, bool) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        #[inline]
@@ -167,19 +184,19 @@ mod decoder {
        fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }
    }

@@ -202,105 +219,105 @@ mod decoder {
    impl rustc_serialize::Decoder for U8Decoder {
        type Error = Error;

-        fn error(&mut self, _: &str) -> Error { Error::SyntaxError }
+        fn error(&mut self, _: &str) -> Error { Error::Syntax }

        // Primitive types:
-        fn read_nil(&mut self) -> Result<(), Error> { Err(Error::SyntaxError) }
-        fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::SyntaxError) }
-        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::SyntaxError) }
-        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError) }
-        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError) }
+        fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) }
+        fn read_usize(&mut self) -> Result<usize, Error> { Err(Error::Syntax) }
+        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
+        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
+        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
        #[inline]
        fn read_u8(&mut self) -> Result<u8, Error> {
            match self.iter.next() {
                Some(value) => Ok(value),
-                None => Err(Error::EndOfStreamError),
+                None => Err(Error::EndOfStream),
            }
        }
        #[inline]
-        fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::SyntaxError) }
-        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError) }
-        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError) }
-        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError) }
-        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::SyntaxError) }
-        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::SyntaxError) }
-        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::SyntaxError) }
-        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::SyntaxError) }
-        fn read_char(&mut self) -> Result<char, Error> { Err(Error::SyntaxError) }
-        fn read_str(&mut self) -> Result<String, Error> { Err(Error::SyntaxError) }
+        fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::Syntax) }
+        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
+        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
+        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
+        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
+        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
+        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
+        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
+        fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
+        fn read_str(&mut self) -> Result<String, Error> { Err(Error::Syntax) }

        // Compound types:
        fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        // Specialized types:
        fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder, bool) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        #[inline]
@@ -320,19 +337,19 @@ mod decoder {
        fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }

        fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
        {
-            Err(Error::SyntaxError)
+            Err(Error::Syntax)
        }
    }
 }
@@ -349,9 +366,9 @@ mod deserializer {

    #[derive(PartialEq, Debug)]
    enum State {
-        StartState,
-        SepOrEndState,
-        EndState,
+        Start,
+        SepOrEnd,
+        End,
    }

    pub struct Deserializer<A> {
@@ -366,7 +383,7 @@ mod deserializer {
        pub fn new(values: Vec<A>) -> Deserializer<A> {
            let len = values.len();
            Deserializer {
-                state: State::StartState,
+                state: State::Start,
                iter: values.into_iter(),
                len: len,
                value: None,
@@ -378,19 +395,19 @@ mod deserializer {
        type Error = Error;

        #[inline]
-        fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
            where V: de::Visitor,
        {
            match self.state {
-                State::StartState => {
-                    self.state = State::SepOrEndState;
+                State::Start => {
+                    self.state = State::SepOrEnd;
                    visitor.visit_seq(self)
                }
-                State::SepOrEndState => {
+                State::SepOrEnd => {
                    visitor.visit_usize(self.value.take().unwrap())
                }
-                State::EndState => {
-                    Err(Error::EndOfStreamError)
+                State::End => {
+                    Err(Error::EndOfStream)
                }
            }
        }
@@ -410,7 +427,7 @@ mod deserializer {
                    Ok(Some(try!(de::Deserialize::deserialize(self))))
                }
                None => {
-                    self.state = State::EndState;
+                    self.state = State::End;
                    Ok(None)
                }
            }
@@ -419,9 +436,9 @@ mod deserializer {
        #[inline]
        fn end(&mut self) -> Result<(), Error> {
            match self.iter.next() {
-                Some(_) => Err(Error::SyntaxError),
+                Some(_) => Err(Error::Syntax),
                None => {
-                    self.state = State::EndState;
+                    self.state = State::End;
                    Ok(())
                }
            }
@@ -437,19 +454,19 @@ mod deserializer {
        type Error = Error;

        #[inline]
-        fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
            where V: de::Visitor,
        {
            match self.state {
-                State::StartState => {
-                    self.state = State::SepOrEndState;
+                State::Start => {
+                    self.state = State::SepOrEnd;
                    visitor.visit_seq(self)
                }
-                State::SepOrEndState => {
+                State::SepOrEnd => {
                    visitor.visit_u8(self.value.take().unwrap())
                }
-                State::EndState => {
-                    Err(Error::EndOfStreamError)
+                State::End => {
+                    Err(Error::EndOfStream)
                }
            }
        }
@@ -469,7 +486,7 @@ mod deserializer {
                    Ok(Some(try!(de::Deserialize::deserialize(self))))
                }
                None => {
-                    self.state = State::EndState;
+                    self.state = State::End;
                    Ok(None)
                }
            }
@@ -478,9 +495,9 @@ mod deserializer {
        #[inline]
        fn end(&mut self) -> Result<(), Error> {
            match self.iter.next() {
-                Some(_) => Err(Error::SyntaxError),
+                Some(_) => Err(Error::Syntax),
                None => {
-                    self.state = State::EndState;
+                    self.state = State::End;
                    Ok(())
                }
            }
@@ -13,10 +13,6 @@ fn main() {
    ] {
        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_codegen::expand(&src, &dst).unwrap();
    }
 }
@@ -62,6 +62,14 @@ macro_rules! hashset {
            $(set.insert($value);)+
            set
        }
+    };
+    ($hasher:ident @ $($value:expr),+) => {
+        {
+            use std::hash::BuildHasherDefault;
+            let mut set = HashSet::with_hasher(BuildHasherDefault::<$hasher>::default());
+            $(set.insert($value);)+
+            set
+        }
    }
 }

@@ -75,5 +83,13 @@ macro_rules! hashmap {
            $(map.insert($key, $value);)+
            map
        }
+    };
+    ($hasher:ident @ $($key:expr => $value:expr),+) => {
+        {
+            use std::hash::BuildHasherDefault;
+            let mut map = HashMap::with_hasher(BuildHasherDefault::<$hasher>::default());
+            $(map.insert($key, $value);)+
+            map
+        }
    }
 }
@@ -1,7 +1,4 @@
 #![cfg_attr(feature = "nightly", feature(plugin))]
 #![cfg_attr(feature = "nightly", plugin(clippy))]

-extern crate num;
-extern crate serde;
-
 include!(concat!(env!("OUT_DIR"), "/test.rs"));
@@ -6,5 +6,6 @@ mod token;
 mod test_annotations;
 mod test_bytes;
 mod test_de;
+mod test_gen;
 mod test_macros;
 mod test_ser;
@@ -1,20 +1,39 @@
-use serde;
-use serde::Serialize;
-use serde::bytes::{ByteBuf, Bytes};
+use std::fmt;
+use std::error;
+
+extern crate serde;
+use self::serde::Serialize;
+use self::serde::bytes::{ByteBuf, Bytes};

 ///////////////////////////////////////////////////////////////////////////////

 #[derive(Debug, PartialEq)]
 struct Error;

+impl serde::ser::Error for Error {
+    fn custom<T: Into<String>>(_: T) -> Error { Error }
+}
+
 impl serde::de::Error for Error {
-    fn syntax(_: &str) -> Error { Error }
+    fn custom<T: Into<String>>(_: T) -> Error { Error }

    fn end_of_stream() -> Error { Error }
+}

-    fn unknown_field(_field: &str) -> Error { Error }
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        formatter.write_str(format!("{:?}", self).as_ref())
+    }
+}

-    fn missing_field(_field: &'static str) -> Error { Error }
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
 }

 ///////////////////////////////////////////////////////////////////////////////
@@ -34,74 +53,74 @@ impl BytesSerializer {
 impl serde::Serializer for BytesSerializer {
    type Error = Error;

-    fn visit_unit(&mut self) -> Result<(), Error> {
+    fn serialize_unit(&mut self) -> Result<(), Error> {
        Err(Error)
    }

-    fn visit_bool(&mut self, _v: bool) -> Result<(), Error> {
+    fn serialize_bool(&mut self, _v: bool) -> Result<(), Error> {
        Err(Error)
    }

-    fn visit_i64(&mut self, _v: i64) -> Result<(), Error> {
+    fn serialize_i64(&mut self, _v: i64) -> Result<(), Error> {
        Err(Error)
    }

-    fn visit_u64(&mut self, _v: u64) -> Result<(), Error> {
+    fn serialize_u64(&mut self, _v: u64) -> Result<(), Error> {
        Err(Error)
    }

-    fn visit_f32(&mut self, _v: f32) -> Result<(), Error> {
+    fn serialize_f32(&mut self, _v: f32) -> Result<(), Error> {
        Err(Error)
    }

-    fn visit_f64(&mut self, _v: f64) -> Result<(), Error> {
+    fn serialize_f64(&mut self, _v: f64) -> Result<(), Error> {
        Err(Error)
    }

-    fn visit_char(&mut self, _v: char) -> Result<(), Error> {
+    fn serialize_char(&mut self, _v: char) -> Result<(), Error> {
        Err(Error)
    }

-    fn visit_str(&mut self, _v: &str) -> Result<(), Error> {
+    fn serialize_str(&mut self, _v: &str) -> Result<(), Error> {
        Err(Error)
    }

-    fn visit_none(&mut self) -> Result<(), Error> {
+    fn serialize_none(&mut self) -> Result<(), Error> {
        Err(Error)
    }

-    fn visit_some<V>(&mut self, _value: V) -> Result<(), Error>
+    fn serialize_some<V>(&mut self, _value: V) -> Result<(), Error>
        where V: serde::Serialize,
    {
        Err(Error)
    }

-    fn visit_seq<V>(&mut self, _visitor: V) -> Result<(), Error>
+    fn serialize_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>
+    fn serialize_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>
+    fn serialize_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>
+    fn serialize_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> {
+    fn serialize_bytes(&mut self, bytes: &[u8]) -> Result<(), Error> {
        assert_eq!(self.bytes, bytes);
        Ok(())
    }
@@ -124,13 +143,13 @@ impl BytesDeserializer {
 impl serde::Deserializer for BytesDeserializer {
    type Error = Error;

-    fn visit<V>(&mut self, _visitor: V) -> Result<V::Value, Error>
+    fn deserialize<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>
+    fn deserialize_bytes<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
        where V: serde::de::Visitor,
    {
        visitor.visit_byte_buf(self.bytes.take().unwrap())
@@ -1,13 +1,17 @@
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::net;
+use std::path::PathBuf;

-use num::FromPrimitive;
-use num::bigint::{BigInt, BigUint};
-use num::complex::Complex;
-use num::rational::Ratio;
+extern crate fnv;
+use self::fnv::FnvHasher;

-use serde::de::{Deserializer, Visitor};
-
-use token::{Token, assert_de_tokens};
+use token::{
+    Error,
+    Token,
+    assert_de_tokens,
+    assert_de_tokens_ignore,
+    assert_de_tokens_error,
+};

 //////////////////////////////////////////////////////////////////////////

@@ -21,6 +25,7 @@ struct TupleStruct(i32, i32, i32);
 struct Struct {
    a: i32,
    b: i32,
+    #[serde(skip_deserializing)]
    c: i32,
 }

@@ -39,7 +44,11 @@ macro_rules! declare_test {
        #[test]
        fn $name() {
            $(
+                // Test ser/de roundtripping
                assert_de_tokens(&$value, $tokens);
+
+                // Test that the tokens are ignorable
+                assert_de_tokens_ignore($tokens);
            )+
        }
    }
@@ -53,6 +62,17 @@ macro_rules! declare_tests {
    }
 }

+macro_rules! declare_error_tests {
+    ($($name:ident<$target:ident> { $tokens:expr, $expected:expr, })+) => {
+        $(
+            #[test]
+            fn $name() {
+                assert_de_tokens_error::<$target>($tokens, $expected);
+            }
+        )+
+    }
+}
+
 //////////////////////////////////////////////////////////////////////////

 declare_tests! {
@@ -179,27 +199,27 @@ declare_tests! {
        ],
        TupleStruct(1, 2, 3) => vec![
            Token::TupleStructStart("TupleStruct", Some(3)),
-                Token::SeqSep,
+                Token::TupleStructSep,
                Token::I32(1),

-                Token::SeqSep,
+                Token::TupleStructSep,
                Token::I32(2),

-                Token::SeqSep,
+                Token::TupleStructSep,
                Token::I32(3),
-            Token::SeqEnd,
+            Token::TupleStructEnd,
        ],
        TupleStruct(1, 2, 3) => vec![
            Token::TupleStructStart("TupleStruct", None),
-                Token::SeqSep,
+                Token::TupleStructSep,
                Token::I32(1),

-                Token::SeqSep,
+                Token::TupleStructSep,
                Token::I32(2),

-                Token::SeqSep,
+                Token::TupleStructSep,
                Token::I32(3),
-            Token::SeqEnd,
+            Token::TupleStructEnd,
        ],
    }
    test_btreeset {
@@ -267,6 +287,18 @@ declare_tests! {
            Token::TupleStructStart("Anything", Some(0)),
            Token::SeqEnd,
        ],
+        hashset![FnvHasher @ 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![
@@ -314,6 +346,10 @@ declare_tests! {
            Token::SeqStart(Some(0)),
            Token::SeqEnd,
        ],
+        [0; 0] => vec![
+            Token::SeqArrayStart(0),
+            Token::SeqEnd,
+        ],
        ([0; 0], [1], [2, 3]) => vec![
            Token::SeqStart(Some(3)),
                Token::SeqSep,
@@ -336,6 +372,28 @@ declare_tests! {
                Token::SeqEnd,
            Token::SeqEnd,
        ],
+        ([0; 0], [1], [2, 3]) => vec![
+            Token::SeqArrayStart(3),
+                Token::SeqSep,
+                Token::SeqArrayStart(0),
+                Token::SeqEnd,
+
+                Token::SeqSep,
+                Token::SeqArrayStart(1),
+                    Token::SeqSep,
+                    Token::I32(1),
+                Token::SeqEnd,
+
+                Token::SeqSep,
+                Token::SeqArrayStart(2),
+                    Token::SeqSep,
+                    Token::I32(2),
+
+                    Token::SeqSep,
+                    Token::I32(3),
+                Token::SeqEnd,
+            Token::SeqEnd,
+        ],
        [0; 0] => vec![
            Token::UnitStruct("Anything"),
        ],
@@ -363,6 +421,24 @@ declare_tests! {
                Token::I32(3),
            Token::SeqEnd,
        ],
+        (1,) => vec![
+            Token::TupleStart(1),
+                Token::TupleSep,
+                Token::I32(1),
+            Token::TupleEnd,
+        ],
+        (1, 2, 3) => vec![
+            Token::TupleStart(3),
+                Token::TupleSep,
+                Token::I32(1),
+
+                Token::TupleSep,
+                Token::I32(2),
+
+                Token::TupleSep,
+                Token::I32(3),
+            Token::TupleEnd,
+        ],
    }
    test_btreemap {
        BTreeMap::<isize, isize>::new() => vec![
@@ -471,9 +547,53 @@ declare_tests! {
            Token::StructStart("Anything", Some(0)),
            Token::MapEnd,
        ],
+        hashmap![FnvHasher @ 1 => 2, 3 => 4] => vec![
+            Token::MapStart(Some(2)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::I32(2),
+
+                Token::MapSep,
+                Token::I32(3),
+                Token::I32(4),
+            Token::MapEnd,
+        ],
    }
    test_struct {
-        Struct { a: 1, b: 2, c: 3 } => vec![
+        Struct { a: 1, b: 2, c: 0 } => vec![
+            Token::MapStart(Some(3)),
+                Token::MapSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::MapSep,
+                Token::Str("b"),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
+        Struct { a: 1, b: 2, c: 0 } => vec![
+            Token::StructStart("Struct", Some(3)),
+                Token::StructSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::StructSep,
+                Token::Str("b"),
+                Token::I32(2),
+            Token::StructEnd,
+        ],
+        Struct { a: 1, b: 2, c: 0 } => vec![
+            Token::SeqStart(Some(3)),
+                Token::SeqSep,
+                Token::I32(1),
+
+                Token::SeqSep,
+                Token::I32(2),
+            Token::SeqEnd,
+        ],
+    }
+    test_struct_with_skip {
+        Struct { a: 1, b: 2, c: 0 } => vec![
            Token::MapStart(Some(3)),
                Token::MapSep,
                Token::Str("a"),
@@ -486,22 +606,30 @@ declare_tests! {
                Token::MapSep,
                Token::Str("c"),
                Token::I32(3),
+
+                Token::MapSep,
+                Token::Str("d"),
+                Token::I32(4),
            Token::MapEnd,
        ],
-        Struct { a: 1, b: 2, c: 3 } => vec![
+        Struct { a: 1, b: 2, c: 0 } => vec![
            Token::StructStart("Struct", Some(3)),
-                Token::MapSep,
+                Token::StructSep,
                Token::Str("a"),
                Token::I32(1),

-                Token::MapSep,
+                Token::StructSep,
                Token::Str("b"),
                Token::I32(2),

-                Token::MapSep,
+                Token::StructSep,
                Token::Str("c"),
                Token::I32(3),
-            Token::MapEnd,
+
+                Token::StructSep,
+                Token::Str("d"),
+                Token::I32(4),
+            Token::StructEnd,
        ],
    }
    test_enum_unit {
@@ -511,39 +639,39 @@ declare_tests! {
    }
    test_enum_simple {
        Enum::Simple(1) => vec![
-            Token::EnumNewtype("Enum", "Simple"),
+            Token::EnumNewType("Enum", "Simple"),
            Token::I32(1),
        ],
    }
    test_enum_seq {
        Enum::Seq(1, 2, 3) => vec![
            Token::EnumSeqStart("Enum", "Seq", Some(3)),
-                Token::SeqSep,
+                Token::EnumSeqSep,
                Token::I32(1),

-                Token::SeqSep,
+                Token::EnumSeqSep,
                Token::I32(2),

-                Token::SeqSep,
+                Token::EnumSeqSep,
                Token::I32(3),
-            Token::SeqEnd,
+            Token::EnumSeqEnd,
        ],
    }
    test_enum_map {
        Enum::Map { a: 1, b: 2, c: 3 } => vec![
            Token::EnumMapStart("Enum", "Map", Some(3)),
-                Token::MapSep,
+                Token::EnumMapSep,
                Token::Str("a"),
                Token::I32(1),

-                Token::MapSep,
+                Token::EnumMapSep,
                Token::Str("b"),
                Token::I32(2),

-                Token::MapSep,
+                Token::EnumMapSep,
                Token::Str("c"),
                Token::I32(3),
-            Token::MapEnd,
+            Token::EnumMapEnd,
        ],
    }
    test_enum_unit_usize {
@@ -560,33 +688,92 @@ declare_tests! {
            Token::Unit,
        ],
    }
-    test_num_bigint {
-        BigInt::from_i64(123).unwrap() => vec![Token::Str("123")],
-        BigInt::from_i64(-123).unwrap() => vec![Token::Str("-123")],
+    test_box {
+        Box::new(0i32) => vec![Token::I32(0)],
    }
-    test_num_biguint {
-        BigUint::from_i64(123).unwrap() => vec![Token::Str("123")],
-    }
-    test_num_complex {
-        Complex::new(1, 2) => vec![
-            Token::SeqStart(Some(2)),
-                Token::SeqSep,
-                Token::I32(1),
-
-                Token::SeqSep,
-                Token::I32(2),
+    test_boxed_slice {
+        Box::new([0, 1, 2]) => vec![
+            Token::SeqStart(Some(3)),
+            Token::SeqSep,
+            Token::I32(0),
+            Token::SeqSep,
+            Token::I32(1),
+            Token::SeqSep,
+            Token::I32(2),
            Token::SeqEnd,
        ],
    }
-    test_num_ratio {
-        Ratio::new(1, 2) => vec![
-            Token::SeqStart(Some(2)),
-                Token::SeqSep,
-                Token::I32(1),
-
-                Token::SeqSep,
-                Token::I32(2),
-            Token::SeqEnd,
+    test_net_ipv4addr {
+        "1.2.3.4".parse::<net::Ipv4Addr>().unwrap() => vec![Token::Str("1.2.3.4")],
+    }
+    test_net_ipv6addr {
+        "::1".parse::<net::Ipv6Addr>().unwrap() => vec![Token::Str("::1")],
+    }
+    test_net_socketaddr {
+        "1.2.3.4:1234".parse::<net::SocketAddr>().unwrap() => vec![Token::Str("1.2.3.4:1234")],
+        "1.2.3.4:1234".parse::<net::SocketAddrV4>().unwrap() => vec![Token::Str("1.2.3.4:1234")],
+        "[::1]:1234".parse::<net::SocketAddrV6>().unwrap() => vec![Token::Str("[::1]:1234")],
+    }
+    test_path_buf {
+        PathBuf::from("/usr/local/lib") => vec![
+            Token::String("/usr/local/lib".to_owned()),
        ],
    }
 }
+
+#[cfg(feature = "nightly")]
+#[test]
+fn test_net_ipaddr() {
+    assert_de_tokens(
+        "1.2.3.4".parse::<net::IpAddr>().unwrap(),
+        vec![Token::Str("1.2.3.4")],
+    );
+}
+
+declare_error_tests! {
+    test_unknown_variant<Enum> {
+        vec![
+            Token::EnumUnit("Enum", "Foo"),
+        ],
+        Error::UnknownVariantError("Foo".to_owned()),
+    }
+    test_struct_seq_too_long<Struct> {
+        vec![
+            Token::SeqStart(Some(4)),
+                Token::SeqSep, Token::I32(1),
+                Token::SeqSep, Token::I32(2),
+                Token::SeqSep, Token::I32(3),
+                Token::SeqSep, Token::I32(4),
+            Token::SeqEnd,
+        ],
+        Error::UnexpectedToken(Token::SeqSep),
+    }
+    test_duplicate_field_struct<Struct> {
+        vec![
+            Token::MapStart(Some(3)),
+                Token::MapSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::MapSep,
+                Token::Str("a"),
+                Token::I32(3),
+            Token::MapEnd,
+        ],
+        Error::DuplicateFieldError("a"),
+    }
+    test_duplicate_field_enum<Enum> {
+        vec![
+            Token::EnumMapStart("Enum", "Map", Some(3)),
+                Token::EnumMapSep,
+                Token::Str("a"),
+                Token::I32(1),
+
+                Token::EnumMapSep,
+                Token::Str("a"),
+                Token::I32(3),
+            Token::EnumMapEnd,
+        ],
+        Error::DuplicateFieldError("a"),
+    }
+}
@@ -0,0 +1,134 @@
+// These just test that serde_codegen is able to produce code that compiles
+// successfully when there are a variety of generics and non-(de)serializable
+// types involved.
+
+extern crate serde;
+use self::serde::ser::{Serialize, Serializer};
+use self::serde::de::{Deserialize, Deserializer};
+
+//////////////////////////////////////////////////////////////////////////
+
+#[derive(Serialize, Deserialize)]
+struct With<T> {
+    t: T,
+    #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+    x: X,
+}
+
+#[derive(Serialize, Deserialize)]
+struct WithRef<'a, T: 'a> {
+    #[serde(skip_deserializing)]
+    t: Option<&'a T>,
+    #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+    x: X,
+}
+
+#[derive(Serialize, Deserialize)]
+struct Bounds<T: Serialize + Deserialize> {
+    t: T,
+    option: Option<T>,
+    boxed: Box<T>,
+    option_boxed: Option<Box<T>>,
+}
+
+#[derive(Serialize, Deserialize)]
+struct NoBounds<T> {
+    t: T,
+    option: Option<T>,
+    boxed: Box<T>,
+    option_boxed: Option<Box<T>>,
+}
+
+#[derive(Serialize, Deserialize)]
+enum EnumWith<T> {
+    Unit,
+    Newtype(
+        #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+        X),
+    Tuple(
+        T,
+        #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+        X),
+    Struct {
+        t: T,
+        #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+        x: X },
+}
+
+#[derive(Serialize)]
+struct MultipleRef<'a, 'b, 'c, T> where T: 'c, 'c: 'b, 'b: 'a {
+    t: T,
+    rrrt: &'a &'b &'c T,
+}
+
+#[derive(Serialize, Deserialize)]
+struct Newtype(
+    #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+    X
+);
+
+#[derive(Serialize, Deserialize)]
+struct Tuple<T>(
+    T,
+    #[serde(serialize_with="ser_x", deserialize_with="de_x")]
+    X,
+);
+
+#[derive(Serialize, Deserialize)]
+enum TreeNode<D> {
+    Split {
+        left: Box<TreeNode<D>>,
+        right: Box<TreeNode<D>>,
+    },
+    Leaf {
+        data: D,
+    },
+}
+
+#[derive(Serialize, Deserialize)]
+struct ListNode<D> {
+    data: D,
+    next: Box<ListNode<D>>,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(bound="D: SerializeWith + DeserializeWith")]
+struct WithTraits1<D, E> {
+    #[serde(serialize_with="SerializeWith::serialize_with",
+            deserialize_with="DeserializeWith::deserialize_with")]
+    d: D,
+    #[serde(serialize_with="SerializeWith::serialize_with",
+            deserialize_with="DeserializeWith::deserialize_with",
+            bound="E: SerializeWith + DeserializeWith")]
+    e: E,
+}
+
+#[derive(Serialize, Deserialize)]
+#[serde(bound(serialize="D: SerializeWith",
+              deserialize="D: DeserializeWith"))]
+struct WithTraits2<D, E> {
+    #[serde(serialize_with="SerializeWith::serialize_with",
+            deserialize_with="DeserializeWith::deserialize_with")]
+    d: D,
+    #[serde(serialize_with="SerializeWith::serialize_with",
+            bound(serialize="E: SerializeWith"))]
+    #[serde(deserialize_with="DeserializeWith::deserialize_with",
+            bound(deserialize="E: DeserializeWith"))]
+    e: E,
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+trait SerializeWith {
+    fn serialize_with<S: Serializer>(_: &Self, _: &mut S) -> Result<(), S::Error>;
+}
+
+trait DeserializeWith: Sized {
+    fn deserialize_with<D: Deserializer>(_: &mut D) -> Result<Self, D::Error>;
+}
+
+// Implements neither Serialize nor Deserialize
+struct X;
+fn ser_x<S: Serializer>(_: &X, _: &mut S) -> Result<(), S::Error> { panic!() }
+fn de_x<D: Deserializer>(_: &mut D) -> Result<X, D::Error> { panic!() }
+
@@ -1,3 +1,4 @@
+use std::marker::PhantomData;
 use token::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens};

 /*
@@ -6,6 +7,13 @@ trait Trait {
 }
 */

+// That tests that the derived Serialize implementation doesn't trigger
+// any warning about `serializer` not being used, in case of empty enums.
+#[derive(Serialize)]
+#[allow(dead_code)]
+#[deny(unused_variables)]
+enum Void {}
+
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 struct NamedUnit;

@@ -123,7 +131,7 @@ pub struct GenericStruct<T> {
 }

 #[derive(Debug, PartialEq, Serialize, Deserialize)]
-pub struct GenericNewtypeStruct<T>(T);
+pub struct GenericNewTypeStruct<T>(T);

 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 pub struct GenericTupleStruct<T, U>(T, U);
@@ -131,11 +139,24 @@ pub struct GenericTupleStruct<T, U>(T, U);
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
 pub enum GenericEnum<T, U> {
    Unit,
-    Newtype(T),
+    NewType(T),
    Seq(T, U),
    Map { x: T, y: U },
 }

+trait AssociatedType {
+    type X;
+}
+
+impl AssociatedType for i32 {
+    type X = i32;
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct DefaultTyParam<T: AssociatedType<X=i32> = i32> {
+    phantom: PhantomData<T>
+}
+
 #[test]
 fn test_named_unit() {
    assert_tokens(
@@ -153,16 +174,16 @@ fn test_ser_named_tuple() {
        &SerNamedTuple(&a, &mut b, c),
        &[
            Token::TupleStructStart("SerNamedTuple", Some(3)),
-            Token::SeqSep,
+            Token::TupleStructSep,
            Token::I32(5),

-            Token::SeqSep,
+            Token::TupleStructSep,
            Token::I32(6),

-            Token::SeqSep,
+            Token::TupleStructSep,
            Token::I32(7),

-            Token::SeqEnd,
+            Token::TupleStructEnd,
        ],
    );
 }
@@ -172,7 +193,7 @@ fn test_de_named_tuple() {
    assert_de_tokens(
        &DeNamedTuple(5, 6, 7),
        vec![
-            Token::TupleStructStart("DeNamedTuple", Some(3)),
+            Token::SeqStart(Some(3)),
            Token::SeqSep,
            Token::I32(5),

@@ -185,6 +206,23 @@ fn test_de_named_tuple() {
            Token::SeqEnd,
        ]
    );
+
+    assert_de_tokens(
+        &DeNamedTuple(5, 6, 7),
+        vec![
+            Token::TupleStructStart("DeNamedTuple", Some(3)),
+            Token::TupleStructSep,
+            Token::I32(5),
+
+            Token::TupleStructSep,
+            Token::I32(6),
+
+            Token::TupleStructSep,
+            Token::I32(7),
+
+            Token::TupleStructEnd,
+        ]
+    );
 }

 #[test]
@@ -202,19 +240,19 @@ fn test_ser_named_map() {
        &[
            Token::StructStart("SerNamedMap", Some(3)),

-            Token::MapSep,
+            Token::StructSep,
            Token::Str("a"),
            Token::I32(5),

-            Token::MapSep,
+            Token::StructSep,
            Token::Str("b"),
            Token::I32(6),

-            Token::MapSep,
+            Token::StructSep,
            Token::Str("c"),
            Token::I32(7),

-            Token::MapEnd,
+            Token::StructEnd,
        ]
    );
 }
@@ -230,19 +268,19 @@ fn test_de_named_map() {
        vec![
            Token::StructStart("DeNamedMap", Some(3)),

-            Token::MapSep,
+            Token::StructSep,
            Token::Str("a"),
            Token::I32(5),

-            Token::MapSep,
+            Token::StructSep,
            Token::Str("b"),
            Token::I32(6),

-            Token::MapSep,
+            Token::StructSep,
            Token::Str("c"),
            Token::I32(7),

-            Token::MapEnd,
+            Token::StructEnd,
        ]
    );
 }
@@ -278,19 +316,19 @@ fn test_ser_enum_seq() {
        &[
            Token::EnumSeqStart("SerEnum", "Seq", Some(4)),

-            Token::SeqSep,
+            Token::EnumSeqSep,
            Token::I8(1),

-            Token::SeqSep,
+            Token::EnumSeqSep,
            Token::I32(2),

-            Token::SeqSep,
+            Token::EnumSeqSep,
            Token::I32(3),

-            Token::SeqSep,
+            Token::EnumSeqSep,
            Token::I32(5),

-            Token::SeqEnd,
+            Token::EnumSeqEnd,
        ],
    );
 }
@@ -316,23 +354,23 @@ fn test_ser_enum_map() {
        &[
            Token::EnumMapStart("SerEnum", "Map", Some(4)),

-            Token::MapSep,
+            Token::EnumMapSep,
            Token::Str("a"),
            Token::I8(1),

-            Token::MapSep,
+            Token::EnumMapSep,
            Token::Str("b"),
            Token::I32(2),

-            Token::MapSep,
+            Token::EnumMapSep,
            Token::Str("c"),
            Token::I32(3),

-            Token::MapSep,
+            Token::EnumMapSep,
            Token::Str("e"),
            Token::I32(5),

-            Token::MapEnd,
+            Token::EnumMapEnd,
        ],
    );
 }
@@ -368,19 +406,19 @@ fn test_de_enum_seq() {
        vec![
            Token::EnumSeqStart("DeEnum", "Seq", Some(4)),

-            Token::SeqSep,
+            Token::EnumSeqSep,
            Token::I8(1),

-            Token::SeqSep,
+            Token::EnumSeqSep,
            Token::I32(2),

-            Token::SeqSep,
+            Token::EnumSeqSep,
            Token::I32(3),

-            Token::SeqSep,
+            Token::EnumSeqSep,
            Token::I32(5),

-            Token::SeqEnd,
+            Token::EnumSeqEnd,
        ],
    );
 }
@@ -406,23 +444,23 @@ fn test_de_enum_map() {
        vec![
            Token::EnumMapStart("DeEnum", "Map", Some(4)),

-            Token::MapSep,
+            Token::EnumMapSep,
            Token::Str("a"),
            Token::I8(1),

-            Token::MapSep,
+            Token::EnumMapSep,
            Token::Str("b"),
            Token::I32(2),

-            Token::MapSep,
+            Token::EnumMapSep,
            Token::Str("c"),
            Token::I32(3),

-            Token::MapSep,
+            Token::EnumMapSep,
            Token::Str("e"),
            Token::I32(5),

-            Token::MapEnd,
+            Token::EnumMapEnd,
        ],
    );
 }
@@ -434,7 +472,7 @@ fn test_lifetimes() {
    assert_ser_tokens(
        &Lifetimes::LifetimeSeq(&value),
        &[
-            Token::EnumNewtype("Lifetimes", "LifetimeSeq"),
+            Token::EnumNewType("Lifetimes", "LifetimeSeq"),
            Token::I32(5),
        ]
    );
@@ -442,7 +480,7 @@ fn test_lifetimes() {
    assert_ser_tokens(
        &Lifetimes::NoLifetimeSeq(5),
        &[
-            Token::EnumNewtype("Lifetimes", "NoLifetimeSeq"),
+            Token::EnumNewType("Lifetimes", "NoLifetimeSeq"),
            Token::I32(5),
        ]
    );
@@ -452,11 +490,11 @@ fn test_lifetimes() {
        &[
            Token::EnumMapStart("Lifetimes", "LifetimeMap", Some(1)),

-            Token::MapSep,
+            Token::EnumMapSep,
            Token::Str("a"),
            Token::I32(5),

-            Token::MapEnd,
+            Token::EnumMapEnd,
        ]
    );

@@ -465,11 +503,11 @@ fn test_lifetimes() {
        &[
            Token::EnumMapStart("Lifetimes", "NoLifetimeMap", Some(1)),

-            Token::MapSep,
+            Token::EnumMapSep,
            Token::Str("a"),
            Token::I32(5),

-            Token::MapEnd,
+            Token::EnumMapEnd,
        ]
    );
 }
@@ -481,11 +519,11 @@ fn test_generic_struct() {
        vec![
            Token::StructStart("GenericStruct", Some(1)),

-            Token::MapSep,
+            Token::StructSep,
            Token::Str("x"),
            Token::U32(5),

-            Token::MapEnd,
+            Token::StructEnd,
        ]
    );
 }
@@ -493,9 +531,9 @@ fn test_generic_struct() {
 #[test]
 fn test_generic_newtype_struct() {
    assert_tokens(
-        &GenericNewtypeStruct(5u32),
+        &GenericNewTypeStruct(5u32),
        vec![
-            Token::StructNewtype("GenericNewtypeStruct"),
+            Token::StructNewType("GenericNewTypeStruct"),
            Token::U32(5),
        ]
    );
@@ -508,13 +546,13 @@ fn test_generic_tuple_struct() {
        vec![
            Token::TupleStructStart("GenericTupleStruct", Some(2)),

-            Token::SeqSep,
+            Token::TupleStructSep,
            Token::U32(5),

-            Token::SeqSep,
+            Token::TupleStructSep,
            Token::U32(6),

-            Token::SeqEnd,
+            Token::TupleStructEnd,
        ]
    );
 }
@@ -532,9 +570,9 @@ fn test_generic_enum_unit() {
 #[test]
 fn test_generic_enum_newtype() {
    assert_tokens(
-        &GenericEnum::Newtype::<u32, u32>(5),
+        &GenericEnum::NewType::<u32, u32>(5),
        vec![
-            Token::EnumNewtype("GenericEnum", "Newtype"),
+            Token::EnumNewType("GenericEnum", "NewType"),
            Token::U32(5),
        ]
    );
@@ -547,13 +585,13 @@ fn test_generic_enum_seq() {
        vec![
            Token::EnumSeqStart("GenericEnum", "Seq", Some(2)),

-            Token::SeqSep,
+            Token::EnumSeqSep,
            Token::U32(5),

-            Token::SeqSep,
+            Token::EnumSeqSep,
            Token::U32(6),

-            Token::SeqEnd,
+            Token::EnumSeqEnd,
        ]
    );
 }
@@ -565,15 +603,31 @@ fn test_generic_enum_map() {
        vec![
            Token::EnumMapStart("GenericEnum", "Map", Some(2)),

-            Token::MapSep,
+            Token::EnumMapSep,
            Token::Str("x"),
            Token::U32(5),

-            Token::MapSep,
+            Token::EnumMapSep,
            Token::Str("y"),
            Token::U32(6),

-            Token::MapEnd,
+            Token::EnumMapEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_default_ty_param() {
+    assert_tokens(
+        &DefaultTyParam::<i32> { phantom: PhantomData },
+        vec![
+            Token::StructStart("DefaultTyParam", Some(1)),
+
+            Token::StructSep,
+            Token::Str("phantom"),
+            Token::UnitStruct("PhantomData"),
+
+            Token::StructEnd,
        ]
    );
 }
@@ -1,11 +1,12 @@
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::net;
+use std::path::{Path, PathBuf};
+use std::str;

-use num::FromPrimitive;
-use num::bigint::{BigInt, BigUint};
-use num::complex::Complex;
-use num::rational::Ratio;
+use token::{self, Token};

-use token::Token;
+extern crate fnv;
+use self::fnv::FnvHasher;

 //////////////////////////////////////////////////////////////////////////

@@ -74,11 +75,11 @@ declare_ser_tests! {
    }
    test_result {
        Ok::<i32, i32>(0) => &[
-            Token::EnumNewtype("Result", "Ok"),
+            Token::EnumNewType("Result", "Ok"),
            Token::I32(0),
        ],
        Err::<i32, i32>(1) => &[
-            Token::EnumNewtype("Result", "Err"),
+            Token::EnumNewType("Result", "Err"),
            Token::I32(1),
        ],
    }
@@ -102,11 +103,11 @@ declare_ser_tests! {
    }
    test_array {
        [0; 0] => &[
-            Token::SeqStart(Some(0)),
+            Token::SeqArrayStart(0),
            Token::SeqEnd,
        ],
        [1, 2, 3] => &[
-            Token::SeqStart(Some(3)),
+            Token::SeqArrayStart(3),
                Token::SeqSep,
                Token::I32(1),

@@ -146,24 +147,42 @@ declare_ser_tests! {
            Token::SeqEnd,
        ],
    }
-    test_tuple {
-        (1,) => &[
+    test_hashset {
+        HashSet::<isize>::new() => &[
+            Token::SeqStart(Some(0)),
+            Token::SeqEnd,
+        ],
+        hashset![1] => &[
            Token::SeqStart(Some(1)),
                Token::SeqSep,
                Token::I32(1),
            Token::SeqEnd,
        ],
-        (1, 2, 3) => &[
-            Token::SeqStart(Some(3)),
+        hashset![FnvHasher @ 1] => &[
+            Token::SeqStart(Some(1)),
                Token::SeqSep,
                Token::I32(1),
+            Token::SeqEnd,
+        ],
+    }
+    test_tuple {
+        (1,) => &[
+            Token::TupleStart(1),
+                Token::TupleSep,
+                Token::I32(1),
+            Token::TupleEnd,
+        ],
+        (1, 2, 3) => &[
+            Token::TupleStart(3),
+                Token::TupleSep,
+                Token::I32(1),

-                Token::SeqSep,
+                Token::TupleSep,
                Token::I32(2),

-                Token::SeqSep,
+                Token::TupleSep,
                Token::I32(3),
-            Token::SeqEnd,
+            Token::TupleEnd,
        ],
    }
    test_btreemap {
@@ -206,91 +225,146 @@ declare_ser_tests! {
            Token::MapEnd,
        ],
    }
+    test_hashmap {
+        HashMap::<isize, isize>::new() => &[
+            Token::MapStart(Some(0)),
+            Token::MapEnd,
+        ],
+        hashmap![1 => 2] => &[
+            Token::MapStart(Some(1)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
+        hashmap![FnvHasher @ 1 => 2] => &[
+            Token::MapStart(Some(1)),
+                Token::MapSep,
+                Token::I32(1),
+                Token::I32(2),
+            Token::MapEnd,
+        ],
+    }
    test_unit_struct {
        UnitStruct => &[Token::UnitStruct("UnitStruct")],
    }
    test_tuple_struct {
        TupleStruct(1, 2, 3) => &[
            Token::TupleStructStart("TupleStruct", Some(3)),
-                Token::SeqSep,
+                Token::TupleStructSep,
                Token::I32(1),

-                Token::SeqSep,
+                Token::TupleStructSep,
                Token::I32(2),

-                Token::SeqSep,
+                Token::TupleStructSep,
                Token::I32(3),
-            Token::SeqEnd,
+            Token::TupleStructEnd,
        ],
    }
    test_struct {
        Struct { a: 1, b: 2, c: 3 } => &[
            Token::StructStart("Struct", Some(3)),
-                Token::MapSep,
+                Token::StructSep,
                Token::Str("a"),
                Token::I32(1),

-                Token::MapSep,
+                Token::StructSep,
                Token::Str("b"),
                Token::I32(2),

-                Token::MapSep,
+                Token::StructSep,
                Token::Str("c"),
                Token::I32(3),
-            Token::MapEnd,
+            Token::StructEnd,
        ],
    }
    test_enum {
        Enum::Unit => &[Token::EnumUnit("Enum", "Unit")],
-        Enum::One(42) => &[Token::EnumNewtype("Enum", "One"), Token::I32(42)],
+        Enum::One(42) => &[Token::EnumNewType("Enum", "One"), Token::I32(42)],
        Enum::Seq(1, 2) => &[
            Token::EnumSeqStart("Enum", "Seq", Some(2)),
-                Token::SeqSep,
+                Token::EnumSeqSep,
                Token::I32(1),

-                Token::SeqSep,
+                Token::EnumSeqSep,
                Token::I32(2),
-            Token::SeqEnd,
+            Token::EnumSeqEnd,
        ],
        Enum::Map { a: 1, b: 2 } => &[
            Token::EnumMapStart("Enum", "Map", Some(2)),
-                Token::MapSep,
+                Token::EnumMapSep,
                Token::Str("a"),
                Token::I32(1),

-                Token::MapSep,
+                Token::EnumMapSep,
                Token::Str("b"),
                Token::I32(2),
-            Token::MapEnd,
+            Token::EnumMapEnd,
        ],
    }
-    test_num_bigint {
-        BigInt::from_i64(123).unwrap() => &[Token::Str("123")],
-        BigInt::from_i64(-123).unwrap() => &[Token::Str("-123")],
+    test_box {
+        Box::new(0i32) => &[Token::I32(0)],
    }
-    test_num_biguint {
-        BigUint::from_i64(123).unwrap() => &[Token::Str("123")],
-    }
-    test_num_complex {
-        Complex::new(1, 2) => &[
-            Token::SeqStart(Some(2)),
-                Token::SeqSep,
-                Token::I32(1),
-
-                Token::SeqSep,
-                Token::I32(2),
+    test_boxed_slice {
+        Box::new([0, 1, 2]) => &[
+            Token::SeqArrayStart(3),
+            Token::SeqSep,
+            Token::I32(0),
+            Token::SeqSep,
+            Token::I32(1),
+            Token::SeqSep,
+            Token::I32(2),
            Token::SeqEnd,
        ],
    }
-    test_num_ratio {
-        Ratio::new(1, 2) => &[
-            Token::SeqStart(Some(2)),
-                Token::SeqSep,
-                Token::I32(1),
-
-                Token::SeqSep,
-                Token::I32(2),
-            Token::SeqEnd,
+    test_net_ipv4addr {
+        "1.2.3.4".parse::<net::Ipv4Addr>().unwrap() => &[Token::Str("1.2.3.4")],
+    }
+    test_net_ipv6addr {
+        "::1".parse::<net::Ipv6Addr>().unwrap() => &[Token::Str("::1")],
+    }
+    test_net_socketaddr {
+        "1.2.3.4:1234".parse::<net::SocketAddr>().unwrap() => &[Token::Str("1.2.3.4:1234")],
+        "1.2.3.4:1234".parse::<net::SocketAddrV4>().unwrap() => &[Token::Str("1.2.3.4:1234")],
+        "[::1]:1234".parse::<net::SocketAddrV6>().unwrap() => &[Token::Str("[::1]:1234")],
+    }
+    test_path {
+        Path::new("/usr/local/lib") => &[
+            Token::Str("/usr/local/lib"),
+        ],
+    }
+    test_path_buf {
+        PathBuf::from("/usr/local/lib") => &[
+            Token::Str("/usr/local/lib"),
        ],
    }
 }
+
+#[cfg(feature = "nightly")]
+#[test]
+fn test_net_ipaddr() {
+    assert_ser_tokens(
+        "1.2.3.4".parse::<net::IpAddr>().unwrap(),
+        &[Token::Str("1.2.3.4")],
+    );
+}
+
+#[test]
+fn test_cannot_serialize_paths() {
+    let path = unsafe {
+        str::from_utf8_unchecked(b"Hello \xF0\x90\x80World")
+    };
+    token::assert_ser_tokens_error(
+        &Path::new(path),
+        &[Token::Str("Hello �World")],
+        token::Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
+
+    let mut path_buf = PathBuf::new();
+    path_buf.push(path);
+
+    token::assert_ser_tokens_error(
+        &path_buf,
+        &[Token::Str("Hello �World")],
+        token::Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
+}