Merge pull request #254 from erickt/error-custom

feat(errors): Switch Error::custom to use Into<String>

.gitignore

@@ -1,2 +1,3 @@
-target
 Cargo.lock
+target
+*.sw[po]

.travis.yml

@@ -22,9 +22,11 @@ script:
 - |
     (cd serde && travis-cargo build) &&
     (cd serde && travis-cargo test) &&
+    (cd serde && travis-cargo --only nightly test -- --features nightly-testing) &&
     (cd serde_tests && travis-cargo test) &&
-    (cd serde_macros && travis-cargo --only nightly test) &&
-    (cd serde_macros && travis-cargo --only nightly bench) &&
+    (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 serde && travis-cargo --only stable doc) &&
     (cd serde_codegen && travis-cargo --only stable doc)
 

README.md

@@ -1,7 +1,7 @@
 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)
 
@@ -13,9 +13,8 @@ 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/serde/serde/index.html)
+* [serde\_codegen](https://serde-rs.github.io/serde/serde/serde_codegen/serde_codegen/index.html)
 
 Using Serde with Nightly Rust and serde\_macros
 ===============================================
@@ -81,7 +80,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 +100,7 @@ serde_json = "*"
 
 `src/main.rs`:
 
-```rust
+```rust,ignore
 extern crate serde;
 extern crate serde_json;
 
@@ -110,7 +109,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 +128,28 @@ 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");
+
+    let mut registry = syntex::Registry::new();
+
+    serde_codegen::register(&mut registry);
+    registry.expand("", &src, &dst).unwrap();
+}
+```
+
 This also produces:
 
 ```
@@ -168,7 +189,7 @@ serde_macros = { version = "*", optional = true }
 
 `build.rs`:
 
-```rust
+```rust,ignore
 #[cfg(not(feature = "serde_macros"))]
 mod inner {
     extern crate syntex;
@@ -202,7 +223,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 +248,7 @@ Then to run with stable:
 
 Or with nightly:
 
-```rust
+```
 % cargo build --features nightly --no-default-features
 ...
 ```
@@ -237,9 +258,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 +269,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 +298,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 +330,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 +350,7 @@ the fields:
 
 ```rust
 extern crate serde;
+extern crate serde_json;
 
 struct Point {
     x: i32,
@@ -339,7 +361,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 +380,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 +392,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 +406,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 +427,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 +445,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 +464,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 +476,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 +518,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 +527,9 @@ before, we need to generate:
 
 ```rust
 extern crate serde;
+extern crate serde_json;
 
+#[derive(Debug)]
 struct Point {
     x: i32,
     y: i32,
@@ -525,12 +555,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 +569,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 +607,78 @@ 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
+=====================================================================
+
+Serde serialization and deserialization implementations are written in such a
+way that they err on being able to represent more values, and also provide
+better error messages when they are passed an incorrect type to deserialize
+from. For example, by default, it is a syntax error to deserialize a `String`
+into an `Option<String>`. This is implemented such that it is possible to
+distinguish between the values `None` and `Some(())`, if the serialization
+format supports option types.
+
+However, many formats do not have option types, and represents optional values
+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,ignore
+...
+
+    fn visit_none(&mut self) -> Result<(), Self::Error> {
+        self.visit_unit()
+    }
+
+    fn visit_some<T>(&mut self, value: T) -> Result<(), Self::Error> {
+        value.serialize(self)
+    }
+...
+```
+
+For deserialization, this can be implemented by way of the
+`Deserializer::visit_option` hook, which presumes that there is some ability to peek at what is the
+next value in the serialized token stream. This following example is from
+[serde_tests::TokenDeserializer](https://github.com/serde-rs/serde/blob/master/serde_tests/tests/token.rs#L435-L454),
+where it checks to see if the next value is an `Option`, a `()`, or some other
+value:
+
+```rust,ignore
+...
+
+    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+        where V: de::Visitor,
+    {
+        match self.tokens.peek() {
+            Some(&Token::Option(false)) => {
+                self.tokens.next();
+                visitor.visit_none()
+            }
+            Some(&Token::Option(true)) => {
+                self.tokens.next();
+                visitor.visit_some(self)
+            }
+            Some(&Token::Unit) => {
+                self.tokens.next();
+                visitor.visit_none()
+            }
+            Some(_) => visitor.visit_some(self),
+            None => Err(Error::EndOfStreamError),
+        }
+    }
+
+...
 ```
 
 Annotations
@@ -585,22 +687,44 @@ 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. |
+
+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_serializing_if="$path")` | Do not serialize this value if this function `fn(&T) -> bool` returns `false`                              |
+| `#[serde(serialize_with="$path")`      | Call a function `fn<T, S>(&T, &mut S) -> Result<(), S::Error> where S: Serializer` to serialize this value |
+| `#[serde(deserialize_with="$path")`    | Call a function `fn<T, D>(&mut D) -> Result<T, D::Error> where D: Deserializer` to deserialize this value  |
 
 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) |

examples/serde-syntex-example/.gitignore

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

examples/serde-syntex-example/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "serde-syntex-example"
+version = "0.1.0"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+build = "build.rs"
+
+[features]
+default = ["serde_codegen"]
+nightly = ["serde_macros"]
+
+[build-dependencies]
+serde_codegen = { version = "^0.6.4", optional = true }
+syntex = "^0.22.0"
+
+[dependencies]
+serde = "^0.6.1"
+serde_json = "^0.6.0"
+serde_macros = { version = "^0.6.1", optional = true }

examples/serde-syntex-example/README.md

@@ -0,0 +1,20 @@
+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
+     Running `target/debug/serde-syntex-example`
+{"x":1,"y":2}
+Point { x: 1, y: 2 }
+
+% multirust run nightly cargo run
+     Running `target/debug/serde-syntex-example`
+{"x":1,"y":2}
+Point { x: 1, y: 2 }
+```
+
+On nightly, it can use a plugin with:
+
+```
+% multirust run nightly cargo run --features nightly --no-default-features
+```

examples/serde-syntex-example/build.rs

@@ -0,0 +1,29 @@
+#[cfg(not(feature = "serde_macros"))]
+mod inner {
+    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");
+
+        let mut registry = syntex::Registry::new();
+
+        serde_codegen::register(&mut registry);
+        registry.expand("", &src, &dst).unwrap();
+    }
+}
+
+#[cfg(feature = "serde_macros")]
+mod inner {
+    pub fn main() {}
+}
+
+fn main() {
+    inner::main();
+}

examples/serde-syntex-example/src/main.rs

@@ -0,0 +1,11 @@
+#![cfg_attr(nightly, feature(custom_derive, plugin))]
+#![cfg_attr(nightly, plugin(serde_macros))]
+
+extern crate serde;
+extern crate serde_json;
+
+#[cfg(feature = "serde_macros")]
+include!("main.rs.in");
+
+#[cfg(not(feature = "serde_macros"))]
+include!(concat!(env!("OUT_DIR"), "/main.rs"));

examples/serde-syntex-example/src/main.rs.in

@@ -0,0 +1,16 @@
+#[derive(Serialize, Deserialize, Debug)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn main() {
+    let point = Point { x: 1, y: 2 };
+    let serialized = serde_json::to_string(&point).unwrap();
+
+    println!("{}", serialized);
+
+    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
+
+    println!("{:?}", deserialized);
+}

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "0.6.1"
+version = "0.7.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -9,8 +9,9 @@ documentation = "https://serde-rs.github.io/serde/serde/serde/index.html"
 readme = "../README.md"
 keywords = ["serde", "serialization"]
 
-[dependencies]
-num = "^0.1.27"
-
 [features]
 nightly = []
+nightly-testing = ["clippy", "nightly"]
+
+[dependencies]
+clippy = { version = "^0.*", optional = true }

serde/src/bytes.rs

@@ -54,7 +54,7 @@ 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)
     }
 }
 
@@ -140,7 +140,7 @@ impl ser::Serialize for ByteBuf {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: ser::Serializer
     {
-        serializer.visit_bytes(&self)
+        serializer.serialize_bytes(&self)
     }
 }
 
@@ -199,7 +199,7 @@ impl de::Deserialize for ByteBuf {
     fn deserialize<D>(deserializer: &mut D) -> Result<ByteBuf, D::Error>
         where D: de::Deserializer
     {
-        deserializer.visit_bytes(ByteBufVisitor)
+        deserializer.deserialize_bytes(ByteBufVisitor)
     }
 }
 

serde/src/de/from_primitive.rs

@@ -0,0 +1,406 @@
+// 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.
+
+use std::{usize, u8, u16, u32, u64};
+use std::{isize, i8, i16, i32, i64};
+use std::{f32, f64};
+use std::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 = ::std::$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 }

serde/src/de/impls.rs

@@ -14,13 +14,12 @@ use std::collections::{
 use collections::enum_set::{CLike, EnumSet};
 use std::hash::Hash;
 use std::marker::PhantomData;
+use std::net;
 use std::path;
 use std::rc::Rc;
 use std::str;
 use std::sync::Arc;
 
-use num::FromPrimitive;
-
 #[cfg(feature = "nightly")]
 use core::nonzero::{NonZero, Zeroable};
 
@@ -38,6 +37,7 @@ use de::{
     VariantVisitor,
     Visitor,
 };
+use de::from_primitive::FromPrimitive;
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -64,7 +64,7 @@ impl Deserialize for () {
     fn deserialize<D>(deserializer: &mut D) -> Result<(), D::Error>
         where D: Deserializer,
     {
-        deserializer.visit_unit(UnitVisitor)
+        deserializer.deserialize_unit(UnitVisitor)
     }
 }
 
@@ -88,7 +88,7 @@ impl Visitor for BoolVisitor {
         match s.trim() {
             "true" => Ok(true),
             "false" => Ok(false),
-            _ => Err(Error::type_mismatch(Type::Bool)),
+            _ => Err(Error::invalid_type(Type::Bool)),
         }
     }
 }
@@ -97,7 +97,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 +111,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);
@@ -154,7 +154,9 @@ impl<
     fn visit_str<E>(&mut self, v: &str) -> Result<T, E>
         where E: Error,
     {
-        str::FromStr::from_str(v.trim()).or(Err(Error::type_mismatch(Type::Str)))
+        str::FromStr::from_str(v.trim()).or_else(|_| {
+            Err(Error::invalid_type(Type::Str))
+        })
     }
 }
 
@@ -171,18 +173,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);
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -205,7 +207,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)
             }
@@ -220,7 +222,7 @@ 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)
     }
 }
 
@@ -234,7 +236,7 @@ impl Visitor for StringVisitor {
     fn visit_str<E>(&mut self, v: &str) -> Result<String, E>
         where E: Error,
     {
-        Ok(v.to_string())
+        Ok(v.to_owned())
     }
 
     fn visit_string<E>(&mut self, v: String) -> Result<String, E>
@@ -247,17 +249,17 @@ impl Visitor for StringVisitor {
         where E: Error,
     {
         match str::from_utf8(v) {
-            Ok(s) => Ok(s.to_string()),
-            Err(_) => Err(Error::type_mismatch(Type::String)),
+            Ok(s) => Ok(s.to_owned()),
+            Err(_) => Err(Error::invalid_type(Type::String)),
         }
     }
 
-    fn visit_byte_buf<'a, E>(&mut self, v: Vec<u8>) -> Result<String, E>
+    fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<String, E>
         where E: Error,
     {
         match String::from_utf8(v) {
             Ok(s) => Ok(s),
-            Err(_) => Err(Error::type_mismatch(Type::String)),
+            Err(_) => Err(Error::invalid_type(Type::String)),
         }
     }
 }
@@ -266,7 +268,7 @@ 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)
     }
 }
 
@@ -281,6 +283,13 @@ impl<
 > Visitor for OptionVisitor<T> {
     type Value = Option<T>;
 
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<Option<T>, E>
+        where E: Error,
+    {
+        Ok(None)
+    }
+
     #[inline]
     fn visit_none<E>(&mut self) -> Result<Option<T>, E>
         where E: Error,
@@ -300,7 +309,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)
     }
 }
 
@@ -364,7 +400,7 @@ macro_rules! seq_impl {
             fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
                 where D: Deserializer,
             {
-                deserializer.visit_seq($visitor_name::new())
+                deserializer.deserialize_seq($visitor_name::new())
             }
         }
     }
@@ -474,7 +510,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())
     }
 }
 
@@ -520,7 +556,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())
                 }
             }
         )+
@@ -621,7 +657,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())
                 }
             }
         )+
@@ -705,7 +741,7 @@ macro_rules! map_impl {
             fn deserialize<D>(deserializer: &mut D) -> Result<$ty, D::Error>
                 where D: Deserializer,
             {
-                deserializer.visit_map($visitor_name::new())
+                deserializer.deserialize_map($visitor_name::new())
             }
         }
     }
@@ -731,6 +767,83 @@ map_impl!(
 
 ///////////////////////////////////////////////////////////////////////////////
 
+#[cfg(feature = "nightly")]
+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())),
+        }
+    }
+}
+
+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())),
+        }
+    }
+}
+
+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())),
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+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())),
+        }
+    }
+}
+
+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())),
+        }
+    }
+}
+
+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())),
+        }
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 struct PathBufVisitor;
 
 impl Visitor for PathBufVisitor {
@@ -753,7 +866,7 @@ 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)
     }
 }
 
@@ -803,7 +916,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))
@@ -855,14 +968,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)
             }
         }
 
@@ -892,6 +1005,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))
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+/// 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,
+    {
+        struct IgnoredAnyVisitor;
+
+        impl Visitor for IgnoredAnyVisitor {
+            type Value = IgnoredAny;
+
+            #[inline]
+            fn visit_bool<E>(&mut self, _: bool) -> Result<IgnoredAny, E> {
+                Ok(IgnoredAny)
+            }
+
+            #[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,
+            {
+                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)
+            }
+        }
+
+        // TODO maybe not necessary with impl specialization
+        deserializer.deserialize_ignored_any(IgnoredAnyVisitor)
     }
 }

serde/src/de/mod.rs

@@ -1,38 +1,56 @@
 //! Generic deserialization framework.
 
+use std::error;
+
 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;
-
-    /// 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")
-    }
+    fn custom<T: Into<String>>(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.
+    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))
+    }
 }
 
 /// `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,
@@ -106,12 +124,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,
 
@@ -139,272 +163,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)
     }
 }
 
@@ -419,7 +466,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`.
@@ -454,7 +501,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`.
@@ -489,7 +536,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`.
@@ -503,7 +550,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`.
@@ -520,10 +567,12 @@ pub trait Visitor {
     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]
     fn visit_string<E>(&mut self, v: String) -> Result<Self::Value, E>
         where E: Error,
@@ -535,7 +584,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`.
@@ -550,42 +599,42 @@ 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`.
@@ -685,7 +734,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,
     {
@@ -756,7 +805,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
@@ -775,7 +824,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.
@@ -784,7 +833,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))
     }
 }
 
@@ -816,8 +865,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)

serde/src/de/value.rs

@@ -11,7 +11,10 @@ use std::collections::{
     hash_set,
 };
 use std::hash::Hash;
+use std::error;
+use std::fmt;
 use std::vec;
+use std::marker::PhantomData;
 
 use de;
 use bytes;
@@ -21,32 +24,75 @@ 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.
+    Custom(String),
+
+    /// 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.
+    InvalidValue(String),
 
     /// EOF while deserializing a value.
-    EndOfStreamError,
+    EndOfStream,
+
+    /// Unknown variant in enum.
+    UnknownVariant(String),
 
     /// Unknown field in struct.
-    UnknownFieldError(String),
+    UnknownField(String),
 
     /// 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) }
+    fn custom<T: Into<String>>(msg: T) -> Self { Error::Custom(msg.into()) }
+    fn end_of_stream() -> Self { Error::EndOfStream }
+    fn invalid_type(ty: de::Type) -> Self { Error::InvalidType(ty) }
+    fn invalid_value(msg: &str) -> Self { Error::InvalidValue(msg.to_owned()) }
+    fn invalid_length(len: usize) -> Self { Error::InvalidLength(len) }
+    fn unknown_variant(variant: &str) -> Self { Error::UnknownVariant(String::from(variant)) }
+    fn unknown_field(field: &str) -> Self { Error::UnknownField(String::from(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 +100,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 +136,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 +183,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 +209,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 +238,24 @@ impl<'a> de::VariantVisitor for StrDeserializer<'a> {
 ///////////////////////////////////////////////////////////////////////////////
 
 /// A helper deserializer that deserializes a `String`.
-pub struct StringDeserializer(Option<String>);
+pub struct StringDeserializer<E>(Option<String>, PhantomData<E>);
 
-impl ValueDeserializer for String {
-    type Deserializer = StringDeserializer;
+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;
+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 +264,28 @@ 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;
+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 +293,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 +346,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 +361,37 @@ impl<I, T> de::SeqVisitor for SeqDeserializer<I>
 
 ///////////////////////////////////////////////////////////////////////////////
 
-impl<T> ValueDeserializer for Vec<T>
-    where T: ValueDeserializer,
+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,
+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,
+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 +399,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 +456,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 +498,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 +506,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 +527,27 @@ 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,
+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,
+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 +555,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 +618,25 @@ impl<'a> de::Deserializer for BytesDeserializer<'a> {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-impl ValueDeserializer for bytes::ByteBuf
+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>>);
+pub struct ByteBufDeserializer<E>(Option<Vec<u8>>, PhantomData<E>);
 
-impl de::Deserializer for ByteBufDeserializer {
-    type Error = Error;
+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() {

serde/src/lib.rs

@@ -10,12 +10,13 @@
 //! [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, core, enumset, nonzero, step_trait, zero_one))]
+#![cfg_attr(feature = "nightly", feature(collections, enumset, nonzero, plugin, step_trait,
+                                         zero_one))]
+#![cfg_attr(feature = "nightly-testing", plugin(clippy))]
+#![cfg_attr(feature = "nightly-testing", allow(linkedlist))]
 
 #![deny(missing_docs)]
 
-extern crate num;
-
 #[cfg(feature = "nightly")]
 extern crate collections;
 

serde/src/ser/impls.rs

@@ -15,6 +15,7 @@ use collections::enum_set::{CLike, EnumSet};
 use std::hash::Hash;
 #[cfg(feature = "nightly")]
 use std::iter;
+use std::net;
 #[cfg(feature = "nightly")]
 use std::num;
 #[cfg(feature = "nightly")]
@@ -22,11 +23,13 @@ use std::ops;
 use std::path;
 use std::rc::Rc;
 use std::sync::Arc;
+use std::marker::PhantomData;
 
 #[cfg(feature = "nightly")]
 use core::nonzero::{NonZero, Zeroable};
 
 use super::{
+    Error,
     Serialize,
     Serializer,
     SeqVisitor,
@@ -48,20 +51,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,7 +73,7 @@ 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)
     }
 }
 
@@ -91,8 +94,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 +107,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 +122,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 +147,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 +182,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 +204,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 +217,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)
             }
         }
     }
@@ -250,7 +267,7 @@ 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())))
     }
 }
 
@@ -261,7 +278,7 @@ 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())))
     }
 }
 
@@ -273,7 +290,7 @@ 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())))
     }
 }
 
@@ -284,7 +301,7 @@ impl<T> Serialize for HashSet<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())))
     }
 }
 
@@ -295,7 +312,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,7 +326,7 @@ 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))
     }
 }
 
@@ -327,7 +344,7 @@ impl<T> Serialize for VecDeque<T> where T: Serialize {
     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 +355,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 +399,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 +418,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 +547,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,8 +583,8 @@ impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
     {
         match self.iter.next() {
             Some((key, value)) => {
-                let value = try!(serializer.visit_map_elt(key, value));
-                Ok(Some(value))
+                try!(serializer.serialize_map_elt(key, value));
+                Ok(Some(()))
             }
             None => Ok(None)
         }
@@ -589,7 +606,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())))
     }
 }
 
@@ -601,7 +618,7 @@ impl<K, V> Serialize for HashMap<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())))
     }
 }
 
@@ -667,10 +684,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,11 +695,73 @@ impl<T, E> Serialize for Result<T, E> where T: Serialize, E: Serialize {
 
 ///////////////////////////////////////////////////////////////////////////////
 
+#[cfg(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),
+        }
+    }
+}
+
+impl Serialize for net::Ipv4Addr {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_string().serialize(serializer)
+    }
+}
+
+impl Serialize for net::Ipv6Addr {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_string().serialize(serializer)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+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),
+        }
+    }
+}
+
+impl Serialize for net::SocketAddrV4 {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_string().serialize(serializer)
+    }
+}
+
+impl Serialize for net::SocketAddrV6 {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: Serializer,
+    {
+        self.to_string().serialize(serializer)
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 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")),
+        }
     }
 }
 
@@ -690,7 +769,7 @@ 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)
     }
 }
 

serde/src/ser/mod.rs

@@ -1,9 +1,25 @@
 //! Generic serialization framework.
 
+use std::error;
+
 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.
+    fn custom<T: Into<String>>(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 +32,259 @@ 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> {
+    fn serialize_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())
+        self.serialize_str(&v.to_string())
     }
 
-    /// `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,62 +292,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-testing", allow(len_without_is_empty))]
 pub trait SeqVisitor {
     /// Serializes a sequence item in the serializer.
     ///
@@ -338,6 +357,7 @@ pub trait SeqVisitor {
 }
 
 /// A trait that is used by a `Serialize` to iterate through a map.
+#[cfg_attr(feature = "nightly-testing", allow(len_without_is_empty))]
 pub trait MapVisitor {
     /// Serializes a map item in the serializer.
     ///

serde_codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen"
-version = "0.6.2"
+version = "0.7.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
@@ -12,15 +12,17 @@ keywords = ["serde", "serialization"]
 [features]
 default = ["with-syntex"]
 nightly = ["quasi_macros"]
+nightly-testing = ["clippy"]
 with-syntex = ["quasi/with-syntex", "quasi_codegen", "quasi_codegen/with-syntex", "syntex", "syntex_syntax"]
 
 [build-dependencies]
-quasi_codegen = { verision = "^0.3.6", optional = true }
-syntex = { version = "^0.17.0", optional = true }
+quasi_codegen = { version = "^0.7.0", optional = true }
+syntex = { version = "^0.29.0", optional = true }
 
 [dependencies]
-aster = { version = "^0.6.0", default-features = false }
-quasi = { verision = "^0.3.5", default-features = false }
-quasi_macros = { version = "^0.3.5", optional = true }
-syntex = { version = "^0.17.0", optional = true }
-syntex_syntax = { version = "^0.19.1", optional = true }
+aster = { version = "^0.13.1", default-features = false }
+clippy = { version = "^0.*", optional = true }
+quasi = { version = "^0.7.0", default-features = false }
+quasi_macros = { version = "^0.7.0", optional = true }
+syntex = { version = "^0.29.0", optional = true }
+syntex_syntax = { version = "^0.29.0", optional = true }

serde_codegen/src/attr.rs

@@ -1,92 +1,323 @@
-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::fold::Folder;
+use syntax::parse::parser::PathParsingMode;
+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 string expression of the field ident.
+    pub fn ident_expr(&self) -> P<ast::Expr> {
+        AstBuilder::new().expr().str(self.ident)
+    }
+
+    /// 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,
+}
+
+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,
+        };
+
+        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));
+
+                        container_attrs.name.serialize_name = ser_name;
+                        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;
+                    }
+
+                    _ => {
+                        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
+    }
+}
+
+/// 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));
+
+                        variant_attrs.name.serialize_name = ser_name;
+                        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_serializing_field_if: Option<P<ast::Expr>>,
+    default_expr_if_missing: Option<P<ast::Expr>>,
+    serialize_with: Option<P<ast::Expr>>,
+    deserialize_with: Option<P<ast::Expr>>,
 }
 
 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, default: _} => {
-                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,
+                      container_ty: &P<ast::Ty>,
+                      generics: &ast::Generics,
+                      field: &ast::StructField,
+                      is_enum: bool) -> 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.node.ident() {
+            Some(ident) => ident,
+            None => { cx.span_bug(field.span, "struct field has no name?") }
+        };
+
+        let mut field_attrs = FieldAttrs {
+            name: Name::new(field_ident),
+            skip_serializing_field: false,
+            skip_serializing_field_if: None,
+            default_expr_if_missing: None,
+            serialize_with: None,
+            deserialize_with: None,
+        };
+
+        for meta_items in field.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));
+
+                        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{formats: _, 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));
 
-    /// 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)
+                        field_attrs.name.serialize_name = ser_name;
+                        field_attrs.name.deserialize_name = de_name;
+                    }
+
+                    // Parse `#[serde(default)]`
+                    ast::MetaItemKind::Word(ref name) if name == &"default" => {
+                        let default_expr = builder.expr().default();
+                        field_attrs.default_expr_if_missing = Some(default_expr);
+                    }
+
+                    // Parse `#[serde(default="...")]`
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"default" => {
+                        let wrapped_expr = wrap_default(
+                            try!(parse_lit_into_path(cx, name, lit)),
+                        );
+
+                        field_attrs.default_expr_if_missing = Some(wrapped_expr);
+                    }
+
+                    // Parse `#[serde(skip_serializing)]`
+                    ast::MetaItemKind::Word(ref name) if name == &"skip_serializing" => {
+                        field_attrs.skip_serializing_field = true;
+                    }
+
+                    // Parse `#[serde(skip_serializing_if="...")]`
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"skip_serializing_if" => {
+                        let expr = wrap_skip_serializing(
+                            field_ident,
+                            try!(parse_lit_into_path(cx, name, lit)),
+                            is_enum,
+                        );
+
+                        field_attrs.skip_serializing_field_if = Some(expr);
+                    }
+
+                    // Parse `#[serde(serialize_with="...")]`
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"serialize_with" => {
+                        let expr = wrap_serialize_with(
+                            cx,
+                            container_ty,
+                            generics,
+                            field_ident,
+                            try!(parse_lit_into_path(cx, name, lit)),
+                            is_enum,
+                        );
+
+                        field_attrs.serialize_with = Some(expr);
+                    }
+
+                    // Parse `#[serde(deserialize_with="...")]`
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"deserialize_with" => {
+                        let expr = wrap_deserialize_with(
+                            cx,
+                            &field.node.ty,
+                            generics,
+                            try!(parse_lit_into_path(cx, name, lit)),
+                        );
+
+                        field_attrs.deserialize_with = Some(expr);
+                    }
+
+                    _ => {
+                        cx.span_err(
+                            meta_item.span,
+                            &format!("unknown serde field attribute `{}`",
+                                     meta_item_to_string(meta_item)));
+
+                        return Err(Error);
+                    }
+                }
             }
         }
+
+        Ok(field_attrs)
+    }
+
+    pub fn name(&self) -> &Name {
+        &self.name
     }
 
     /// Predicate for using a field's default value
-    pub fn use_default(&self) -> bool {
-        self.use_default
+    pub fn expr_is_missing(&self) -> P<ast::Expr> {
+        match self.default_expr_if_missing {
+            Some(ref expr) => expr.clone(),
+            None => {
+                let name = self.name.ident_expr();
+                AstBuilder::new().expr()
+                    .try()
+                    .method_call("missing_field").id("visitor")
+                        .with_arg(name)
+                        .build()
+            }
+        }
     }
 
     /// Predicate for ignoring a field when serializing a value
@@ -94,152 +325,309 @@ impl FieldAttrs {
         self.skip_serializing_field
     }
 
-    pub fn skip_serializing_field_if_empty(&self) -> bool {
-        self.skip_serializing_field_if_empty
+    pub fn skip_serializing_field_if(&self) -> Option<&P<ast::Expr>> {
+        self.skip_serializing_field_if.as_ref()
     }
 
-    pub fn skip_serializing_field_if_none(&self) -> bool {
-        self.skip_serializing_field_if_none
+    pub fn serialize_with(&self) -> Option<&P<ast::Expr>> {
+        self.serialize_with.as_ref()
+    }
+
+    pub fn deserialize_with(&self) -> Option<&P<ast::Expr>> {
+        self.deserialize_with.as_ref()
     }
 }
 
-pub struct FieldAttrsBuilder<'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,
+
+/// Extract out the `#[serde(...)]` attributes from a struct field.
+pub fn get_struct_field_attrs(cx: &ExtCtxt,
+                              container_ty: &P<ast::Ty>,
+                              generics: &ast::Generics,
+                              fields: &[ast::StructField],
+                              is_enum: bool) -> Result<Vec<FieldAttrs>, Error> {
+    fields.iter()
+        .map(|field| FieldAttrs::from_field(cx, container_ty, generics, field, is_enum))
+        .collect()
 }
 
-impl<'a> FieldAttrsBuilder<'a> {
-    pub fn new(builder: &'a aster::AstBuilder) -> FieldAttrsBuilder<'a> {
-        FieldAttrsBuilder {
-            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_renames(cx: &ExtCtxt,
+               items: &[P<ast::MetaItem>],
+              )-> Result<(Option<InternedString>, Option<InternedString>), Error> {
+    let mut ser_name = None;
+    let mut de_name = None;
 
-    pub fn field(mut self, field: &ast::StructField) -> 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!(get_str_from_lit(cx, name, lit));
+                ser_name = Some(s);
             }
-            ast::UnnamedField(_) => { }
-        };
 
-        self.attrs(&field.node.attrs)
-    }
-
-    pub fn attrs(self, attrs: &[ast::Attribute]) -> FieldAttrsBuilder<'a> {
-        attrs.iter().fold(self, FieldAttrsBuilder::attr)
-    }
-
-    pub fn attr(self, attr: &ast::Attribute) -> FieldAttrsBuilder<'a> {
-        match attr.node.value.node {
-            ast::MetaList(ref name, ref items) if name == &"serde" => {
-                attr::mark_used(&attr);
-                items.iter().fold(self, FieldAttrsBuilder::meta_item)
+            ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"deserialize" => {
+                let s = try!(get_str_from_lit(cx, name, lit));
+                de_name = Some(s);
             }
+
             _ => {
-                self
+                cx.span_err(
+                    item.span,
+                    &format!("unknown rename attribute `{}`",
+                             meta_item_to_string(item)));
+
+                return Err(Error);
             }
         }
     }
 
-    pub fn meta_item(mut self, meta_item: &P<ast::MetaItem>) -> 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_name, de_name))
+}
 
-                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_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
+    }
+}
 
-                            self = self.format_rename(name, expr);
-                        }
-                        _ => { }
-                    }
-                }
-                self
+/// 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" => {
-                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" => {
-                self.skip_serializing_field()
-            }
-            ast::MetaWord(ref name) if name == &"skip_serializing_if_empty" => {
-                self.skip_serializing_field_if_empty()
-            }
-            ast::MetaWord(ref name) if name == &"skip_serializing_if_none" => {
-                self.skip_serializing_field_if_none()
-            }
-            _ => {
-                // Ignore unknown meta variables for now.
-                self
+            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(),
         }
     }
 }
+
+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)));
+
+            return Err(Error);
+        }
+    }
+}
+
+fn parse_lit_into_path(cx: &ExtCtxt, name: &str, lit: &ast::Lit) -> Result<ast::Path, Error> {
+    let source = try!(get_str_from_lit(cx, name, lit));
+
+    // If we just parse the string into an expression, 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 attribute,
+    // and then finally parse them into an expression.
+    let tts = parse::parse_tts_from_source_str(
+        format!("<serde {} expansion>", name),
+        (*source).to_owned(),
+        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 parser.parse_path(PathParsingMode::LifetimeAndTypesWithoutColons) {
+        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);
+        }
+    }
+
+    Ok(path)
+}
+
+/// This function wraps the expression in `#[serde(default="...")]` in a function to prevent it
+/// from accessing the internal `Deserialize` state.
+fn wrap_default(path: ast::Path) -> P<ast::Expr> {
+    AstBuilder::new().expr().call()
+        .build_path(path)
+        .build()
+}
+
+/// This function wraps the expression in `#[serde(skip_serializing_if="...")]` in a trait to
+/// prevent it from accessing the internal `Serialize` state.
+fn wrap_skip_serializing(field_ident: ast::Ident,
+                         path: ast::Path,
+                         is_enum: bool) -> P<ast::Expr> {
+    let builder = AstBuilder::new();
+
+    let expr = builder.expr()
+        .field(field_ident)
+        .field("value")
+        .self_();
+
+    let expr = if is_enum {
+        expr
+    } else {
+        builder.expr().ref_().build(expr)
+    };
+
+    builder.expr().call()
+        .build_path(path)
+        .arg().build(expr)
+        .build()
+}
+
+/// This function wraps the expression in `#[serde(serialize_with="...")]` in a trait to
+/// prevent it from accessing the internal `Serialize` state.
+fn wrap_serialize_with(cx: &ExtCtxt,
+                       container_ty: &P<ast::Ty>,
+                       generics: &ast::Generics,
+                       field_ident: ast::Ident,
+                       path: ast::Path,
+                       is_enum: bool) -> P<ast::Expr> {
+    let builder = AstBuilder::new();
+
+    let expr = builder.expr()
+        .field(field_ident)
+        .self_();
+
+    let expr = if is_enum {
+        expr
+    } else {
+        builder.expr().ref_().build(expr)
+    };
+
+    let expr = builder.expr().call()
+        .build_path(path)
+        .arg().build(expr)
+        .arg()
+            .id("serializer")
+        .build();
+
+    let where_clause = &generics.where_clause;
+
+    quote_expr!(cx, {
+        trait __SerdeSerializeWith {
+            fn __serde_serialize_with<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+                where S: ::serde::ser::Serializer;
+        }
+
+        impl<'a, T> __SerdeSerializeWith for &'a T
+            where T: 'a + __SerdeSerializeWith,
+        {
+            fn __serde_serialize_with<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+                where S: ::serde::ser::Serializer
+            {
+                (**self).__serde_serialize_with(serializer)
+            }
+        }
+
+        impl $generics __SerdeSerializeWith for $container_ty $where_clause {
+            fn __serde_serialize_with<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+                where S: ::serde::ser::Serializer
+            {
+                $expr
+            }
+        }
+
+        struct __SerdeSerializeWithStruct<'a, T: 'a> {
+            value: &'a T,
+        }
+
+        impl<'a, T> ::serde::ser::Serialize for __SerdeSerializeWithStruct<'a, T>
+            where T: 'a + __SerdeSerializeWith
+        {
+            fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+                where S: ::serde::ser::Serializer
+            {
+                self.value.__serde_serialize_with(serializer)
+            }
+        }
+
+        __SerdeSerializeWithStruct {
+            value: &self.value,
+        }
+    })
+}
+
+/// This function wraps the expression in `#[serde(deserialize_with="...")]` in a trait to prevent
+/// it from accessing the internal `Deserialize` state.
+fn wrap_deserialize_with(cx: &ExtCtxt,
+                         field_ty: &P<ast::Ty>,
+                         generics: &ast::Generics,
+                         path: ast::Path) -> P<ast::Expr> {
+    // Quasi-quoting doesn't do a great job of expanding generics into paths, so manually build it.
+    let ty_path = AstBuilder::new().path()
+        .segment("__SerdeDeserializeWithStruct")
+            .with_generics(generics.clone())
+            .build()
+        .build();
+
+    let where_clause = &generics.where_clause;
+
+    quote_expr!(cx, {
+        struct __SerdeDeserializeWithStruct $generics $where_clause {
+            value: $field_ty,
+        }
+
+        impl $generics ::serde::de::Deserialize for $ty_path $where_clause {
+            fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
+                where D: ::serde::de::Deserializer
+            {
+                let value = try!($path(deserializer));
+                Ok(__SerdeDeserializeWithStruct { value: value })
+            }
+        }
+
+        let value: $ty_path = try!(visitor.visit_value());
+        Ok(value.value)
+    })
+}

serde_codegen/src/error.rs

@@ -0,0 +1,2 @@
+/// Error returned if failed to parse attribute.
+pub struct Error;

serde_codegen/src/field.rs

@@ -1,17 +0,0 @@
-use syntax::ast;
-use syntax::ext::base::ExtCtxt;
-
-use aster;
-use attr::{FieldAttrs, FieldAttrsBuilder};
-
-pub fn struct_field_attrs(
-    _cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    fields: &[ast::StructField],
-) -> Vec<FieldAttrs> {
-    fields.iter()
-        .map(|field| {
-            FieldAttrsBuilder::new(builder).field(field).build()
-        })
-        .collect()
-}

serde_codegen/src/lib.rs

@@ -1,3 +1,6 @@
+#![cfg_attr(feature = "nightly-testing", plugin(clippy))]
+#![cfg_attr(feature = "nightly-testing", feature(plugin))]
+#![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))]
 
@@ -14,7 +17,10 @@ extern crate syntex_syntax as syntax;
 extern crate syntax;
 
 #[cfg(not(feature = "with-syntex"))]
-extern crate rustc;
+extern crate rustc_plugin;
+
+#[cfg(not(feature = "with-syntex"))]
+use syntax::feature_gate::AttributeType;
 
 #[cfg(feature = "with-syntex")]
 include!(concat!(env!("OUT_DIR"), "/lib.rs"));
@@ -26,14 +32,6 @@ include!("lib.rs.in");
 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 {
@@ -43,7 +41,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; }
                     _ => {}
                 }
 
@@ -57,10 +55,18 @@ 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"))]
-pub fn register(reg: &mut rustc::plugin::Registry) {
+pub fn register(reg: &mut rustc_plugin::Registry) {
     reg.register_syntax_extension(
         syntax::parse::token::intern("derive_Serialize"),
         syntax::ext::base::MultiDecorator(
@@ -70,4 +76,6 @@ pub fn register(reg: &mut rustc::plugin::Registry) {
         syntax::parse::token::intern("derive_Deserialize"),
         syntax::ext::base::MultiDecorator(
             Box::new(de::expand_derive_deserialize)));
+
+    reg.register_attribute("serde".to_owned(), AttributeType::Normal);
 }

serde_codegen/src/lib.rs.in

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

serde_codegen/src/ser.rs

@@ -4,7 +4,6 @@ use syntax::ast::{
     Ident,
     MetaItem,
     Item,
-    Expr,
 };
 use syntax::ast;
 use syntax::codemap::Span;
@@ -12,7 +11,8 @@ use syntax::ext::base::{Annotatable, ExtCtxt};
 use syntax::ext::build::AstBuilder;
 use syntax::ptr::P;
 
-use field::struct_field_attrs;
+use attr;
+use error::Error;
 
 pub fn expand_derive_serialize(
     cx: &mut ExtCtxt,
@@ -26,17 +26,38 @@ pub fn expand_derive_serialize(
         _ => {
             cx.span_err(
                 meta_item.span,
-                "`derive` may only be applied to structs and enums");
+                "`#[derive(Serialize)]` may only be applied to structs and enums");
             return;
         }
     };
 
     let builder = aster::AstBuilder::new().span(span);
 
+    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::ItemStruct(_, ref generics) => generics,
-        ast::ItemEnum(_, ref generics) => generics,
-        _ => cx.bug("expected ItemStruct or ItemEnum in #[derive(Serialize)]")
+        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 impl_generics = builder.from_generics(generics.clone())
@@ -49,18 +70,15 @@ pub fn expand_derive_serialize(
         .segment(item.ident).with_generics(impl_generics.clone()).build()
         .build();
 
-    let body = serialize_body(
-        cx,
-        &builder,
-        &item,
-        &impl_generics,
-        ty.clone(),
-    );
+    let body = try!(serialize_body(cx,
+                                   &builder,
+                                   &item,
+                                   &impl_generics,
+                                   ty.clone()));
 
     let where_clause = &impl_generics.where_clause;
 
-    let impl_item = quote_item!(cx,
-        #[automatically_derived]
+    Ok(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,
@@ -68,9 +86,7 @@ pub fn expand_derive_serialize(
                 $body
             }
         }
-    ).unwrap();
-
-    push(Annotatable::Item(impl_item))
+    ).unwrap())
 }
 
 fn serialize_body(
@@ -79,19 +95,22 @@ fn serialize_body(
     item: &Item,
     impl_generics: &ast::Generics,
     ty: P<ast::Ty>,
-) -> P<ast::Expr> {
+) -> Result<P<ast::Expr>, Error> {
+    let container_attrs = try!(attr::ContainerAttrs::from_item(cx, item));
+
     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,
@@ -99,61 +118,64 @@ fn serialize_body(
                 impl_generics,
                 ty,
                 enum_def,
+                &container_attrs,
             )
         }
-        _ => cx.bug("expected ItemStruct or ItemEnum in #[derive(Serialize)]")
+        _ => {
+            cx.span_bug(item.span,
+                        "expected ItemStruct or ItemEnum in #[derive(Serialize)]");
+        }
     }
 }
 
 fn serialize_item_struct(
     cx: &ExtCtxt,
     builder: &aster::AstBuilder,
-    item: &Item,
     impl_generics: &ast::Generics,
     ty: P<ast::Ty>,
+    span: Span,
     variant_data: &ast::VariantData,
-) -> 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,
+                container_attrs,
             )
         }
         ast::VariantData::Tuple(ref fields, _) => {
             if fields.iter().any(|field| !field.node.kind.is_unnamed()) {
-                cx.bug("tuple struct has named fields")
+                cx.span_bug(span, "tuple struct has named fields")
             }
 
             serialize_tuple_struct(
                 cx,
                 &builder,
-                item.ident,
                 impl_generics,
                 ty,
                 fields.len(),
+                container_attrs,
             )
         }
         ast::VariantData::Struct(ref fields, _) => {
             if fields.iter().any(|field| field.node.kind.is_unnamed()) {
-                cx.bug("struct has unnamed fields")
+                cx.span_bug(span, "struct has unnamed fields")
             }
 
             serialize_struct(
                 cx,
                 &builder,
-                item.ident,
                 impl_generics,
                 ty,
                 fields,
+                container_attrs,
             )
         }
     }
@@ -161,32 +183,34 @@ fn serialize_item_struct(
 
 fn serialize_unit_struct(
     cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    type_ident: Ident
-) -> 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();
 
-    quote_expr!(cx, serializer.visit_unit_struct($type_name))
+    Ok(quote_expr!(cx,
+        serializer.serialize_unit_struct($type_name)
+    ))
 }
 
 fn serialize_newtype_struct(
     cx: &ExtCtxt,
-    builder: &aster::AstBuilder,
-    type_ident: Ident
-) -> P<ast::Expr> {
-    let type_name = builder.expr().str(type_ident);
+    container_attrs: &attr::ContainerAttrs,
+) -> Result<P<ast::Expr>, Error> {
+    let type_name = container_attrs.name().serialize_name_expr();
 
-    quote_expr!(cx, serializer.visit_newtype_struct($type_name, &self.0))
+    Ok(quote_expr!(cx,
+        serializer.serialize_newtype_struct($type_name, &self.0)
+    ))
 }
 
 fn serialize_tuple_struct(
     cx: &ExtCtxt,
     builder: &aster::AstBuilder,
-    type_ident: Ident,
     impl_generics: &ast::Generics,
     ty: P<ast::Ty>,
     fields: usize,
-) -> P<ast::Expr> {
+    container_attrs: &attr::ContainerAttrs,
+) -> Result<P<ast::Expr>, Error> {
     let (visitor_struct, visitor_impl) = serialize_tuple_struct_visitor(
         cx,
         builder,
@@ -195,32 +219,33 @@ fn serialize_tuple_struct(
             .ref_()
             .lifetime("'__a")
             .build_ty(ty.clone()),
+        builder.id("serialize_tuple_struct_elt"),
         fields,
         impl_generics,
     );
 
-    let type_name = builder.expr().str(type_ident);
+    let type_name = container_attrs.name().serialize_name_expr();
 
-    quote_expr!(cx, {
+    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>,
         })
-    })
+    }))
 }
 
 fn serialize_struct(
     cx: &ExtCtxt,
     builder: &aster::AstBuilder,
-    type_ident: Ident,
     impl_generics: &ast::Generics,
     ty: P<ast::Ty>,
     fields: &[ast::StructField],
-) -> P<ast::Expr> {
-    let (visitor_struct, visitor_impl) = serialize_struct_visitor(
+    container_attrs: &attr::ContainerAttrs,
+) -> Result<P<ast::Expr>, Error> {
+    let (visitor_struct, visitor_impl) = try!(serialize_struct_visitor(
         cx,
         builder,
         ty.clone(),
@@ -228,25 +253,23 @@ fn serialize_struct(
             .ref_()
             .lifetime("'__a")
             .build_ty(ty.clone()),
+        builder.id("serialize_struct_elt"),
         fields,
         impl_generics,
-        fields.iter().map(|field| {
-            let name = field.node.ident().expect("struct has unnamed field");
-            quote_expr!(cx, &self.value.$name)
-        })
-    );
+        false,
+    ));
 
-    let type_name = builder.expr().str(type_ident);
+    let type_name = container_attrs.name().serialize_name_expr();
 
-    quote_expr!(cx, {
+    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>,
         })
-    })
+    }))
 }
 
 fn serialize_item_enum(
@@ -256,27 +279,31 @@ fn serialize_item_enum(
     impl_generics: &ast::Generics,
     ty: P<ast::Ty>,
     enum_def: &ast::EnumDef,
-) -> P<ast::Expr> {
-    let arms: Vec<ast::Arm> = enum_def.variants.iter()
-        .enumerate()
-        .map(|(variant_index, variant)| {
-            serialize_variant(
-                cx,
-                builder,
-                type_ident,
-                impl_generics,
-                ty.clone(),
-                variant,
-                variant_index,
-            )
-        })
-        .collect();
+    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()
+    );
 
-    quote_expr!(cx,
+    Ok(quote_expr!(cx,
         match *self {
             $arms
         }
-    )
+    ))
 }
 
 fn serialize_variant(
@@ -287,27 +314,30 @@ fn serialize_variant(
     ty: P<ast::Ty>,
     variant: &ast::Variant,
     variant_index: usize,
-) -> 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()
+            let pat = builder.pat().path()
+                .id(type_ident).id(variant_ident)
                 .build();
 
-            quote_arm!(cx,
+            Ok(quote_arm!(cx,
                 $pat => {
-                    ::serde::ser::Serializer::visit_unit_variant(
+                    ::serde::ser::Serializer::serialize_unit_variant(
                         serializer,
                         $type_name,
                         $variant_index,
                         $variant_name,
                     )
                 }
-            )
+            ))
         },
         ast::VariantData::Tuple(ref fields, _) if fields.len() == 1 => {
             let field = builder.id("__simple_value");
@@ -316,9 +346,10 @@ fn serialize_variant(
                 .id(type_ident).id(variant_ident).build()
                 .with_pats(Some(field).into_iter())
                 .build();
-            quote_arm!(cx,
+
+            Ok(quote_arm!(cx,
                 $pat => {
-                    ::serde::ser::Serializer::visit_newtype_variant(
+                    ::serde::ser::Serializer::serialize_newtype_variant(
                         serializer,
                         $type_name,
                         $variant_index,
@@ -326,7 +357,7 @@ fn serialize_variant(
                         __simple_value,
                     )
                 }
-            )
+            ))
         },
         ast::VariantData::Tuple(ref fields, _) => {
             let field_names: Vec<ast::Ident> = (0 .. fields.len())
@@ -353,7 +384,9 @@ fn serialize_variant(
                 field_names,
             );
 
-            quote_arm!(cx, $pat => { $expr })
+            Ok(quote_arm!(cx,
+                $pat => { $expr }
+            ))
         }
         ast::VariantData::Struct(ref fields, _) => {
             let field_names: Vec<_> = (0 .. fields.len())
@@ -369,7 +402,7 @@ fn serialize_variant(
                             let name = match field.node.kind {
                                 ast::NamedField(name, _) => name,
                                 ast::UnnamedField(_) => {
-                                    cx.bug("struct variant has unnamed fields")
+                                    cx.span_bug(field.span, "struct variant has unnamed fields")
                                 }
                             };
 
@@ -378,19 +411,21 @@ fn serialize_variant(
                 )
                 .build();
 
-            let expr = serialize_struct_variant(
+            let expr = try!(serialize_struct_variant(
                 cx,
                 builder,
-                type_name,
                 variant_index,
                 variant_name,
                 generics,
                 ty,
                 fields,
                 field_names,
-            );
+                container_attrs,
+            ));
 
-            quote_arm!(cx, $pat => { $expr })
+            Ok(quote_arm!(cx,
+                $pat => { $expr }
+            ))
         }
     }
 }
@@ -422,6 +457,7 @@ fn serialize_tuple_variant(
         builder,
         structure_ty.clone(),
         variant_ty,
+        builder.id("serialize_tuple_variant_elt"),
         fields.len(),
         generics,
     );
@@ -437,7 +473,7 @@ fn serialize_tuple_variant(
     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>,
@@ -448,56 +484,90 @@ fn serialize_tuple_variant(
 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>,
-) -> P<ast::Expr> {
-    let value_ty = builder.ty().tuple()
-        .with_tys(
+    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 variant_struct = builder.item().struct_("__VariantStruct")
+        .with_generics(variant_generics.clone())
+        .with_fields(
             fields.iter().map(|field| {
-                builder.ty()
+                builder.struct_field(field.node.ident().expect("struct has unnamed fields"))
+                    .with_attrs(field.node.attrs.iter().cloned())
+                    .ty()
                     .ref_()
-                    .lifetime("'__a")
+                    .lifetime("'__serde_variant")
                     .build_ty(field.node.ty.clone())
             })
         )
+        .field("__serde_container_ty")
+            .ty().phantom_data().build(ty.clone())
         .build();
 
-    let value_expr = builder.expr().tuple()
-        .with_exprs(
-            field_names.iter().map(|field| {
-                builder.expr().id(field)
-            })
+    let variant_expr = builder.expr().struct_id("__VariantStruct")
+        .with_id_exprs(
+            fields.iter()
+                .zip(field_names.iter())
+                .map(|(field, field_name)| {
+                    (
+                        field.node.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 (visitor_struct, visitor_impl) = serialize_struct_visitor(
+    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,
+    ));
 
-    quote_expr!(cx, {
+    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,
+            },
+        )
+    }))
 }
 
 fn serialize_tuple_struct_visitor(
@@ -505,20 +575,21 @@ fn serialize_tuple_struct_visitor(
     builder: &aster::AstBuilder,
     structure_ty: P<ast::Ty>,
     variant_ty: P<ast::Ty>,
+    serializer_method: ast::Ident,
     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_();
+            let expr = builder.expr().method_call(serializer_method)
+                .id("serializer")
+                .arg().ref_().tup_field(i).field("value").self_()
+                .build();
 
             quote_arm!(cx,
                 $i => {
                     self.state += 1;
-                    let v = try!(serializer.visit_tuple_struct_elt(&$expr));
-                    Ok(Some(v))
+                    Ok(Some(try!($expr)))
                 }
             )
         })
@@ -567,51 +638,48 @@ fn serialize_tuple_struct_visitor(
     )
 }
 
-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,
-) -> (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 field_attrs = try!(
+        attr::get_struct_field_attrs(cx, &structure_ty, generics, fields, is_enum)
+    );
 
-    let field_attrs = 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.iter().zip(field_attrs.iter())
+        .filter(|&(_, ref field_attr)| !field_attr.skip_serializing_field())
         .enumerate()
-        .map(|(i, (ref field, value_expr))| {
-            let key_expr = field.serializer_key_expr(cx);
+        .map(|(i, (ref field, ref field_attr))| {
+            let name = field.node.ident().expect("struct has unnamed field");
 
-            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; })
+            let key_expr = field_attr.name().serialize_name_expr();
+
+            let stmt = if let Some(expr) = field_attr.skip_serializing_field_if() {
+                    Some(quote_stmt!(cx, if $expr { continue; }))
             } else {
-                quote_stmt!(cx, {})
+                None
             };
 
+            let field_expr = match field_attr.serialize_with() {
+                Some(expr) => expr.clone(),
+                None => quote_expr!(cx, &self.value.$name),
+            };
+
+            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,
-                                )
-                            )
-                        )
-                    );
+                    return Ok(Some(try!($expr)));
                 }
             )
         })
@@ -629,21 +697,20 @@ fn serialize_struct_visitor<I>(
         .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)
+        .filter(|field_attr| !field_attr.skip_serializing_field())
+        .map(|field_attr| {
+            match field_attr.skip_serializing_field_if() {
+                Some(expr) => {
+                    quote_expr!(cx, if $expr { 0 } else { 1 })
+                }
+                None => {
+                    quote_expr!(cx, 1)
+                }
             }
         })
         .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr));
 
-    (
+    Ok((
         quote_item!(cx,
             struct Visitor $visitor_impl_generics $where_clause {
                 state: usize,
@@ -675,5 +742,5 @@ fn serialize_struct_visitor<I>(
                 }
             }
         ).unwrap(),
-    )
+    ))
 }

serde_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_macros"
-version = "0.6.1"
+version = "0.7.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
@@ -12,10 +12,22 @@ keywords = ["serde", "serialization"]
 name = "serde_macros"
 plugin = true
 
+[features]
+nightly-testing = ["clippy", "serde/nightly-testing", "serde_codegen/nightly-testing"]
+
 [dependencies]
-serde_codegen = { version = "*", path = "../serde_codegen", default-features = false, features = ["nightly"] }
+clippy = { version = "^0.*", optional = true }
+serde_codegen = { version = "^0.7.0", path = "../serde_codegen", default-features = false, features = ["nightly"] }
 
 [dev-dependencies]
-num = "^0.1.27"
+compiletest_rs = "^0.0.11"
 rustc-serialize = "^0.3.16"
-serde = { version = "*", path = "../serde", features = ["nightly"] }
+serde = { version = "^0.7.0", path = "../serde" }
+
+[[test]]
+name = "test"
+path = "tests/test.rs"
+
+[[bench]]
+name = "bench"
+path = "benches/bench.rs"

serde_macros/benches/bench.rs

@@ -1,7 +1,7 @@
 #![feature(custom_attribute, custom_derive, plugin, test)]
+#![cfg_attr(feature = "clippy", plugin(clippy))]
 #![plugin(serde_macros)]
 
-extern crate num;
 extern crate rustc_serialize;
 extern crate serde;
 extern crate test;

serde_macros/src/lib.rs

@@ -1,10 +1,12 @@
 #![feature(plugin_registrar, rustc_private)]
+#![cfg_attr(feature = "clippy", feature(plugin))]
+#![cfg_attr(feature = "clippy", plugin(clippy))]
 
 extern crate serde_codegen;
-extern crate rustc;
+extern crate rustc_plugin;
 
 #[plugin_registrar]
 #[doc(hidden)]
-pub fn plugin_registrar(reg: &mut rustc::plugin::Registry) {
+pub fn plugin_registrar(reg: &mut rustc_plugin::Registry) {
     serde_codegen::register(reg);
 }

serde_macros/tests/compile-fail/reject-unknown-attributes.rs

@@ -0,0 +1,30 @@
+#![feature(custom_attribute, custom_derive, plugin)]
+#![plugin(serde_macros)]
+
+extern crate serde;
+
+#[derive(Serialize)]
+#[serde(abc="xyz")] //~ unknown serde container attribute `abc = "xyz"`
+struct Foo {
+    x: u32,
+}
+
+#[derive(Deserialize)]
+#[serde(abc="xyz")] //~ unknown serde container attribute `abc = "xyz"`
+struct Foo {
+    x: u32,
+}
+
+#[derive(Serialize)]
+struct Foo {
+    #[serde(abc="xyz")] //~ unknown serde field attribute `abc = "xyz"`
+    x: u32,
+}
+
+#[derive(Deserialize)]
+struct Foo {
+    #[serde(abc="xyz")] //~ unknown serde field attribute `abc = "xyz"`
+    x: u32,
+}
+
+fn main() { }

serde_macros/tests/compile_tests.rs

@@ -0,0 +1,25 @@
+extern crate compiletest_rs as compiletest;
+
+use std::path::PathBuf;
+use std::env::var;
+
+fn run_mode(mode: &'static str) {
+    let mut config = compiletest::default_config();
+
+    let cfg_mode = mode.parse().ok().expect("Invalid mode");
+
+    config.target_rustcflags = Some("-L target/debug/ -L target/debug/deps/".to_owned());
+    if let Ok(name) = var::<&str>("TESTNAME") {
+        let s : String = name.to_owned();
+        config.filter = Some(s)
+    }
+    config.mode = cfg_mode;
+    config.src_base = PathBuf::from(format!("tests/{}", mode));
+
+    compiletest::run_tests(&config);
+}
+
+#[test]
+fn compile_test() {
+    run_mode("compile-fail");
+}

serde_macros/tests/test.rs

@@ -5,3 +5,5 @@ extern crate serde;
 extern crate test;
 
 include!("../../serde_tests/tests/test.rs.in");
+
+mod compile_tests;

serde_tests/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_tests"
-version = "0.6.2"
+version = "0.6.3"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -10,16 +10,21 @@ readme = "README.md"
 keywords = ["serialization"]
 build = "build.rs"
 
+[features]
+nightly-testing = ["clippy", "serde/nightly-testing", "serde_codegen/nightly-testing"]
+
 [build-dependencies]
-syntex = { version = "^0.17.0" }
-syntex_syntax = { version = "^0.19.1" }
+syntex = { version = "^0.29.0" }
+syntex_syntax = { version = "^0.29.0" }
 serde_codegen = { version = "*", path = "../serde_codegen", features = ["with-syntex"] }
 
 [dev-dependencies]
-num = "^0.1.27"
 rustc-serialize = "^0.3.16"
 serde = { version = "*", path = "../serde" }
-syntex = "^0.17.0"
+syntex = "^0.29.0"
+
+[dependencies]
+clippy = { version = "^0.*", optional = true }
 
 [[test]]
 name = "test"

serde_tests/benches/bench.rs

@@ -1,6 +1,7 @@
 #![feature(test)]
+#![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;

serde_tests/benches/bench_enum.rs

@@ -1,4 +1,6 @@
 use test::Bencher;
+use std::error;
+use std::fmt;
 use rustc_serialize::{Decoder, Decodable};
 use serde;
 use serde::de::{Deserializer, 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)
             }
         }
 
@@ -415,7 +432,7 @@ fn bench_decoder_dog(b: &mut Bencher) {
 #[bench]
 fn bench_decoder_frog(b: &mut Bencher) {
     b.iter(|| {
-        let animal = Animal::Frog("Henry".to_string(), 349);
+        let animal = Animal::Frog("Henry".to_owned(), 349);
 
         let mut d = decoder::AnimalDecoder::new(animal.clone());
         let value: Animal = Decodable::decode(&mut d).unwrap();
@@ -439,7 +456,7 @@ fn bench_deserializer_dog(b: &mut Bencher) {
 #[bench]
 fn bench_deserializer_frog(b: &mut Bencher) {
     b.iter(|| {
-        let animal = Animal::Frog("Henry".to_string(), 349);
+        let animal = Animal::Frog("Henry".to_owned(), 349);
 
         let mut d = deserializer::AnimalDeserializer::new(animal.clone());
         let value: Animal = Deserialize::deserialize(&mut d).unwrap();

serde_tests/benches/bench_map.rs

@@ -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)

serde_tests/benches/bench_struct.rs

@@ -1,5 +1,7 @@
 use std::collections::HashMap;
 use test::Bencher;
+use std::fmt;
+use std::error;
 
 use rustc_serialize::{Decoder, Decodable};
 
@@ -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(()),
             }
         }
@@ -614,7 +619,7 @@ mod deserializer {
 fn bench_decoder_0_0(b: &mut Bencher) {
     b.iter(|| {
         let mut map = HashMap::new();
-        map.insert("abc".to_string(), Some('c'));
+        map.insert("abc".to_owned(), Some('c'));
 
         let outer = Outer {
             inner: vec!(),
@@ -653,11 +658,11 @@ fn bench_decoder_1_0(b: &mut Bencher) {
 fn bench_decoder_1_5(b: &mut Bencher) {
     b.iter(|| {
         let mut map = HashMap::new();
-        map.insert("1".to_string(), Some('a'));
-        map.insert("2".to_string(), None);
-        map.insert("3".to_string(), Some('b'));
-        map.insert("4".to_string(), None);
-        map.insert("5".to_string(), Some('c'));
+        map.insert("1".to_owned(), Some('a'));
+        map.insert("2".to_owned(), None);
+        map.insert("3".to_owned(), Some('b'));
+        map.insert("4".to_owned(), None);
+        map.insert("5".to_owned(), Some('c'));
 
         let outer = Outer {
             inner: vec!(
@@ -716,11 +721,11 @@ fn bench_deserializer_1_0(b: &mut Bencher) {
 fn bench_deserializer_1_5(b: &mut Bencher) {
     b.iter(|| {
         let mut map = HashMap::new();
-        map.insert("1".to_string(), Some('a'));
-        map.insert("2".to_string(), None);
-        map.insert("3".to_string(), Some('b'));
-        map.insert("4".to_string(), None);
-        map.insert("5".to_string(), Some('c'));
+        map.insert("1".to_owned(), Some('a'));
+        map.insert("2".to_owned(), None);
+        map.insert("3".to_owned(), Some('b'));
+        map.insert("4".to_owned(), None);
+        map.insert("5".to_owned(), Some('c'));
 
         let outer = Outer {
             inner: vec!(

serde_tests/benches/bench_vec.rs

@@ -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(())
                 }
             }

serde_tests/tests/test.rs

@@ -1,3 +1,6 @@
+#![cfg_attr(feature = "nightly", feature(plugin))]
+#![cfg_attr(feature = "nightly", plugin(clippy))]
+
 extern crate serde;
 
 include!(concat!(env!("OUT_DIR"), "/test.rs"));

serde_tests/tests/test_annotations.rs

@@ -1,343 +1,699 @@
-use std::default;
+use std::default::Default;
+use serde::{Serialize, Serializer, Deserialize, Deserializer};
 
-use token::{Token, assert_tokens, assert_ser_tokens, assert_de_tokens};
+use token::{
+    Error,
+    Token,
+    assert_tokens,
+    assert_ser_tokens,
+    assert_de_tokens,
+    assert_de_tokens_error
+};
 
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
-struct Default {
-    a1: i32,
-    #[serde(default)]
-    a2: i32,
+trait Trait: Sized {
+    fn my_default() -> Self;
+
+    fn should_skip(&self) -> bool;
+
+    fn serialize_with<S>(&self, ser: &mut S) -> Result<(), S::Error>
+        where S: Serializer;
+
+    fn deserialize_with<D>(de: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer;
+}
+
+impl Trait for i32 {
+    fn my_default() -> Self { 123 }
+
+    fn should_skip(&self) -> bool { *self == 123 }
+
+    fn serialize_with<S>(&self, ser: &mut S) -> Result<(), S::Error>
+        where S: Serializer
+    {
+        if *self == 123 {
+            true.serialize(ser)
+        } else {
+            false.serialize(ser)
+        }
+    }
+
+    fn deserialize_with<D>(de: &mut D) -> Result<Self, D::Error>
+        where D: Deserializer
+    {
+        if try!(Deserialize::deserialize(de)) {
+            Ok(123)
+        } else {
+            Ok(2)
+        }
+    }
 }
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
-struct Rename {
+struct DefaultStruct<A, B: Default, C> where C: Trait {
+    a1: A,
+    #[serde(default)]
+    a2: B,
+    #[serde(default="Trait::my_default")]
+    a3: C,
+}
+
+#[test]
+fn test_default_struct() {
+    assert_de_tokens(
+        &DefaultStruct { a1: 1, a2: 2, a3: 3 },
+        vec![
+            Token::StructStart("DefaultStruct", Some(3)),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructSep,
+            Token::Str("a2"),
+            Token::I32(2),
+
+            Token::StructSep,
+            Token::Str("a3"),
+            Token::I32(3),
+
+            Token::StructEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &DefaultStruct { a1: 1, a2: 0, a3: 123 },
+        vec![
+            Token::StructStart("DefaultStruct", Some(1)),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+enum DefaultEnum<A, B: Default, C> where C: Trait {
+    Struct {
+        a1: A,
+        #[serde(default)]
+        a2: B,
+        #[serde(default="Trait::my_default")]
+        a3: C,
+    }
+}
+
+#[test]
+fn test_default_enum() {
+    assert_de_tokens(
+        &DefaultEnum::Struct { a1: 1, a2: 2, a3: 3 },
+        vec![
+            Token::EnumMapStart("DefaultEnum", "Struct", Some(3)),
+
+            Token::EnumMapSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::EnumMapSep,
+            Token::Str("a2"),
+            Token::I32(2),
+
+            Token::EnumMapSep,
+            Token::Str("a3"),
+            Token::I32(3),
+
+            Token::EnumMapEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &DefaultEnum::Struct { a1: 1, a2: 0, a3: 123 },
+        vec![
+            Token::EnumMapStart("DefaultEnum", "Struct", Some(3)),
+
+            Token::EnumMapSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::EnumMapEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct DenyUnknown {
+    a1: i32,
+}
+
+#[test]
+fn test_ignore_unknown() {
+    // 'Default' allows unknown. Basic smoke test of ignore...
+    assert_de_tokens(
+        &DefaultStruct { a1: 1, a2: 2, a3: 3 },
+        vec![
+            Token::StructStart("DefaultStruct", Some(5)),
+
+            Token::StructSep,
+            Token::Str("whoops1"),
+            Token::I32(2),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructSep,
+            Token::Str("whoops2"),
+            Token::SeqStart(Some(1)),
+            Token::SeqSep,
+            Token::I32(2),
+            Token::SeqEnd,
+
+            Token::StructSep,
+            Token::Str("a2"),
+            Token::I32(2),
+
+            Token::StructSep,
+            Token::Str("whoops3"),
+            Token::I32(2),
+
+            Token::StructSep,
+            Token::Str("a3"),
+            Token::I32(3),
+
+            Token::StructEnd,
+        ]
+    );
+
+    assert_de_tokens_error::<DenyUnknown>(
+        vec![
+            Token::StructStart("DenyUnknown", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructSep,
+            Token::Str("whoops"),
+            Token::I32(2),
+
+            Token::StructEnd,
+        ],
+        Error::UnknownFieldError("whoops".to_owned())
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename="Superhero")]
+struct RenameStruct {
     a1: i32,
     #[serde(rename="a3")]
     a2: i32,
 }
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
-struct FormatRename {
+#[serde(rename(serialize="SuperheroSer", deserialize="SuperheroDe"))]
+struct RenameStructSerializeDeserialize {
     a1: i32,
-    #[serde(rename(xml= "a4", token="a5"))]
+    #[serde(rename(serialize="a4", deserialize="a5"))]
     a2: i32,
 }
 
-#[derive(Debug, PartialEq, Deserialize, Serialize)]
-enum SerEnum<A> {
-    Map {
-        a: i8,
-        #[serde(rename(xml= "c", token="d"))]
-        b: A,
+#[test]
+fn test_rename_struct() {
+    assert_tokens(
+        &RenameStruct { a1: 1, a2: 2 },
+        vec![
+            Token::StructStart("Superhero", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructSep,
+            Token::Str("a3"),
+            Token::I32(2),
+
+            Token::StructEnd,
+        ]
+    );
+
+    assert_ser_tokens(
+        &RenameStructSerializeDeserialize { a1: 1, a2: 2 },
+        &[
+            Token::StructStart("SuperheroSer", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructSep,
+            Token::Str("a4"),
+            Token::I32(2),
+
+            Token::StructEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &RenameStructSerializeDeserialize { a1: 1, a2: 2 },
+        vec![
+            Token::StructStart("SuperheroDe", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a1"),
+            Token::I32(1),
+
+            Token::StructSep,
+            Token::Str("a5"),
+            Token::I32(2),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename="Superhero")]
+enum RenameEnum {
+    #[serde(rename="bruce_wayne")]
+    Batman,
+    #[serde(rename="clark_kent")]
+    Superman(i8),
+    #[serde(rename="diana_prince")]
+    WonderWoman(i8, i8),
+    #[serde(rename="barry_allan")]
+    Flash {
+        #[serde(rename="b")]
+        a: i32,
     },
 }
 
 #[derive(Debug, PartialEq, Deserialize, Serialize)]
-struct SkipSerializingFields<A: default::Default> {
-    a: i8,
-    #[serde(skip_serializing, default)]
-    b: A,
-}
-
-#[derive(Debug, PartialEq, Deserialize, Serialize)]
-struct SkipSerializingIfEmptyFields<A: default::Default> {
-    a: i8,
-    #[serde(skip_serializing_if_empty, default)]
-    b: Vec<A>,
-}
-
-#[derive(Debug, PartialEq, Deserialize, Serialize)]
-struct SkipSerializingIfNoneFields<A: default::Default> {
-    a: i8,
-    #[serde(skip_serializing_if_none, default)]
-    b: Option<A>,
+#[serde(rename(serialize="SuperheroSer", deserialize="SuperheroDe"))]
+enum RenameEnumSerializeDeserialize<A> {
+    #[serde(rename(serialize="dick_grayson", deserialize="jason_todd"))]
+    Robin {
+        a: i8,
+        #[serde(rename(serialize="c", deserialize="d"))]
+        b: A,
+    },
 }
 
 #[test]
-fn test_default() {
-    assert_de_tokens(
-        &Default { a1: 1, a2: 2 },
+fn test_rename_enum() {
+    assert_tokens(
+        &RenameEnum::Batman,
         vec![
-            Token::StructStart("Default", Some(2)),
+            Token::EnumUnit("Superhero", "bruce_wayne"),
+        ]
+    );
 
-            Token::MapSep,
-            Token::Str("a1"),
+    assert_tokens(
+        &RenameEnum::Superman(0),
+        vec![
+            Token::EnumNewType("Superhero", "clark_kent"),
+            Token::I8(0),
+        ]
+    );
+
+    assert_tokens(
+        &RenameEnum::WonderWoman(0, 1),
+        vec![
+            Token::EnumSeqStart("Superhero", "diana_prince", Some(2)),
+
+            Token::EnumSeqSep,
+            Token::I8(0),
+
+            Token::EnumSeqSep,
+            Token::I8(1),
+
+            Token::EnumSeqEnd,
+        ]
+    );
+
+    assert_tokens(
+        &RenameEnum::Flash { a: 1 },
+        vec![
+            Token::EnumMapStart("Superhero", "barry_allan", Some(1)),
+
+            Token::EnumMapSep,
+            Token::Str("b"),
             Token::I32(1),
 
-            Token::MapSep,
-            Token::Str("a2"),
-            Token::I32(2),
+            Token::EnumMapEnd,
+        ]
+    );
 
-            Token::MapEnd,
+    assert_ser_tokens(
+        &RenameEnumSerializeDeserialize::Robin {
+            a: 0,
+            b: String::new(),
+        },
+        &[
+            Token::EnumMapStart("SuperheroSer", "dick_grayson", Some(2)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(0),
+
+            Token::EnumMapSep,
+            Token::Str("c"),
+            Token::Str(""),
+
+            Token::EnumMapEnd,
         ]
     );
 
     assert_de_tokens(
-        &Default { a1: 1, a2: 0 },
-        vec![
-            Token::StructStart("Default", Some(1)),
-
-            Token::MapSep,
-            Token::Str("a1"),
-            Token::I32(1),
-
-            Token::MapEnd,
-        ]
-    );
-}
-
-#[test]
-fn test_rename() {
-    assert_tokens(
-        &Rename { a1: 1, a2: 2 },
-        vec![
-            Token::StructStart("Rename", Some(2)),
-
-            Token::MapSep,
-            Token::Str("a1"),
-            Token::I32(1),
-
-            Token::MapSep,
-            Token::Str("a3"),
-            Token::I32(2),
-
-            Token::MapEnd,
-        ]
-    );
-}
-
-#[test]
-fn test_format_rename() {
-    assert_tokens(
-        &FormatRename { a1: 1, a2: 2 },
-        vec![
-            Token::StructStart("FormatRename", Some(2)),
-
-            Token::MapSep,
-            Token::Str("a1"),
-            Token::I32(1),
-
-            Token::MapSep,
-            Token::Str("a5"),
-            Token::I32(2),
-
-            Token::MapEnd,
-        ]
-    );
-}
-
-#[test]
-fn test_enum_format_rename() {
-    assert_tokens(
-        &SerEnum::Map {
+        &RenameEnumSerializeDeserialize::Robin {
             a: 0,
             b: String::new(),
         },
         vec![
-            Token::EnumMapStart("SerEnum", "Map", Some(2)),
+            Token::EnumMapStart("SuperheroDe", "jason_todd", Some(2)),
 
-            Token::MapSep,
+            Token::EnumMapSep,
             Token::Str("a"),
             Token::I8(0),
 
-            Token::MapSep,
+            Token::EnumMapSep,
             Token::Str("d"),
             Token::Str(""),
 
-            Token::MapEnd,
+            Token::EnumMapEnd,
         ]
     );
 }
 
+#[derive(Debug, PartialEq, Serialize)]
+struct SkipSerializingStruct<'a, B, C> where C: Trait {
+    a: &'a i8,
+    #[serde(skip_serializing)]
+    b: B,
+    #[serde(skip_serializing_if="Trait::should_skip")]
+    c: C,
+}
+
 #[test]
-fn test_skip_serializing_fields() {
+fn test_skip_serializing_struct() {
+    let a = 1;
     assert_ser_tokens(
-        &SkipSerializingFields {
-            a: 1,
+        &SkipSerializingStruct {
+            a: &a,
+            b: 2,
+            c: 3,
+        },
+        &[
+            Token::StructStart("SkipSerializingStruct", Some(2)),
+
+            Token::StructSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::StructSep,
+            Token::Str("c"),
+            Token::I32(3),
+
+            Token::StructEnd,
+        ]
+    );
+
+    assert_ser_tokens(
+        &SkipSerializingStruct {
+            a: &a,
+            b: 2,
+            c: 123,
+        },
+        &[
+            Token::StructStart("SkipSerializingStruct", Some(1)),
+
+            Token::StructSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize)]
+enum SkipSerializingEnum<'a, B, C> where C: Trait {
+    Struct {
+        a: &'a i8,
+        #[serde(skip_serializing)]
+        _b: B,
+        #[serde(skip_serializing_if="Trait::should_skip")]
+        c: C,
+    }
+}
+
+#[test]
+fn test_skip_serializing_enum() {
+    let a = 1;
+    assert_ser_tokens(
+        &SkipSerializingEnum::Struct {
+            a: &a,
+            _b: 2,
+            c: 3,
+        },
+        &[
+            Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(2)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::EnumMapSep,
+            Token::Str("c"),
+            Token::I32(3),
+
+            Token::EnumMapEnd,
+        ]
+    );
+
+    assert_ser_tokens(
+        &SkipSerializingEnum::Struct {
+            a: &a,
+            _b: 2,
+            c: 123,
+        },
+        &[
+            Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(1)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::EnumMapEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Serialize)]
+struct SerializeWithStruct<'a, B> where B: Trait {
+    a: &'a i8,
+    #[serde(serialize_with="Trait::serialize_with")]
+    b: B,
+}
+
+#[test]
+fn test_serialize_with_struct() {
+    let a = 1;
+    assert_ser_tokens(
+        &SerializeWithStruct {
+            a: &a,
             b: 2,
         },
         &[
-            Token::StructStart("SkipSerializingFields", Some(1)),
+            Token::StructStart("SerializeWithStruct", Some(2)),
 
-            Token::MapSep,
+            Token::StructSep,
             Token::Str("a"),
             Token::I8(1),
 
-            Token::MapEnd,
+            Token::StructSep,
+            Token::Str("b"),
+            Token::Bool(false),
+
+            Token::StructEnd,
         ]
     );
 
-    assert_de_tokens(
-        &SkipSerializingFields {
-            a: 1,
-            b: 0,
+    assert_ser_tokens(
+        &SerializeWithStruct {
+            a: &a,
+            b: 123,
         },
-        vec![
-            Token::StructStart("SkipSerializingFields", Some(1)),
+        &[
+            Token::StructStart("SerializeWithStruct", Some(2)),
 
-            Token::MapSep,
+            Token::StructSep,
             Token::Str("a"),
             Token::I8(1),
 
-            Token::MapEnd,
+            Token::StructSep,
+            Token::Str("b"),
+            Token::Bool(true),
+
+            Token::StructEnd,
         ]
     );
 }
 
+#[derive(Debug, PartialEq, Serialize)]
+enum SerializeWithEnum<'a, B> where B: Trait {
+    Struct {
+        a: &'a i8,
+        #[serde(serialize_with="Trait::serialize_with")]
+        b: B,
+    }
+}
+
 #[test]
-fn test_skip_serializing_fields_if_empty() {
+fn test_serialize_with_enum() {
+    let a = 1;
     assert_ser_tokens(
-        &SkipSerializingIfEmptyFields::<i32> {
-            a: 1,
-            b: vec![],
+        &SerializeWithEnum::Struct {
+            a: &a,
+            b: 2,
         },
         &[
-            Token::StructStart("SkipSerializingIfEmptyFields", Some(1)),
+            Token::EnumMapStart("SerializeWithEnum", "Struct", Some(2)),
 
-            Token::MapSep,
+            Token::EnumMapSep,
             Token::Str("a"),
             Token::I8(1),
 
-            Token::MapEnd,
-        ]
-    );
+            Token::EnumMapSep,
+            Token::Str("b"),
+            Token::Bool(false),
 
-    assert_de_tokens(
-        &SkipSerializingIfEmptyFields::<i32> {
-            a: 1,
-            b: vec![],
-        },
-        vec![
-            Token::StructStart("SkipSerializingIfEmptyFields", Some(1)),
-
-            Token::MapSep,
-            Token::Str("a"),
-            Token::I8(1),
-
-            Token::MapEnd,
+            Token::EnumMapEnd,
         ]
     );
 
     assert_ser_tokens(
-        &SkipSerializingIfEmptyFields {
-            a: 1,
-            b: vec![2],
+        &SerializeWithEnum::Struct {
+            a: &a,
+            b: 123,
         },
         &[
-            Token::StructStart("SkipSerializingIfEmptyFields", Some(2)),
+            Token::EnumMapStart("SerializeWithEnum", "Struct", Some(2)),
 
-            Token::MapSep,
+            Token::EnumMapSep,
             Token::Str("a"),
             Token::I8(1),
 
-            Token::MapSep,
+            Token::EnumMapSep,
             Token::Str("b"),
-            Token::SeqStart(Some(1)),
-            Token::SeqSep,
-            Token::I32(2),
-            Token::SeqEnd,
+            Token::Bool(true),
 
-            Token::MapEnd,
+            Token::EnumMapEnd,
         ]
     );
+}
 
-    assert_de_tokens(
-        &SkipSerializingIfEmptyFields {
-            a: 1,
-            b: vec![2],
-        },
-        vec![
-            Token::StructStart("SkipSerializingIfEmptyFields", Some(2)),
-
-            Token::MapSep,
-            Token::Str("a"),
-            Token::I8(1),
-
-            Token::MapSep,
-            Token::Str("b"),
-            Token::SeqStart(Some(1)),
-            Token::SeqSep,
-            Token::I32(2),
-            Token::SeqEnd,
-
-            Token::MapEnd,
-        ]
-    );
+#[derive(Debug, PartialEq, Deserialize)]
+struct DeserializeWithStruct<B> where B: Trait {
+    a: i8,
+    #[serde(deserialize_with="Trait::deserialize_with")]
+    b: B,
 }
 
 #[test]
-fn test_skip_serializing_fields_if_none() {
-    assert_ser_tokens(
-        &SkipSerializingIfNoneFields::<i32> {
+fn test_deserialize_with_struct() {
+    assert_de_tokens(
+        &DeserializeWithStruct {
             a: 1,
-            b: None,
+            b: 2,
         },
-        &[
-            Token::StructStart("SkipSerializingIfNoneFields", Some(1)),
+        vec![
+            Token::StructStart("DeserializeWithStruct", Some(2)),
 
-            Token::MapSep,
+            Token::StructSep,
             Token::Str("a"),
             Token::I8(1),
 
-            Token::MapEnd,
+            Token::StructSep,
+            Token::Str("b"),
+            Token::Bool(false),
+
+            Token::StructEnd,
         ]
     );
 
     assert_de_tokens(
-        &SkipSerializingIfNoneFields::<i32> {
+        &DeserializeWithStruct {
             a: 1,
-            b: None,
+            b: 123,
         },
         vec![
-            Token::StructStart("SkipSerializingIfNoneFields", Some(1)),
+            Token::StructStart("DeserializeWithStruct", Some(2)),
 
-            Token::MapSep,
+            Token::StructSep,
             Token::Str("a"),
             Token::I8(1),
 
-            Token::MapEnd,
-        ]
-    );
-
-    assert_ser_tokens(
-        &SkipSerializingIfNoneFields {
-            a: 1,
-            b: Some(2),
-        },
-        &[
-            Token::StructStart("SkipSerializingIfNoneFields", Some(2)),
-
-            Token::MapSep,
-            Token::Str("a"),
-            Token::I8(1),
-
-            Token::MapSep,
+            Token::StructSep,
             Token::Str("b"),
-            Token::Option(true),
-            Token::I32(2),
+            Token::Bool(true),
 
-            Token::MapEnd,
-        ]
-    );
-
-    assert_de_tokens(
-        &SkipSerializingIfNoneFields {
-            a: 1,
-            b: Some(2),
-        },
-        vec![
-            Token::StructStart("SkipSerializingIfNoneFields", Some(2)),
-
-            Token::MapSep,
-            Token::Str("a"),
-            Token::I8(1),
-
-            Token::MapSep,
-            Token::Str("b"),
-            Token::Option(true),
-            Token::I32(2),
-
-            Token::MapEnd,
+            Token::StructEnd,
+        ]
+    );
+}
+
+#[derive(Debug, PartialEq, Deserialize)]
+enum DeserializeWithEnum<B> where B: Trait {
+    Struct {
+        a: i8,
+        #[serde(deserialize_with="Trait::deserialize_with")]
+        b: B,
+    }
+}
+
+#[test]
+fn test_deserialize_with_enum() {
+    assert_de_tokens(
+        &DeserializeWithEnum::Struct {
+            a: 1,
+            b: 2,
+        },
+        vec![
+            Token::EnumMapStart("DeserializeWithEnum", "Struct", Some(2)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::EnumMapSep,
+            Token::Str("b"),
+            Token::Bool(false),
+
+            Token::EnumMapEnd,
+        ]
+    );
+
+    assert_de_tokens(
+        &DeserializeWithEnum::Struct {
+            a: 1,
+            b: 123,
+        },
+        vec![
+            Token::EnumMapStart("DeserializeWithEnum", "Struct", Some(2)),
+
+            Token::EnumMapSep,
+            Token::Str("a"),
+            Token::I8(1),
+
+            Token::EnumMapSep,
+            Token::Str("b"),
+            Token::Bool(true),
+
+            Token::EnumMapEnd,
         ]
     );
 }

serde_tests/tests/test_bytes.rs

@@ -1,4 +1,6 @@
 use serde;
+use std::fmt;
+use std::error;
 use serde::Serialize;
 use serde::bytes::{ByteBuf, Bytes};
 
@@ -7,14 +9,30 @@ use 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 +52,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 +142,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())

serde_tests/tests/test_de.rs

@@ -1,8 +1,16 @@
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use std::net;
+use std::path::PathBuf;
 
 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,
+};
 
 //////////////////////////////////////////////////////////////////////////
 
@@ -34,7 +42,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);
             )+
         }
     }
@@ -90,12 +102,12 @@ declare_tests! {
     test_char {
         'a' => vec![Token::Char('a')],
         'a' => vec![Token::Str("a")],
-        'a' => vec![Token::String("a".to_string())],
+        'a' => vec![Token::String("a".to_owned())],
     }
     test_string {
-        "abc".to_string() => vec![Token::Str("abc")],
-        "abc".to_string() => vec![Token::String("abc".to_string())],
-        "a".to_string() => vec![Token::Char('a')],
+        "abc".to_owned() => vec![Token::Str("abc")],
+        "abc".to_owned() => vec![Token::String("abc".to_owned())],
+        "a".to_owned() => vec![Token::Char('a')],
     }
     test_option {
         None::<i32> => vec![Token::Unit],
@@ -174,27 +186,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 {
@@ -309,6 +321,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,
@@ -331,6 +347,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"),
         ],
@@ -358,6 +396,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![
@@ -485,18 +541,18 @@ declare_tests! {
         ],
         Struct { a: 1, b: 2, c: 3 } => 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::StructEnd,
         ],
     }
     test_enum_unit {
@@ -506,39 +562,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 {
@@ -555,4 +611,39 @@ declare_tests! {
             Token::Unit,
         ],
     }
+    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")],
+    );
+}
+
+#[test]
+fn test_enum_error() {
+    assert_de_tokens_error::<Enum>(
+        vec![
+            Token::EnumUnit("Enum", "Foo"),
+        ],
+        Error::UnknownVariantError("Foo".to_owned()),
+    )
 }

serde_tests/tests/test_macros.rs

@@ -123,7 +123,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,7 +131,7 @@ 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 },
 }
@@ -153,16 +153,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 +172,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 +185,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 +219,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 +247,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 +295,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 +333,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 +385,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 +423,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 +451,7 @@ fn test_lifetimes() {
     assert_ser_tokens(
         &Lifetimes::LifetimeSeq(&value),
         &[
-            Token::EnumNewtype("Lifetimes", "LifetimeSeq"),
+            Token::EnumNewType("Lifetimes", "LifetimeSeq"),
             Token::I32(5),
         ]
     );
@@ -442,7 +459,7 @@ fn test_lifetimes() {
     assert_ser_tokens(
         &Lifetimes::NoLifetimeSeq(5),
         &[
-            Token::EnumNewtype("Lifetimes", "NoLifetimeSeq"),
+            Token::EnumNewType("Lifetimes", "NoLifetimeSeq"),
             Token::I32(5),
         ]
     );
@@ -452,11 +469,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 +482,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 +498,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 +510,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 +525,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 +549,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 +564,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 +582,15 @@ 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,
         ]
     );
 }

serde_tests/tests/test_ser.rs

@@ -1,6 +1,9 @@
 use std::collections::BTreeMap;
+use std::net;
+use std::path::{Path, PathBuf};
+use std::str;
 
-use token::Token;
+use token::{self, Token};
 
 //////////////////////////////////////////////////////////////////////////
 
@@ -58,7 +61,7 @@ declare_ser_tests! {
     }
     test_str {
         "abc" => &[Token::Str("abc")],
-        "abc".to_string() => &[Token::Str("abc")],
+        "abc".to_owned() => &[Token::Str("abc")],
     }
     test_option {
         None::<i32> => &[Token::Option(false)],
@@ -69,11 +72,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),
         ],
     }
@@ -97,11 +100,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),
 
@@ -143,22 +146,22 @@ declare_ser_tests! {
     }
     test_tuple {
         (1,) => &[
-            Token::SeqStart(Some(1)),
-                Token::SeqSep,
+            Token::TupleStart(1),
+                Token::TupleSep,
                 Token::I32(1),
-            Token::SeqEnd,
+            Token::TupleEnd,
         ],
         (1, 2, 3) => &[
-            Token::SeqStart(Some(3)),
-                Token::SeqSep,
+            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 {
@@ -207,56 +210,105 @@ declare_ser_tests! {
     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_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()));
+}