Release 0.8.9

Release 0.8.8
Auto merge of #546 - serde-rs:qual, r=oli-obk
2026-04-22 22:58:02 +00:00 · 2016-09-23 07:11:59 -07:00 · 2016-09-08 08:34:20 -07:00 · 2016-09-08 18:05:36 +09:00 · 2016-09-07 16:37:26 -07:00 · 2016-09-05 09:39:27 -07:00
27 changed files with 788 additions and 1097 deletions
@@ -29,9 +29,7 @@ script:
 - (cd examples/serde-syntex-example && travis-cargo --only nightly run -- --no-default-features --features unstable)
 - (cd serde && travis-cargo --only stable doc)
 after_success:
- (cd serde && travis-cargo --only stable doc-upload --branch docs)
 - (cd testing && travis-cargo --only stable coveralls --no-sudo)
 env:
  global:
  - TRAVIS_CARGO_NIGHTLY_FEATURE=""
-  - secure: Jcd11Jy0xLyacBUB+oKOaxKBm9iZNInenRDtNBY8GKOtqF5fHUfEjgDf538hwRl5L0FP7DLr8oK0IHmzA7lPjJxlzoKVKV3IM7bRZEYzW5DMonf/lcliuGte7SH0NVFhifM87T8HI2hjGdAb+7+m34siBR7M3AY/XjLInrvUFvY=
@@ -1,214 +1,21 @@
-Serde Rust Serialization Framework
-==================================
+# Serde &emsp; [![Build Status](https://api.travis-ci.org/serde-rs/serde.svg?branch=master)](https://travis-ci.org/serde-rs/serde) [![Latest Version](https://img.shields.io/crates/v/serde.svg)](https://crates.io/crates/serde)

-[![Build Status](https://api.travis-ci.org/serde-rs/serde.svg?branch=master)](https://travis-ci.org/serde-rs/serde)
-[![Coverage Status](https://coveralls.io/repos/serde-rs/serde/badge.svg?branch=master&service=github)](https://coveralls.io/github/serde-rs/serde?branch=master)
-[![Latest Version](https://img.shields.io/crates/v/serde.svg)](https://crates.io/crates/serde)
-[![Clippy Linting Result](https://clippy.bashy.io/github/serde-rs/serde/master/badge.svg)](https://clippy.bashy.io/github/serde-rs/serde/master/log)
+**Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**

-Serde is a powerful framework that enables serialization libraries to
-generically serialize Rust data structures without the overhead of runtime type
-information. In many situations, the handshake protocol between serializers and
-serializees can be completely optimized away, leaving Serde to perform roughly
-the same speed as a hand written serializer for a specific type.
+---

-[Documentation](https://serde-rs.github.io/serde/serde/index.html)
+You may be looking for:

-Simple Serde Example
-====================
+- [An overview of Serde](https://serde.rs/)
+- [Data formats supported by Serde](https://serde.rs/#data-formats)
+- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/codegen.html)
+- [Examples](https://serde.rs/examples.html)
+- [API documentation](https://docs.serde.rs/serde/)

-Here is a simple example that uses
-[serde_json](https://github.com/serde-rs/json), which uses Serde under the
-covers, to generate and parse JSON. First, lets start off with the `Cargo.toml`
-file:
-
-```toml
-[package]
-name = "serde_example"
-version = "0.1.0"
-authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
-
-[dependencies]
-serde_json = "0.8"
-```
-
-Next, the `src/main.rs` file itself:
-
-```rust,ignore
-extern crate serde_json;
-
-use std::collections::HashMap;
-use serde_json::Value;
-use serde_json::builder::{ArrayBuilder, ObjectBuilder};
-
-fn main() {
-    // Serde has support for many of the builtin Rust types, like arrays..:
-    let v = vec![1, 2];
-    let serialized = serde_json::to_string(&v).unwrap();
-    println!("serialized vec: {:?}", serialized);
-
-    let deserialized: Vec<u32> = serde_json::from_str(&serialized).unwrap();
-    println!("deserialized vec: {:?}", deserialized);
-
-    // ... and maps:
-    let mut map = HashMap::new();
-    map.insert("x".to_string(), 1);
-    map.insert("y".to_string(), 2);
-
-    let serialized = serde_json::to_string(&map).unwrap();
-    println!("serialized map: {:?}", serialized);
-
-    let deserialized: HashMap<String, u32> = serde_json::from_str(&serialized).unwrap();
-    println!("deserialized map: {:?}", deserialized);
-
-    // It also can handle complex objects:
-    let value = ObjectBuilder::new()
-        .insert("int", 1)
-        .insert("string", "a string")
-        .insert("array", ArrayBuilder::new()
-                .push(1)
-                .push(2)
-                .build())
-        .build();
-
-    let serialized = serde_json::to_string(&value).unwrap();
-    println!("serialized value: {:?}", serialized);
-
-    let deserialized: serde_json::Value = serde_json::from_str(&serialized).unwrap();
-    println!("deserialized value: {:?}", deserialized);
-}
-```
-
-This produces the following output when run:
-
-```sh
-% cargo run
-serialized vec: "[1,2]"
-deserialized vec: [1, 2]
-serialized map: "{\"y\":2,\"x\":1}"
-deserialized map: {"y": 2, "x": 1}
-serialized value: "{\"array\":[1,2],\"int\":1,\"string\":\"a string\"}"
-deserialized value: {"array":[1,2],"int":1,"string":"a string"}
-```
-
-Using Serde with Stable Rust and serde\_codegen
-===============================================
-
-The example before used `serde_json::Value` as the in-memory representation of
-the JSON value, but it's also possible for Serde to serialize to and from
-regular Rust types. However, the code to do this can be a bit complicated to
-write. So instead, Serde also has some powerful code generation libraries that
-work with Stable and Nightly Rust that eliminate much of the complexity of hand
-rolling serialization and deserialization for a given type.
-
-First lets see how we would use Stable Rust, which is currently a tad more
-complicated than Nightly Rust due to having to work around compiler plugins
-being unstable.  We will use `serde_codegen` which is based on the code
-generation library [syntex](https://github.com/serde-rs/syntex). First we need
-to setup the `Cargo.toml` that builds the project:
-
-```toml
-[package]
-name = "serde_example"
-version = "0.1.0"
-authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
-build = "build.rs"
-
-[build-dependencies]
-serde_codegen = "0.8"
-
-[dependencies]
-serde = "0.8"
-serde_json = "0.8"
-```
-
-Next, we define our source file, `src/main.rs.in`. Note this is a different
-extension than usual because we need to do code generation:
-
-```rust,ignore
-#[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);
-}
-```
-
-To finish up the main source code, we define a very simple `src/main.rs` that
-uses the generated code.
-
-`src/main.rs`:
-
-```rust,ignore
-extern crate serde;
-extern crate serde_json;
-
-include!(concat!(env!("OUT_DIR"), "/main.rs"));
-```
-
-The last step is to actually drive the code generation, with the `build.rs` script:
-
-```rust,ignore
-extern crate serde_codegen;
-
-use std::env;
-use std::path::Path;
-
-pub fn main() {
-    let out_dir = env::var_os("OUT_DIR").unwrap();
-
-    let src = Path::new("src/main.rs.in");
-    let dst = Path::new(&out_dir).join("main.rs");
-
-    serde_codegen::expand(&src, &dst).unwrap();
-}
-```
-
-All this produces this when run:
-
-```sh
-% cargo run
-{"x":1,"y":2}
-Point { x: 1, y: 2 }
-```
-
-While this works well with Stable Rust, be aware that the error locations
-currently are reported in the generated file instead of in the source file.
-
-Using Serde with Nightly Rust and serde\_macros
-===============================================
-
-The prior example is a bit more complicated than it needs to be due to compiler
-plugins being unstable. However, if you are already using Nightly Rust, you can
-use `serde_macros`, which has a much simpler interface. First, here is the new
-`Cargo.toml`:
-
-```toml
-[package]
-name = "serde_example_nightly"
-version = "0.1.0"
-authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
-
-[dependencies]
-serde = "0.8"
-serde_json = "0.8"
-serde_macros = "0.8"
-```
-
-Note that it doesn't need a build script. Now the `src/main.rs`, which enables
-the plugin feature, and registers the `serde_macros` plugin:
+## Serde in action

 ```rust
-#![feature(custom_derive, plugin)]
+#![feature(plugin, custom_derive)]
 #![plugin(serde_macros)]

 extern crate serde_json;
@@ -222,539 +29,41 @@ struct Point {
 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);
-}
-```
-
-This also produces the same output:
-
-```sh
-% cargo run
-{"x":1,"y":2}
-Point { x: 1, y: 2 }
-```
-
-You may find it easier to develop with Nightly Rust and `serde\_macros`, then
-deploy with Stable Rust and `serde_codegen`. It's possible to combine both
-approaches in one setup:
-
-`Cargo.toml`:
-
-```toml
-[package]
-name = "serde_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.8", optional = true }
-
-[dependencies]
-serde = "0.8"
-serde_json = "0.8"
-serde_macros = { version = "0.8", optional = true }
-```
-
-`build.rs`:
-
-```rust,ignore
-#[cfg(not(feature = "serde_macros"))]
-mod inner {
-    extern crate serde_codegen;
-
-    use std::env;
-    use std::path::Path;
-
-    pub fn main() {
-        let out_dir = env::var_os("OUT_DIR").unwrap();
-
-        let src = Path::new("src/main.rs.in");
-        let dst = Path::new(&out_dir).join("main.rs");
-
-        serde_codegen::expand(&src, &dst).unwrap();
-    }
-}
-
-#[cfg(feature = "serde_macros")]
-mod inner {
-    pub fn main() {}
-}
-
-fn main() {
-    inner::main();
-}
-```
-
-`src/main.rs`:
-
-```rust,ignore
-#![cfg_attr(feature = "serde_macros", feature(custom_derive, plugin))]
-#![cfg_attr(feature = "serde_macros", 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"));
-```
-
-The `src/main.rs.in` is the same as before.
-
-Then to run with stable:
-
-```sh
-% cargo build
-...
-```
-
-Or with nightly:
-
-```sh
-% cargo build --features nightly --no-default-features
-...
-```
-
-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/serde/ser/trait.Serializer.html)
-and
-[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,
-Rust is able to remove most or all the visitor state, and generate code that's
-nearly as fast as a hand written serializer format for a specific type.
-
-To see it in action, lets look at how a simple type like `i32` is serialized.
-The
-[Serializer](http://serde-rs.github.io/serde/serde/serde/ser/trait.Serializer.html)
-is threaded through the type:
-
-```rust,ignore
-impl serde::Serialize for i32 {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
-        where S: serde::Serializer,
-    {
-        serializer.serialize_i32(*self)
-    }
-}
-```
-
-As you can see it's pretty simple. More complex types like `BTreeMap` need to
-use a multi-step process (init, elements, end) in order to walk through the
-type:
-
-```rust,ignore
-impl<K, V> Serialize for BTreeMap<K, V>
-    where K: Serialize + Ord,
-          V: Serialize,
-{
-    #[inline]
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
-        where S: Serializer,
-    {
-        let mut state = try!(serializer.serialize_map(Some(self.len())));
-        for (k, v) in self {
-            try!(serializer.serialize_map_elt(&mut state, k, v));
-        }
-        serializer.serialize_map_end(state)
-    }
-}
-```
-
-Serializing structs follow this same pattern. In fact, structs are represented
-as a named map, with a known length.
-
-```rust
-extern crate serde;
-extern crate serde_json;
-
-struct Point {
-    x: i32,
-    y: i32,
-}
-
-impl serde::Serialize for Point {
-    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
-        where S: serde::Serializer
-    {
-        let mut state = try!(serializer.serialize_struct("Point", 2));
-        try!(serializer.serialize_struct_elt(&mut state, "x", &self.x));
-        try!(serializer.serialize_struct_elt(&mut state, "y", &self.y));
-        serializer.serialize_struct_end(state)
-    }
-}
-
-fn main() {
-    let point = Point { x: 1, y: 2 };
+    // Convert the Point to a JSON string.
    let serialized = serde_json::to_string(&point).unwrap();

-    println!("{}", serialized);
-}
-```
-
-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/serde/de/trait.Deserialize.html)
-implementation. It passes a
-[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,ignore
-impl Deserialize for i32 {
-    fn deserialize<D>(deserializer: &mut D) -> Result<i32, D::Error>
-        where D: serde::Deserializer,
-    {
-        deserializer.deserialize(I32Visitor)
-    }
-}
-
-struct I32Visitor;
-
-impl serde::de::Visitor for I32Visitor {
-    type Value = i32;
-
-    fn visit_i16<E>(&mut self, value: i16) -> Result<i32, E>
-        where E: Error,
-    {
-        self.visit_i32(value as i32)
-    }
-
-    fn visit_i32<E>(&mut self, value: i32) -> Result<i32, E>
-        where E: Error,
-    {
-        Ok(value)
-    }
-
-    ...
-
-```
-
-Since it's possible for this type to get passed an unexpected type, we need a
-way to error out. This is done by way of the
-[Error](http://serde-rs.github.io/serde/serde/serde/de/trait.Error.html) trait,
-which allows a
-[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,ignore
-    ...
-
-    fn visit_string<E>(&mut self, _: String) -> Result<i32, E>
-        where E: Error,
-    {
-        Err(serde::de::Error::custom("expect a string"))
-    }
-
-    ...
-
-```
-
-Maps follow a similar pattern as before, and use a
-[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/serde/de/trait.Deserializer.html).
-
-```rust,ignore
-impl<K, V> serde::Deserialize for BTreeMap<K, V>
-    where K: serde::Deserialize + Eq + Ord,
-          V: serde::Deserialize,
-{
-    fn deserialize<D>(deserializer: &mut D) -> Result<BTreeMap<K, V>, D::Error>
-        where D: serde::Deserializer,
-    {
-        deserializer.deserialize(BTreeMapVisitor::new())
-    }
-}
-
-pub struct BTreeMapVisitor<K, V> {
-    marker: PhantomData<BTreeMap<K, V>>,
-}
-
-impl<K, V> BTreeMapVisitor<K, V> {
-    pub fn new() -> Self {
-        BTreeMapVisitor {
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<K, V> serde::de::Visitor for BTreeMapVisitor<K, V>
-    where K: serde::de::Deserialize + Ord,
-          V: serde::de::Deserialize
-{
-    type Value = BTreeMap<K, V>;
-
-    fn visit_unit<E>(&mut self) -> Result<BTreeMap<K, V>, E>
-        where E: Error,
-    {
-        Ok(BTreeMap::new())
-    }
-
-    fn visit_map<V_>(&mut self, mut visitor: V_) -> Result<BTreeMap<K, V>, V_::Error>
-        where V_: MapVisitor,
-    {
-        let mut values = BTreeMap::new();
-
-        while let Some((key, value)) = try!(visitor.visit()) {
-            values.insert(key, value);
-        }
-
-        try!(visitor.end());
-
-        Ok(values)
-    }
-}
-```
-
-Deserializing structs goes a step further in order to support not allocating a
-`String` to hold the field names. This is done by custom field enum that
-deserializes an enum variant from a string. So for our `Point` example from
-before, we need to generate:
-
-```rust
-extern crate serde;
-extern crate serde_json;
-
-#[derive(Debug)]
-struct Point {
-    x: i32,
-    y: i32,
-}
-
-enum PointField {
-    X,
-    Y,
-}
-
-impl serde::Deserialize for PointField {
-    fn deserialize<D>(deserializer: &mut D) -> Result<PointField, D::Error>
-        where D: serde::de::Deserializer
-    {
-        struct PointFieldVisitor;
-
-        impl serde::de::Visitor for PointFieldVisitor {
-            type Value = PointField;
-
-            fn visit_str<E>(&mut self, value: &str) -> Result<PointField, E>
-                where E: serde::de::Error
-            {
-                match value {
-                    "x" => Ok(PointField::X),
-                    "y" => Ok(PointField::Y),
-                    _ => Err(serde::de::Error::custom("expected x or y")),
-                }
-            }
-        }
-
-        deserializer.deserialize(PointFieldVisitor)
-    }
-}
-
-impl serde::Deserialize for Point {
-    fn deserialize<D>(deserializer: &mut D) -> Result<Point, D::Error>
-        where D: serde::de::Deserializer
-    {
-        static FIELDS: &'static [&'static str] = &["x", "y"];
-        deserializer.deserialize_struct("Point", FIELDS, PointVisitor)
-    }
-}
-
-struct PointVisitor;
-
-impl serde::de::Visitor for PointVisitor {
-    type Value = Point;
-
-    fn visit_map<V>(&mut self, mut visitor: V) -> Result<Point, V::Error>
-        where V: serde::de::MapVisitor
-    {
-        let mut x = None;
-        let mut y = None;
-
-        loop {
-            match try!(visitor.visit_key()) {
-                Some(PointField::X) => { x = Some(try!(visitor.visit_value())); }
-                Some(PointField::Y) => { y = Some(try!(visitor.visit_value())); }
-                None => { break; }
-            }
-        }
-
-        let x = match x {
-            Some(x) => x,
-            None => try!(visitor.missing_field("x")),
-        };
-
-        let y = match y {
-            Some(y) => y,
-            None => try!(visitor.missing_field("y")),
-        };
-
-        try!(visitor.end());
-
-        Ok(Point{ x: x, y: y })
-    }
-}
-
-
-fn main() {
-    let serialized = "{\"x\":1,\"y\":2}";
+    // Prints serialized = {"x":1,"y":2}
+    println!("serialized = {}", serialized);

+    // Convert the JSON string back to a Point.
    let deserialized: Point = serde_json::from_str(&serialized).unwrap();

-    println!("{:?}", deserialized);
+    // Prints deserialized = Point { x: 1, y: 2 }
+    println!("deserialized = {:?}", deserialized);
 }
 ```

-Design Considerations and tradeoffs for Serializers and Deserializers
-=====================================================================
+## Getting help

-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.
+Serde developers live in the #serde channel on
+[`irc.mozilla.org`](https://wiki.mozilla.org/IRC). The #rust channel is also a
+good resource with generally faster response time but less specific knowledge
+about Serde. If IRC is not your thing, we are happy to respond to [GitHub
+issues](https://github.com/serde-rs/serde/issues/new) as well.

-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:
+## License

-```rust,ignore
-...
+Serde is licensed under either of

-    fn visit_none(&mut self) -> Result<(), Self::Error> {
-        self.visit_unit()
-    }
+ * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
+   http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([LICENSE-MIT](LICENSE-MIT) or
+   http://opensource.org/licenses/MIT)

-    fn visit_some<T>(&mut self, value: T) -> Result<(), Self::Error> {
-        value.serialize(self)
-    }
-...
-```
+at your option.

-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:
+### Contribution

-```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
-===========
-
-`serde_codegen` and `serde_macros` support annotations that help to customize
-how types are serialized. Here are the supported annotations:
-
-Container Annotations:
-
-| Annotation                                  | Function                                                                                                                                           |
-| ----------                                  | --------                                                                                                                                           |
-| `#[serde(rename="name")]`                   | Serialize and deserialize this container with the given name                                                                                       |
-| `#[serde(rename(serialize="name1"))]`       | Serialize this container with the given name                                                                                                       |
-| `#[serde(rename(deserialize="name1"))]`     | Deserialize this container with the given name                                                                                                     |
-| `#[serde(deny_unknown_fields)]`             | Always error during serialization when encountering unknown fields. When absent, unknown fields are ignored for self-describing formats like JSON. |
-| `#[serde(bound="T: MyTrait")]`              | Where-clause for the Serialize and Deserialize impls. This replaces any bounds inferred by Serde.                                                  |
-| `#[serde(bound(serialize="T: MyTrait"))]`   | Where-clause for the Serialize impl.                                                                                                               |
-| `#[serde(bound(deserialize="T: MyTrait"))]` | Where-clause for the Deserialize impl.                                                                                                             |
-
-Variant Annotations:
-
-| Annotation                              | Function                                                   |
-| ----------                              | --------                                                   |
-| `#[serde(rename="name")]`               | Serialize and deserialize this variant with the given name |
-| `#[serde(rename(serialize="name1"))]`   | Serialize this variant with the given name                 |
-| `#[serde(rename(deserialize="name1"))]` | Deserialize this variant with the given name               |
-
-Field Annotations:
-
-| Annotation                                  | Function                                                                                                                |
-| ----------                                  | --------                                                                                                                |
-| `#[serde(rename="name")]`                   | Serialize and deserialize this field with the given name                                                                |
-| `#[serde(rename(serialize="name1"))]`       | Serialize this field with the given name                                                                                |
-| `#[serde(rename(deserialize="name1"))]`     | Deserialize this field with the given name                                                                              |
-| `#[serde(default)]`                         | If the value is not specified, use the `Default::default()`                                                             |
-| `#[serde(default="$path")]`                 | Call the path to a function `fn() -> T` to build the value                                                              |
-| `#[serde(skip_serializing)]`                | Do not serialize this value                                                                                             |
-| `#[serde(skip_deserializing)]`              | Always use `Default::default()` or `#[serde(default="$path")]` instead of deserializing this value                      |
-| `#[serde(skip_serializing_if="$path")]`     | Do not serialize this value if this function `fn(&T) -> bool` returns `true`                                            |
-| `#[serde(serialize_with="$path")]`          | Call a function `fn<S>(&T, &mut S) -> Result<(), S::Error> where S: Serializer` to serialize this value of type `T`     |
-| `#[serde(deserialize_with="$path")]`        | Call a function `fn<D>(&mut D) -> Result<T, D::Error> where D: Deserializer` to deserialize this value of type `T`      |
-| `#[serde(bound="T: MyTrait")]`              | Where-clause for the Serialize and Deserialize impls. This replaces any bounds inferred by Serde for the current field. |
-| `#[serde(bound(serialize="T: MyTrait"))]`   | Where-clause for the Serialize impl.                                                                                    |
-| `#[serde(bound(deserialize="T: MyTrait"))]` | Where-clause for the Deserialize impl.                                                                                  |
-
-Using in `no_std` crates
-========================
-
-The core `serde` package defines a number of features to enable usage in a
-variety of freestanding environments. Enable any or none of the following
-features, and use `default-features = false` in your `Cargo.toml`:
-
- `alloc` (implies `nightly`)
- `collections` (implies `alloc` and `nightly`)
- `std` (default)
-
-If you only use `default-features = false`, you will receive a stock `no_std`
-serde with no support for any of the collection types.
-
-Serialization Formats Using Serde
-=================================
-
-| Format      | Name                                                 |
-| ------      | ----                                                 |
-| Bincode     | [bincode](https://crates.io/crates/bincode)          |
-| env vars    | [envy](https://crates.io/crates/envy)                |
-| Hjson       | [serde\_hjson](https://crates.io/crates/serde-hjson) |
-| 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) |
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in Serde by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.
@@ -9,9 +9,9 @@ default = ["serde_codegen"]
 unstable = ["serde_macros"]

 [build-dependencies]
-serde_codegen = { version = "^0.8", optional = true }
+serde_codegen = { version = "^0.8", optional = true, path = "../../serde_codegen" }

 [dependencies]
 serde = "^0.8"
 serde_json = "^0.8"
-serde_macros = { version = "^0.8", optional = true }
+serde_macros = { version = "^0.8", optional = true, path = "../../serde_macros" }
@@ -1,11 +1,12 @@
 [package]
 name = "serde"
-version = "0.8.0"
+version = "0.8.9"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
+homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
-documentation = "https://serde-rs.github.io/serde/serde/"
+documentation = "https://docs.serde.rs/serde/"
 readme = "../README.md"
 keywords = ["serde", "serialization"]
 include = ["Cargo.toml", "src/**/*.rs"]
@@ -19,6 +19,15 @@ pub struct Bytes<'a> {
    bytes: &'a [u8],
 }

+impl<'a> Bytes<'a> {
+    /// Wrap an existing `&[u8]`.
+    pub fn new(bytes: &'a [u8]) -> Self {
+        Bytes {
+            bytes: bytes,
+        }
+    }
+}
+
 impl<'a> fmt::Debug for Bytes<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        try!(f.write_str("b\""));
@@ -31,18 +40,14 @@ impl<'a> fmt::Debug for Bytes<'a> {

 impl<'a> From<&'a [u8]> for Bytes<'a> {
    fn from(bytes: &'a [u8]) -> Self {
-        Bytes {
-            bytes: bytes,
-        }
+        Bytes::new(bytes)
    }
 }

 #[cfg(any(feature = "std", feature = "collections"))]
 impl<'a> From<&'a Vec<u8>> for Bytes<'a> {
    fn from(bytes: &'a Vec<u8>) -> Self {
-        Bytes {
-            bytes: bytes,
-        }
+        Bytes::new(bytes)
    }
 }

@@ -90,15 +95,18 @@ mod bytebuf {
    impl ByteBuf {
        /// Construct a new, empty `ByteBuf`.
        pub fn new() -> Self {
-            ByteBuf {
-                bytes: Vec::new(),
-            }
+            ByteBuf::from(Vec::new())
        }

        /// Construct a new, empty `ByteBuf` with the specified capacity.
        pub fn with_capacity(cap: usize) -> Self {
+            ByteBuf::from(Vec::with_capacity(cap))
+        }
+
+        /// Wrap existing bytes in a `ByteBuf`.
+        pub fn from<T: Into<Vec<u8>>>(bytes: T) -> Self {
            ByteBuf {
-                bytes: Vec::with_capacity(cap)
+                bytes: bytes.into(),
            }
        }
    }
@@ -121,9 +129,7 @@ mod bytebuf {

    impl From<Vec<u8>> for ByteBuf {
        fn from(bytes: Vec<u8>) -> Self {
-            ByteBuf {
-                bytes: bytes,
-            }
+            ByteBuf::from(bytes)
        }
    }

@@ -179,9 +185,7 @@ mod bytebuf {
        fn visit_unit<E>(&mut self) -> Result<ByteBuf, E>
            where E: de::Error,
        {
-            Ok(ByteBuf {
-                bytes: Vec::new(),
-            })
+            Ok(ByteBuf::new())
        }

        #[inline]
@@ -197,9 +201,7 @@ mod bytebuf {

            try!(visitor.end());

-            Ok(ByteBuf {
-                bytes: values,
-            })
+            Ok(ByteBuf::from(values))
        }

        #[inline]
@@ -213,9 +215,7 @@ mod bytebuf {
        fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<ByteBuf, E>
            where E: de::Error,
        {
-            Ok(ByteBuf {
-                bytes: v,
-            })
+            Ok(ByteBuf::from(v))
        }
    }

@@ -791,7 +791,7 @@ macro_rules! map_impl {
 #[cfg(any(feature = "std", feature = "collections"))]
 map_impl!(
    BTreeMap<K, V>,
-    BTreeMapVisitor<K: Deserialize + Eq + Ord,
+    BTreeMapVisitor<K: Deserialize + Ord,
                    V: Deserialize>,
    visitor,
    BTreeMap::new(),
@@ -11,71 +11,6 @@ use collections::{String, Vec};
 use core::fmt;

 ///////////////////////////////////////////////////////////////////////////////
-/// Macro helper to not have to re-implement all the defaulted methods.
-/// Every given method ignores all arguments and forwards to `deserialize`.
-/// Note that `deserialize_enum` simply returns an `Error::invalid_type`.
-macro_rules! de_forward_to_deserialize {
-    ($($func:ident),*) => {
-        $(de_forward_to_deserialize!{func: $func})*
-    };
-    (func: deserialize_unit_struct) => {
-        de_forward_to_deserialize!{named: deserialize_unit_struct}
-    };
-    (func: deserialize_newtype_struct) => {
-        de_forward_to_deserialize!{named: deserialize_newtype_struct}
-    };
-    (func: deserialize_tuple) => {
-        de_forward_to_deserialize!{tup_fn: deserialize_tuple}
-    };
-    (func: deserialize_seq_fixed_size) => {
-        de_forward_to_deserialize!{tup_fn: deserialize_seq_fixed_size}
-    };
-    (func: deserialize_tuple_struct) => {
-        #[inline]
-        fn deserialize_tuple_struct<__V>(&mut self, _: &str, _: usize, visitor: __V) -> Result<__V::Value, Self::Error>
-            where __V: $crate::de::Visitor {
-            self.deserialize(visitor)
-        }
-    };
-    (func: deserialize_struct) => {
-        #[inline]
-        fn deserialize_struct<__V>(&mut self, _: &str, _: &[&str], visitor: __V) -> Result<__V::Value, Self::Error>
-            where __V: $crate::de::Visitor {
-            self.deserialize(visitor)
-        }
-    };
-    (func: deserialize_enum) => {
-        #[inline]
-        fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _: __V) -> Result<__V::Value, Self::Error>
-            where __V: $crate::de::EnumVisitor {
-            Err($crate::de::Error::invalid_type($crate::de::Type::Enum))
-        }
-    };
-    (named: $func:ident) => {
-        #[inline]
-        fn $func<__V>(&mut self, _: &str, visitor: __V) -> Result<__V::Value, Self::Error>
-            where __V: $crate::de::Visitor {
-            self.deserialize(visitor)
-        }
-    };
-    (tup_fn: $func: ident) => {
-        #[inline]
-        fn $func<__V>(&mut self, _: usize, visitor: __V) -> Result<__V::Value, Self::Error>
-            where __V: $crate::de::Visitor {
-            self.deserialize(visitor)
-        }
-    };
-    (func: $func:ident) => {
-        #[inline]
-        fn $func<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error>
-            where __V: $crate::de::Visitor {
-            self.deserialize(visitor)
-        }
-    };
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// modules come after macros

 pub mod impls;
 pub mod value;
@@ -12,6 +12,8 @@ use std::collections::{
    hash_set,
 };
 #[cfg(feature = "std")]
+use std::borrow::Cow;
+#[cfg(feature = "std")]
 use std::vec;

 #[cfg(all(feature = "collections", not(feature = "std")))]
@@ -24,6 +26,8 @@ use collections::{
    btree_set,
    vec,
 };
+#[cfg(all(feature = "collections", not(feature = "std")))]
+use collections::borrow::Cow;

 #[cfg(all(feature = "unstable", feature = "collections"))]
 use collections::borrow::ToOwned;
@@ -128,7 +132,7 @@ impl fmt::Display for Error {
                write!(formatter, "Unknown variant: {}", variant)
            }
            Error::UnknownField(ref field) => write!(formatter, "Unknown field: {}", field),
-            Error::MissingField(ref field) => write!(formatter, "Missing field: {}", field),
+            Error::MissingField(field) => write!(formatter, "Missing field: {}", field),
        }
    }
 }
@@ -174,20 +178,10 @@ impl<E> de::Deserializer for UnitDeserializer<E>
 {
    type Error = E;

-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
    }

    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
@@ -225,21 +219,11 @@ macro_rules! primitive_deserializer {
        {
            type Error = E;

-            de_forward_to_deserialize!{
-                deserialize_bool,
-                deserialize_f64, deserialize_f32,
-                deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-                deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-                deserialize_char, deserialize_str, deserialize_string,
-                deserialize_ignored_any,
-                deserialize_bytes,
-                deserialize_unit_struct, deserialize_unit,
-                deserialize_seq, deserialize_seq_fixed_size,
-                deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-                deserialize_tuple,
-                deserialize_enum,
-                deserialize_struct, deserialize_tuple_struct,
-                deserialize_option
+            forward_to_deserialize! {
+                bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str
+                string unit option seq seq_fixed_size bytes map unit_struct
+                newtype_struct tuple_struct struct struct_field tuple enum
+                ignored_any
            }

            fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
@@ -307,20 +291,10 @@ impl<'a, E> de::Deserializer for StrDeserializer<'a, E>
        visitor.visit(self)
    }

-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple ignored_any
    }
 }

@@ -404,20 +378,10 @@ impl<E> de::Deserializer for StringDeserializer<E>
        visitor.visit(self)
    }

-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple ignored_any
    }
 }

@@ -463,6 +427,95 @@ impl<'a, E> de::VariantVisitor for StringDeserializer<E>

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

+/// A helper deserializer that deserializes a `String`.
+#[cfg(any(feature = "std", feature = "collections"))]
+pub struct CowStrDeserializer<'a, E>(Option<Cow<'a, str>>, PhantomData<E>);
+
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<'a, E> ValueDeserializer<E> for Cow<'a, str>
+    where E: de::Error,
+{
+    type Deserializer = CowStrDeserializer<'a, E>;
+
+    fn into_deserializer(self) -> CowStrDeserializer<'a, E> {
+        CowStrDeserializer(Some(self), PhantomData)
+    }
+}
+
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<'a, E> de::Deserializer for CowStrDeserializer<'a, E>
+    where E: de::Error,
+{
+    type Error = E;
+
+    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor,
+    {
+        match self.0.take() {
+            Some(Cow::Borrowed(string)) => visitor.visit_str(string),
+            Some(Cow::Owned(string)) => visitor.visit_string(string),
+            None => Err(de::Error::end_of_stream()),
+        }
+    }
+
+    fn deserialize_enum<V>(&mut self,
+                     _name: &str,
+                     _variants: &'static [&'static str],
+                     mut visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::EnumVisitor,
+    {
+        visitor.visit(self)
+    }
+
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple ignored_any
+    }
+}
+
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<'a, E> de::VariantVisitor for CowStrDeserializer<'a, E>
+    where E: de::Error,
+{
+    type Error = E;
+
+    fn visit_variant<T>(&mut self) -> Result<T, Self::Error>
+        where T: de::Deserialize,
+    {
+        de::Deserialize::deserialize(self)
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
+        where T: super::Deserialize,
+    {
+        let (value,) = try!(self.visit_tuple(1, super::impls::TupleVisitor1::new()));
+        Ok(value)
+    }
+
+    fn visit_tuple<V>(&mut self,
+                      _len: usize,
+                      _visitor: V) -> Result<V::Value, Self::Error>
+        where V: super::Visitor
+    {
+        Err(super::Error::invalid_type(super::Type::TupleVariant))
+    }
+
+    fn visit_struct<V>(&mut self,
+                       _fields: &'static [&'static str],
+                       _visitor: V) -> Result<V::Value, Self::Error>
+        where V: super::Visitor
+    {
+        Err(super::Error::invalid_type(super::Type::StructVariant))
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 /// A helper deserializer that deserializes a sequence.
 pub struct SeqDeserializer<I, E> {
    iter: I,
@@ -496,21 +549,10 @@ impl<I, T, E> de::Deserializer for SeqDeserializer<I, E>
        visitor.visit_seq(self)
    }

-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
    }
 }

@@ -619,21 +661,10 @@ impl<V_, E> de::Deserializer for SeqVisitorDeserializer<V_, E>
        visitor.visit_seq(&mut self.visitor)
    }

-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
    }
 }

@@ -648,7 +679,7 @@ pub struct MapDeserializer<I, K, V, E>
 {
    iter: I,
    value: Option<V>,
-    len: usize,
+    len: Option<usize>,
    marker: PhantomData<E>,
 }

@@ -658,15 +689,35 @@ impl<I, K, V, E> MapDeserializer<I, K, V, E>
          V: ValueDeserializer<E>,
          E: de::Error,
 {
-    /// Construct a new `MapDeserializer<I, K, V>`.
+    /// Construct a new `MapDeserializer<I, K, V, E>` with a specific length.
    pub fn new(iter: I, len: usize) -> Self {
        MapDeserializer {
            iter: iter,
            value: None,
-            len: len,
+            len: Some(len),
            marker: PhantomData,
        }
    }
+
+    /// Construct a new `MapDeserializer<I, K, V, E>` that is not bounded
+    /// by a specific length and that delegates to `iter` for its size hint.
+    pub fn unbounded(iter: I) -> Self {
+        MapDeserializer {
+            iter: iter,
+            value: None,
+            len: None,
+            marker: PhantomData,
+        }
+    }
+
+    fn next(&mut self) -> Option<(K, V)> {
+        self.iter.next().map(|(k, v)| {
+            if let Some(len) = self.len.as_mut() {
+                *len -= 1;
+            }
+            (k, v)
+        })
+    }
 }

 impl<I, K, V, E> de::Deserializer for MapDeserializer<I, K, V, E>
@@ -683,21 +734,26 @@ impl<I, K, V, E> de::Deserializer for MapDeserializer<I, K, V, E>
        visitor.visit_map(self)
    }

-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    fn deserialize_seq<V_>(&mut self, mut visitor: V_) -> Result<V_::Value, Self::Error>
+        where V_: de::Visitor,
+    {
+        visitor.visit_seq(self)
+    }
+
+    fn deserialize_seq_fixed_size<V_>(&mut self, len: usize, mut visitor: V_) -> Result<V_::Value, Self::Error>
+        where V_: de::Visitor,
+    {
+        match self.len {
+            Some(map_len) if map_len == len => visitor.visit_seq(self),
+            Some(_) => Err(de::Error::invalid_length(len)),
+            None => visitor.visit_seq(self),
+        }
+    }
+
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option bytes map unit_struct newtype_struct tuple_struct struct
+        struct_field tuple enum ignored_any
    }
 }

@@ -712,12 +768,11 @@ impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
    fn visit_key<T>(&mut self) -> Result<Option<T>, Self::Error>
        where T: de::Deserialize,
    {
-        match self.iter.next() {
+        match self.next() {
            Some((key, value)) => {
-                self.len -= 1;
                self.value = Some(value);
                let mut de = key.into_deserializer();
-                Ok(Some(try!(de::Deserialize::deserialize(&mut de))))
+                de::Deserialize::deserialize(&mut de).map(Some)
            }
            None => Ok(None),
        }
@@ -738,15 +793,133 @@ impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
    }

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

    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
+        self.len.map_or_else(
+            || self.iter.size_hint(),
+            |len| (len, Some(len)))
+    }
+}
+
+impl<I, K, V, E> de::SeqVisitor for MapDeserializer<I, K, V, E>
+    where I: Iterator<Item=(K, V)>,
+          K: ValueDeserializer<E>,
+          V: ValueDeserializer<E>,
+          E: de::Error,
+{
+    type Error = E;
+
+    fn visit<T>(&mut self) -> Result<Option<T>, Self::Error>
+        where T: de::Deserialize,
+    {
+        match self.next() {
+            Some(kv) => {
+                let mut de = PairDeserializer(Some(kv), PhantomData);
+                de::Deserialize::deserialize(&mut de).map(Some)
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn end(&mut self) -> Result<(), Self::Error> {
+        de::MapVisitor::end(self)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        de::MapVisitor::size_hint(self)
+    }
+}
+
+// Used in the `impl SeqVisitor for MapDeserializer` to visit the map as a
+// sequence of pairs.
+struct PairDeserializer<A, B, E>(Option<(A, B)>, PhantomData<E>);
+
+impl<A, B, E> de::Deserializer for PairDeserializer<A, B, E>
+    where A: ValueDeserializer<E>,
+          B: ValueDeserializer<E>,
+          E: de::Error
+{
+    type Error = E;
+
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option bytes map unit_struct newtype_struct tuple_struct struct
+        struct_field tuple enum ignored_any
+    }
+
+    fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor,
+    {
+        self.deserialize_seq(visitor)
+    }
+
+    fn deserialize_seq<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor,
+    {
+        match self.0.take() {
+            Some((k, v)) => {
+                visitor.visit_seq(PairVisitor(Some(k), Some(v), PhantomData))
+            }
+            None => Err(de::Error::end_of_stream()),
+        }
+    }
+
+    fn deserialize_seq_fixed_size<V>(&mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor,
+    {
+        if len == 2 {
+            self.deserialize_seq(visitor)
+        } else {
+            Err(de::Error::invalid_length(len))
+        }
+    }
+}
+
+struct PairVisitor<A, B, E>(Option<A>, Option<B>, PhantomData<E>);
+
+impl<A, B, E> de::SeqVisitor for PairVisitor<A, B, E>
+    where A: ValueDeserializer<E>,
+          B: ValueDeserializer<E>,
+          E: de::Error,
+{
+    type Error = E;
+
+    fn visit<T>(&mut self) -> Result<Option<T>, Self::Error>
+        where T: de::Deserialize,
+    {
+        if let Some(k) = self.0.take() {
+            let mut de = k.into_deserializer();
+            de::Deserialize::deserialize(&mut de).map(Some)
+        } else if let Some(v) = self.1.take() {
+            let mut de = v.into_deserializer();
+            de::Deserialize::deserialize(&mut de).map(Some)
+        } else {
+            Ok(None)
+        }
+    }
+
+    fn end(&mut self) -> Result<(), Self::Error> {
+        if self.1.is_none() {
+            Ok(())
+        } else {
+            Err(de::Error::invalid_length(self.size_hint().0))
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = if self.0.is_some() {
+            2
+        } else if self.1.is_some() {
+            1
+        } else {
+            0
+        };
+        (len, Some(len))
    }
 }

@@ -811,21 +984,10 @@ impl<V_, E> de::Deserializer for MapVisitorDeserializer<V_, E>
        visitor.visit_map(&mut self.visitor)
    }

-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
    }
 }

@@ -858,25 +1020,13 @@ impl<'a, E> de::Deserializer for BytesDeserializer<'a, E>
        }
    }

-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
    }
 }

-
 ///////////////////////////////////////////////////////////////////////////////

 #[cfg(any(feature = "std", feature = "collections"))]
@@ -909,20 +1059,9 @@ impl<E> de::Deserializer for ByteBufDeserializer<E>
        }
    }

-    de_forward_to_deserialize!{
-        deserialize_bool,
-        deserialize_f64, deserialize_f32,
-        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
-        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
-        deserialize_char, deserialize_str, deserialize_string,
-        deserialize_ignored_any,
-        deserialize_bytes,
-        deserialize_unit_struct, deserialize_unit,
-        deserialize_seq, deserialize_seq_fixed_size,
-        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
-        deserialize_tuple,
-        deserialize_enum,
-        deserialize_struct, deserialize_tuple_struct,
-        deserialize_option
+    forward_to_deserialize! {
+        bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+        unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
    }
 }
@@ -9,7 +9,7 @@
 //! For a detailed tutorial on the different ways to use serde please check out the
 //! [github repository](https://github.com/serde-rs/serde)

-#![doc(html_root_url="https://serde-rs.github.io/serde/serde")]
+#![doc(html_root_url="https://docs.serde.rs")]
 #![cfg_attr(not(feature = "std"), no_std)]
 #![cfg_attr(feature = "unstable", feature(reflect_marker, unicode, nonzero, plugin, step_trait, zero_one))]
 #![cfg_attr(feature = "alloc", feature(alloc))]
@@ -45,6 +45,9 @@ macro_rules! format {
    ($s:expr, $($rest:tt)*) => ($s)
 }

+#[macro_use]
+mod macros;
+
 pub mod bytes;
 pub mod de;
 #[cfg(feature = "std")]
@@ -0,0 +1,179 @@
+#[cfg(feature = "std")]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! forward_to_deserialize_method {
+    ($func:ident($($arg:ty),*)) => {
+        #[inline]
+        fn $func<__V>(&mut self, $(_: $arg,)* visitor: __V) -> ::std::result::Result<__V::Value, Self::Error>
+            where __V: $crate::de::Visitor
+        {
+            self.deserialize(visitor)
+        }
+    };
+}
+
+#[cfg(not(feature = "std"))]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! forward_to_deserialize_method {
+    ($func:ident($($arg:ty),*)) => {
+        #[inline]
+        fn $func<__V>(&mut self, $(_: $arg,)* visitor: __V) -> ::core::result::Result<__V::Value, Self::Error>
+            where __V: $crate::de::Visitor
+        {
+            self.deserialize(visitor)
+        }
+    };
+}
+
+#[cfg(feature = "std")]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! forward_to_deserialize_enum {
+    () => {
+        #[inline]
+        fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _: __V) -> ::std::result::Result<__V::Value, Self::Error>
+            where __V: $crate::de::EnumVisitor
+        {
+            Err($crate::de::Error::invalid_type($crate::de::Type::Enum))
+        }
+    };
+}
+
+#[cfg(not(feature = "std"))]
+#[doc(hidden)]
+#[macro_export]
+macro_rules! forward_to_deserialize_enum {
+    () => {
+        #[inline]
+        fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _: __V) -> ::core::result::Result<__V::Value, Self::Error>
+            where __V: $crate::de::EnumVisitor
+        {
+            Err($crate::de::Error::invalid_type($crate::de::Type::Enum))
+        }
+    };
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! forward_to_deserialize_helper {
+    (bool) => {
+        forward_to_deserialize_method!{deserialize_bool()}
+    };
+    (usize) => {
+        forward_to_deserialize_method!{deserialize_usize()}
+    };
+    (u8) => {
+        forward_to_deserialize_method!{deserialize_u8()}
+    };
+    (u16) => {
+        forward_to_deserialize_method!{deserialize_u16()}
+    };
+    (u32) => {
+        forward_to_deserialize_method!{deserialize_u32()}
+    };
+    (u64) => {
+        forward_to_deserialize_method!{deserialize_u64()}
+    };
+    (isize) => {
+        forward_to_deserialize_method!{deserialize_isize()}
+    };
+    (i8) => {
+        forward_to_deserialize_method!{deserialize_i8()}
+    };
+    (i16) => {
+        forward_to_deserialize_method!{deserialize_i16()}
+    };
+    (i32) => {
+        forward_to_deserialize_method!{deserialize_i32()}
+    };
+    (i64) => {
+        forward_to_deserialize_method!{deserialize_i64()}
+    };
+    (f32) => {
+        forward_to_deserialize_method!{deserialize_f32()}
+    };
+    (f64) => {
+        forward_to_deserialize_method!{deserialize_f64()}
+    };
+    (char) => {
+        forward_to_deserialize_method!{deserialize_char()}
+    };
+    (str) => {
+        forward_to_deserialize_method!{deserialize_str()}
+    };
+    (string) => {
+        forward_to_deserialize_method!{deserialize_string()}
+    };
+    (unit) => {
+        forward_to_deserialize_method!{deserialize_unit()}
+    };
+    (option) => {
+        forward_to_deserialize_method!{deserialize_option()}
+    };
+    (seq) => {
+        forward_to_deserialize_method!{deserialize_seq()}
+    };
+    (seq_fixed_size) => {
+        forward_to_deserialize_method!{deserialize_seq_fixed_size(usize)}
+    };
+    (bytes) => {
+        forward_to_deserialize_method!{deserialize_bytes()}
+    };
+    (map) => {
+        forward_to_deserialize_method!{deserialize_map()}
+    };
+    (unit_struct) => {
+        forward_to_deserialize_method!{deserialize_unit_struct(&'static str)}
+    };
+    (newtype_struct) => {
+        forward_to_deserialize_method!{deserialize_newtype_struct(&'static str)}
+    };
+    (tuple_struct) => {
+        forward_to_deserialize_method!{deserialize_tuple_struct(&'static str, usize)}
+    };
+    (struct) => {
+        forward_to_deserialize_method!{deserialize_struct(&'static str, &'static [&'static str])}
+    };
+    (struct_field) => {
+        forward_to_deserialize_method!{deserialize_struct_field()}
+    };
+    (tuple) => {
+        forward_to_deserialize_method!{deserialize_tuple(usize)}
+    };
+    (ignored_any) => {
+        forward_to_deserialize_method!{deserialize_ignored_any()}
+    };
+    (enum) => {
+        forward_to_deserialize_enum!();
+    };
+}
+
+/// Helper to forward `Deserializer` methods to `Deserializer::deserialize`.
+/// Every given method ignores all arguments and forwards to `deserialize`.
+/// Note that `deserialize_enum` simply returns an `Error::invalid_type`; a
+/// better approach is tracked in [serde-rs/serde#521][1].
+///
+/// ```rust,ignore
+/// impl Deserializer for MyDeserializer {
+///     fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error>
+///         where V: Visitor
+///     {
+///         /* ... */
+///     }
+///
+///     forward_to_deserialize! {
+///         bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string
+///         unit option seq seq_fixed_size bytes map unit_struct newtype_struct
+///         tuple_struct struct struct_field tuple enum ignored_any
+///     }
+/// }
+/// ```
+///
+/// [1]: https://github.com/serde-rs/serde/issues/521
+#[macro_export]
+macro_rules! forward_to_deserialize {
+    ($($func:ident)*) => {
+        $(forward_to_deserialize_helper!{$func})*
+    };
+}
@@ -1,11 +1,12 @@
 [package]
 name = "serde_codegen"
-version = "0.8.1"
+version = "0.8.9"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
+homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
-documentation = "https://github.com/serde-rs/serde"
+documentation = "https://serde.rs/codegen.html"
 keywords = ["serde", "serialization"]
 build = "build.rs"
 include = ["Cargo.toml", "build.rs", "src/**/*.rs", "src/lib.rs.in"]
@@ -24,14 +25,14 @@ with-syntex = [
 ]

 [build-dependencies]
-quasi_codegen = { version = "^0.16.0", optional = true }
-syntex = { version = "^0.39.0", optional = true }
+quasi_codegen = { version = "^0.20.0", optional = true }
+syntex = { version = "^0.44.0", optional = true }

 [dependencies]
-aster = { version = "^0.22.0", default-features = false }
+aster = { version = "^0.27.0", default-features = false }
 clippy = { version = "^0.*", optional = true }
-quasi = { version = "^0.16.0", default-features = false }
-quasi_macros = { version = "^0.16.0", optional = true }
-serde_codegen_internals = { version = "=0.5.0", default-features = false, path = "../serde_codegen_internals" }
-syntex = { version = "^0.39.0", optional = true }
-syntex_syntax = { version = "^0.39.0", optional = true }
+quasi = { version = "^0.20.0", default-features = false }
+quasi_macros = { version = "^0.20.0", optional = true }
+serde_codegen_internals = { version = "=0.8.9", default-features = false, path = "../serde_codegen_internals" }
+syntex = { version = "^0.44.0", optional = true }
+syntex_syntax = { version = "^0.44.0", optional = true }
@@ -192,7 +192,7 @@ fn deserialize_visitor(
    builder: &aster::AstBuilder,
    generics: &ast::Generics,
 ) -> (P<ast::Item>, P<ast::Ty>, P<ast::Expr>) {
-    if generics.ty_params.is_empty() {
+    if generics.lifetimes.is_empty() && generics.ty_params.is_empty() {
        (
            builder.item().unit_struct("__Visitor"),
            builder.ty().id("__Visitor"),
@@ -36,10 +36,7 @@ include!(concat!(env!("OUT_DIR"), "/lib.rs"));
 include!("lib.rs.in");

 #[cfg(feature = "with-syntex")]
-pub fn expand<S, D>(src: S, dst: D) -> Result<(), syntex::Error>
-    where S: AsRef<Path>,
-          D: AsRef<Path>,
-{
+fn syntex_registry() -> syntex::Registry {
    use syntax::{ast, fold};

    /// Strip the serde attributes from the crate.
@@ -76,7 +73,33 @@ pub fn expand<S, D>(src: S, dst: D) -> Result<(), syntex::Error>

    reg.add_post_expansion_pass(strip_attributes);

-    reg.expand("", src.as_ref(), dst.as_ref())
+    reg
+}
+
+#[cfg(feature = "with-syntex")]
+pub fn expand_str(src: &str) -> Result<String, syntex::Error> {
+    let src = src.to_owned();
+
+    let expand_thread = move || {
+        syntex_registry().expand_str("", "", &src)
+    };
+
+    syntex::with_extra_stack(expand_thread)
+}
+
+#[cfg(feature = "with-syntex")]
+pub fn expand<S, D>(src: S, dst: D) -> Result<(), syntex::Error>
+    where S: AsRef<Path>,
+          D: AsRef<Path>,
+{
+    let src = src.as_ref().to_owned();
+    let dst = dst.as_ref().to_owned();
+
+    let expand_thread = move || {
+        syntex_registry().expand("", src, dst)
+    };
+
+    syntex::with_extra_stack(expand_thread)
 }

 #[cfg(not(feature = "with-syntex"))]
@@ -4,6 +4,7 @@ use syntax::ast::{self, Ident, MetaItem};
 use syntax::codemap::Span;
 use syntax::ext::base::{Annotatable, ExtCtxt};
 use syntax::ptr::P;
+use syntax::tokenstream::TokenTree;

 use bound;
 use span;
@@ -226,9 +227,10 @@ fn serialize_tuple_struct(

    let type_name = name_expr(builder, item_attrs.name());
    let len = serialize_stmts.len();
+    let let_mut = mut_if(cx, len > 0);

    quote_block!(cx, {
-        let mut state = try!(_serializer.serialize_tuple_struct($type_name, $len));
+        let $let_mut state = try!(_serializer.serialize_tuple_struct($type_name, $len));
        $serialize_stmts
        _serializer.serialize_tuple_struct_end(state)
    }).unwrap()
@@ -253,8 +255,14 @@ fn serialize_struct(
    );

    let type_name = name_expr(builder, item_attrs.name());
-    let len = fields.iter()
+
+    let mut serialized_fields = fields.iter()
        .filter(|&field| !field.attrs.skip_serializing())
+        .peekable();
+
+    let let_mut = mut_if(cx, serialized_fields.peek().is_some());
+
+    let len = serialized_fields
        .map(|field| {
            let ident = field.ident.expect("struct has unnamed fields");
            let field_expr = quote_expr!(cx, &self.$ident);
@@ -267,7 +275,7 @@ fn serialize_struct(
        .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr));

    quote_block!(cx, {
-        let mut state = try!(_serializer.serialize_struct($type_name, $len));
+        let $let_mut state = try!(_serializer.serialize_struct($type_name, $len));
        $serialize_fields
        _serializer.serialize_struct_end(state)
    }).unwrap()
@@ -458,9 +466,10 @@ fn serialize_tuple_variant(
    );

    let len = serialize_stmts.len();
+    let let_mut = mut_if(cx, len > 0);

    quote_block!(cx, {
-        let mut state = try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len));
+        let $let_mut state = try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len));
        $serialize_stmts
        _serializer.serialize_tuple_variant_end(state)
    }).unwrap()
@@ -488,8 +497,14 @@ fn serialize_struct_variant(
    );

    let item_name = name_expr(builder, item_attrs.name());
-    let len = fields.iter()
+
+    let mut serialized_fields = fields.iter()
        .filter(|&field| !field.attrs.skip_serializing())
+        .peekable();
+
+    let let_mut = mut_if(cx, serialized_fields.peek().is_some());
+
+    let len = serialized_fields
        .map(|field| {
            let ident = field.ident.expect("struct has unnamed fields");
            let field_expr = quote_expr!(cx, $ident);
@@ -502,7 +517,7 @@ fn serialize_struct_variant(
        .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr));

    quote_block!(cx, {
-        let mut state = try!(_serializer.serialize_struct_variant(
+        let $let_mut state = try!(_serializer.serialize_struct_variant(
            $item_name,
            $variant_index,
            $variant_name,
@@ -532,19 +547,21 @@ fn serialize_tuple_struct_visitor(
            };

            let skip = field.attrs.skip_serializing_if()
-                .map(|path| quote_expr!(cx, $path($field_expr)))
-                .unwrap_or(quote_expr!(cx, false));
+                .map(|path| quote_expr!(cx, $path($field_expr)));

            if let Some(path) = field.attrs.serialize_with() {
                field_expr = wrap_serialize_with(cx, builder,
                    &structure_ty, generics, &field.ty, path, field_expr);
            }

-            quote_stmt!(cx,
-                if !$skip {
-                    try!(_serializer.$func(&mut state, $field_expr));
-                }
-            ).unwrap()
+            let ser = quote_expr!(cx,
+                try!(_serializer.$func(&mut state, $field_expr));
+            );
+
+            match skip {
+                None => quote_stmt!(cx, $ser).unwrap(),
+                Some(skip) => quote_stmt!(cx, if !$skip { $ser }).unwrap(),
+            }
        })
        .collect()
 }
@@ -571,19 +588,21 @@ fn serialize_struct_visitor(
            let key_expr = name_expr(builder, field.attrs.name());

            let skip = field.attrs.skip_serializing_if()
-                .map(|path| quote_expr!(cx, $path($field_expr)))
-                .unwrap_or(quote_expr!(cx, false));
+                .map(|path| quote_expr!(cx, $path($field_expr)));

            if let Some(path) = field.attrs.serialize_with() {
                field_expr = wrap_serialize_with(cx, builder,
                    &structure_ty, generics, &field.ty, path, field_expr)
            }

-            quote_stmt!(cx,
-                if !$skip {
-                    try!(_serializer.$func(&mut state, $key_expr, $field_expr));
-                }
-            ).unwrap()
+            let ser = quote_expr!(cx,
+                try!(_serializer.$func(&mut state, $key_expr, $field_expr));
+            );
+
+            match skip {
+                None => quote_stmt!(cx, $ser).unwrap(),
+                Some(skip) => quote_stmt!(cx, if !$skip { $ser }).unwrap(),
+            }
        })
        .collect()
 }
@@ -617,7 +636,7 @@ fn wrap_serialize_with(
        }

        impl $wrapper_generics _serde::ser::Serialize for $wrapper_ty $where_clause {
-            fn serialize<__S>(&self, __s: &mut __S) -> Result<(), __S::Error>
+            fn serialize<__S>(&self, __s: &mut __S) -> ::std::result::Result<(), __S::Error>
                where __S: _serde::ser::Serializer
            {
                $path(self.value, __s)
@@ -637,3 +656,17 @@ fn name_expr(
 ) -> P<ast::Expr> {
    builder.expr().str(name.serialize_name())
 }
+
+// Serialization of an empty struct results in code like:
+//
+//     let mut state = try!(serializer.serialize_struct("S", 0));
+//     serializer.serialize_struct_end(state)
+//
+// where we want to omit the `mut` to avoid a warning.
+fn mut_if(cx: &ExtCtxt, is_mut: bool) -> Vec<TokenTree> {
+    if is_mut {
+        quote_tokens!(cx, mut)
+    } else {
+        Vec::new()
+    }
+}
@@ -1,11 +1,12 @@
 [package]
 name = "serde_codegen_internals"
-version = "0.5.0"
+version = "0.8.9"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "AST representation used by Serde codegen. Unstable."
+homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
-documentation = "https://github.com/serde-rs/serde"
+documentation = "https://docs.serde.rs/serde_codegen_internals/"
 keywords = ["serde", "serialization"]
 include = ["Cargo.toml", "src/**/*.rs"]

@@ -16,5 +17,5 @@ with-syntex = ["syntex_syntax", "syntex_errors"]

 [dependencies]
 clippy = { version = "^0.*", optional = true }
-syntex_syntax = { version = "^0.39.0", optional = true }
-syntex_errors = { version = "^0.39.0", optional = true }
+syntex_syntax = { version = "^0.44.0", optional = true }
+syntex_errors = { version = "^0.44.0", optional = true }
@@ -8,8 +8,7 @@ use syntax::fold::Folder;
 use syntax::parse::parser::{Parser, PathStyle};
 use syntax::parse::token::{self, InternedString};
 use syntax::parse;
-use syntax::print::pprust::{lit_to_string, meta_item_to_string};
-use syntax::ptr::P;
+use syntax::print::pprust::{lit_to_string, meta_item_to_string, meta_list_item_to_string};
 use syntax::tokenstream::{self, TokenTree};

 // This module handles parsing of `#[serde(...)]` attributes. The entrypoints
@@ -165,7 +164,7 @@ impl Item {
                        cx.span_err(
                            meta_item.span,
                            &format!("unknown serde container attribute `{}`",
-                                     meta_item_to_string(meta_item)));
+                                     meta_item_to_string(&meta_item)));
                    }
                }
            }
@@ -236,7 +235,7 @@ impl Variant {
                        cx.span_err(
                            meta_item.span,
                            &format!("unknown serde variant attribute `{}`",
-                                     meta_item_to_string(meta_item)));
+                                     meta_item_to_string(&meta_item)));
                    }
                }
            }
@@ -384,7 +383,7 @@ impl Field {
                        cx.span_err(
                            meta_item.span,
                            &format!("unknown serde field attribute `{}`",
-                                     meta_item_to_string(meta_item)));
+                                     meta_item_to_string(&meta_item)));
                    }
                }
            }
@@ -449,12 +448,14 @@ impl Field {
    }
 }

+type SerAndDe<T> = (Option<Spanned<T>>, Option<Spanned<T>>);
+
 fn get_ser_and_de<T, F>(
    cx: &ExtCtxt,
    attribute: &'static str,
-    items: &[P<ast::MetaItem>],
+    items: &[ast::NestedMetaItem],
    f: F
-) -> Result<(Option<Spanned<T>>, Option<Spanned<T>>), ()>
+) -> Result<SerAndDe<T>, ()>
    where F: Fn(&ExtCtxt, &str, &ast::Lit) -> Result<T, ()>,
 {
    let mut ser_item = Attr::none(cx, attribute);
@@ -462,15 +463,29 @@ fn get_ser_and_de<T, F>(

    for item in items {
        match item.node {
-            ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"serialize" => {
-                if let Ok(v) = f(cx, name, lit) {
-                    ser_item.set(item.span, v);
-                }
-            }
+            ast::NestedMetaItemKind::MetaItem(ref meta_item) => {
+                match meta_item.node {
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"serialize" => {
+                        if let Ok(v) = f(cx, name, lit) {
+                            ser_item.set(item.span, v);
+                        }
+                    }

-            ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"deserialize" => {
-                if let Ok(v) = f(cx, name, lit) {
-                    de_item.set(item.span, v);
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"deserialize" => {
+                        if let Ok(v) = f(cx, name, lit) {
+                            de_item.set(item.span, v);
+                        }
+                    }
+
+                    _ => {
+                        cx.span_err(
+                            item.span,
+                            &format!("unknown {} attribute `{}`",
+                                    attribute,
+                                    meta_item_to_string(meta_item)));
+
+                        return Err(());
+                    }
                }
            }

@@ -479,7 +494,7 @@ fn get_ser_and_de<T, F>(
                    item.span,
                    &format!("unknown {} attribute `{}`",
                             attribute,
-                             meta_item_to_string(item)));
+                             meta_list_item_to_string(item)));

                return Err(());
            }
@@ -491,23 +506,30 @@ fn get_ser_and_de<T, F>(

 fn get_renames(
    cx: &ExtCtxt,
-    items: &[P<ast::MetaItem>],
-) -> Result<(Option<Spanned<InternedString>>, Option<Spanned<InternedString>>), ()> {
+    items: &[ast::NestedMetaItem],
+) -> Result<SerAndDe<InternedString>, ()> {
    get_ser_and_de(cx, "rename", items, get_str_from_lit)
 }

 fn get_where_predicates(
    cx: &ExtCtxt,
-    items: &[P<ast::MetaItem>],
-) -> Result<(Option<Spanned<Vec<ast::WherePredicate>>>, Option<Spanned<Vec<ast::WherePredicate>>>), ()> {
+    items: &[ast::NestedMetaItem],
+) -> Result<SerAndDe<Vec<ast::WherePredicate>>, ()> {
    get_ser_and_de(cx, "bound", items, parse_lit_into_where)
 }

-pub fn get_serde_meta_items(attr: &ast::Attribute) -> Option<&[P<ast::MetaItem>]> {
+pub fn get_serde_meta_items(attr: &ast::Attribute) -> Option<Vec<ast::MetaItem>> {
    match attr.node.value.node {
        ast::MetaItemKind::List(ref name, ref items) if name == &"serde" => {
-            attr::mark_used(&attr);
-            Some(items)
+            attr::mark_used(attr);
+            Some(items.iter().filter_map(|item| {
+                match item.node {
+                    ast::NestedMetaItemKind::MetaItem(ref meta_item) => {
+                        Some((*meta_item.clone()).clone())
+                    }
+                    _ => None,
+                }
+            }).collect())
        }
        _ => None
    }
@@ -570,7 +592,7 @@ fn get_str_from_lit(cx: &ExtCtxt, name: &str, lit: &ast::Lit) -> Result<Interned
                         name,
                         lit_to_string(lit)));

-            return Err(());
+            Err(())
        }
    }
 }
@@ -0,0 +1,23 @@
+[package]
+name = "serde_derive"
+version = "0.8.9"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+license = "MIT/Apache-2.0"
+description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
+homepage = "https://serde.rs"
+repository = "https://github.com/serde-rs/serde"
+documentation = "https://serde.rs/codegen.html"
+keywords = ["serde", "serialization"]
+include = ["Cargo.toml", "src/**/*.rs"]
+
+[lib]
+name = "serde_derive"
+rustc-macro = true
+
+[dependencies]
+serde_codegen = { version = "=0.8.9", path = "../serde_codegen" }
+
+[dev-dependencies]
+fnv = "1.0"
+serde = { version = "0.8.9", path = "../serde" }
+serde_test = { version = "0.8.9", path = "../serde_test" }
@@ -0,0 +1,21 @@
+#![feature(rustc_macro, rustc_macro_lib)]
+#![cfg(not(test))]
+
+extern crate rustc_macro;
+extern crate serde_codegen;
+
+use rustc_macro::TokenStream;
+
+#[rustc_macro_derive(Serialize)]
+pub fn derive_serialize(input: TokenStream) -> TokenStream {
+    let item = format!("#[derive(Serialize)]\n{}", input);
+    let expanded = serde_codegen::expand_str(&item).unwrap();
+    expanded.parse().unwrap()
+}
+
+#[rustc_macro_derive(Deserialize)]
+pub fn derive_deserialize(input: TokenStream) -> TokenStream {
+    let item = format!("#[derive(Deserialize)]\n{}", input);
+    let expanded = serde_codegen::expand_str(&item).unwrap();
+    expanded.parse().unwrap()
+}
@@ -0,0 +1,8 @@
+#![feature(test, rustc_macro, rustc_attrs)]
+
+#[macro_use]
+extern crate serde_derive;
+
+extern crate test;
+
+include!("../../testing/tests/test.rs.in");
@@ -0,0 +1,2 @@
+# To prevent compiletest from seeing two versions of serde
+paths = ["../serde"]
@@ -1,14 +1,14 @@
 [package]
 name = "serde_macros"
-version = "0.8.1"
+version = "0.8.9"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
+homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
-documentation = "https://github.com/serde-rs/serde"
+documentation = "https://serde.rs/codegen.html"
 keywords = ["serde", "serialization"]
-include = ["Cargo.toml", "src/**/*.rs", "build.rs"]
-build = "build.rs"
+include = ["Cargo.toml", "src/**/*.rs"]

 [lib]
 name = "serde_macros"
@@ -17,37 +17,25 @@ plugin = true
 [features]
 unstable-testing = [
    "clippy",
-    "skeptic",
-    "serde_json",
    "serde/unstable-testing",
    "serde_codegen/unstable-testing"
 ]

-[build-dependencies]
-skeptic = { version = "^0.6.0", optional = true }
-
 [dependencies]
 clippy = { version = "^0.*", optional = true }
-serde_codegen = { version = "=0.8.1", default-features = false, features = ["unstable"], path = "../serde_codegen" }
-skeptic = { version = "^0.6.0", optional = true }
-serde_json = { version = "0.8.0", optional = true }
+serde_codegen = { version = "=0.8.9", default-features = false, features = ["unstable"], path = "../serde_codegen" }

 [dev-dependencies]
-clippy = "^0.*"
 compiletest_rs = "^0.2.0"
 fnv = "1.0"
 rustc-serialize = "^0.3.16"
-serde = { version = "0.8.0", path = "../serde" }
-serde_test = { version = "0.8.0", path = "../serde_test" }
+serde = { version = "0.8.9", path = "../serde" }
+serde_test = { version = "0.8.9", path = "../serde_test" }

 [[test]]
 name = "test"
 path = "tests/test.rs"

-[[test]]
-name = "skeptic"
-path = "tests/skeptic.rs"
-
 [[bench]]
 name = "bench"
 path = "benches/bench.rs"
@@ -1,18 +0,0 @@
-#[cfg(feature = "unstable-testing")]
-mod inner {
-    extern crate skeptic;
-
-    pub fn main() {
-        println!("cargo:rerun-if-changed=../README.md");
-        skeptic::generate_doc_tests(&["../README.md"]);
-    }
-}
-
-#[cfg(not(feature = "unstable-testing"))]
-mod inner {
-    pub fn main() {}
-}
-
-fn main() {
-    inner::main()
-}
@@ -1,3 +0,0 @@
-#![cfg(feature = "unstable-testing")]
-
-include!(concat!(env!("OUT_DIR"), "/skeptic-tests.rs"));
@@ -6,4 +6,3 @@ extern crate test;
 include!("../../testing/tests/test.rs.in");

 mod compile_tests;
-mod skeptic;
@@ -1,14 +1,15 @@
 [package]
 name = "serde_test"
-version = "0.8.0"
+version = "0.8.9"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"
+homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
-documentation = "https://serde-rs.github.io/serde/serde/"
+documentation = "https://docs.serde.rs/serde_test/"
 readme = "../README.md"
 keywords = ["serde", "serialization"]
 include = ["Cargo.toml", "src/**/*.rs"]

 [dependencies]
-serde = { version = "0.8.0", path = "../serde" }
+serde = { version = "0.8.9", path = "../serde" }
@@ -1,11 +1,12 @@
 [package]
 name = "serde_testing"
-version = "0.8.0"
+version = "0.8.9"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
+homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
-documentation = "http://serde-rs.github.io/serde/serde"
+documentation = "https://docs.serde.rs/serde/"
 readme = "README.md"
 keywords = ["serialization"]
 build = "build.rs"
@@ -6,8 +6,14 @@ extern crate serde;
 use self::serde::ser::{Serialize, Serializer};
 use self::serde::de::{Deserialize, Deserializer};

+use std::borrow::Cow;
 use std::marker::PhantomData;

+// Try to trip up the generated code if it fails to use fully qualified paths.
+#[allow(dead_code)]
+struct Result;
+use std::result::Result as StdResult;
+
 //////////////////////////////////////////////////////////////////////////

 #[test]
@@ -177,6 +183,25 @@ fn test_gen() {
        e: E,
    }
    assert::<WithTraits2<X, X>>();
+
+    #[derive(Serialize, Deserialize)]
+    struct CowStr<'a>(Cow<'a, str>);
+    assert::<CowStr>();
+
+    #[derive(Serialize, Deserialize)]
+    #[serde(bound(deserialize = "T::Owned: Deserialize"))]
+    struct CowT<'a, T: ?Sized + 'a + ToOwned>(Cow<'a, T>);
+    assert::<CowT<str>>();
+
+    #[derive(Serialize, Deserialize)]
+    struct EmptyStruct {}
+    assert::<EmptyStruct>();
+
+    #[derive(Serialize, Deserialize)]
+    enum EmptyEnumVariant {
+        EmptyStruct {},
+    }
+    assert::<EmptyEnumVariant>();
 }

 //////////////////////////////////////////////////////////////////////////
@@ -185,32 +210,32 @@ fn assert<T: Serialize + Deserialize>() {}
 fn assert_ser<T: Serialize>() {}

 trait SerializeWith {
-    fn serialize_with<S: Serializer>(_: &Self, _: &mut S) -> Result<(), S::Error>;
+    fn serialize_with<S: Serializer>(_: &Self, _: &mut S) -> StdResult<(), S::Error>;
 }

 trait DeserializeWith: Sized {
-    fn deserialize_with<D: Deserializer>(_: &mut D) -> Result<Self, D::Error>;
+    fn deserialize_with<D: Deserializer>(_: &mut D) -> StdResult<Self, D::Error>;
 }

 // Implements neither Serialize nor Deserialize
 struct X;

-fn ser_x<S: Serializer>(_: &X, _: &mut S) -> Result<(), S::Error> {
+fn ser_x<S: Serializer>(_: &X, _: &mut S) -> StdResult<(), S::Error> {
    unimplemented!()
 }

-fn de_x<D: Deserializer>(_: &mut D) -> Result<X, D::Error> {
+fn de_x<D: Deserializer>(_: &mut D) -> StdResult<X, D::Error> {
    unimplemented!()
 }

 impl SerializeWith for X {
-    fn serialize_with<S: Serializer>(_: &Self, _: &mut S) -> Result<(), S::Error> {
+    fn serialize_with<S: Serializer>(_: &Self, _: &mut S) -> StdResult<(), S::Error> {
        unimplemented!()
    }
 }

 impl DeserializeWith for X {
-    fn deserialize_with<D: Deserializer>(_: &mut D) -> Result<Self, D::Error> {
+    fn deserialize_with<D: Deserializer>(_: &mut D) -> StdResult<Self, D::Error> {
        unimplemented!()
    }
 }
Author	SHA1	Message	Date
Oliver Schneider	429de89276	Release 0.8.9	2016-09-23 07:11:59 -07:00
David Tolnay	7cc36a9cd3	Release 0.8.8	2016-09-08 08:34:20 -07:00
Homu	d343017f47	Auto merge of #546 - serde-rs:qual, r=oli-obk Result needs to be fully qualified Without this: ``` error[E0244]: wrong number of type arguments --> src/api/accounts.rs:19:10 \| 19 \| #[derive(Serialize, Deserialize, Debug)] \| ^^^^^^^^^^ expected 1 type arguments, found 2 ```	2016-09-08 18:05:36 +09:00
David Tolnay	2212bfbf2c	Result needs to be fully qualified Without this: ``` error[E0244]: wrong number of type arguments --> src/api/accounts.rs:19:10 \| 19 \| #[derive(Serialize, Deserialize, Debug)] \| ^^^^^^^^^^ expected 1 type arguments, found 2 ```	2016-09-07 16:37:26 -07:00
David Tolnay	e85ca8411e	Release 0.8.7	2016-09-05 09:39:27 -07:00
Homu	1ff2053262	Auto merge of #536 - serde-rs:mutempty, r=oli-obk Fix "variable does not need to be mutable" warning Fixes #534. cc @EliDupree	2016-09-06 01:10:43 +09:00
Homu	bf779ea343	Auto merge of #525 - serde-rs:forward, r=oli-obk Expose forward_to_deserialize macro Fixes #522. ```rust impl Deserializer for MyDeserializer { fn deserialize<V>(&mut self, visitor: V) -> Result<V::Value, Self::Error> where V: Visitor { /* ... */ } forward_to_deserialize! { bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str string unit option seq seq_fixed_size bytes map unit_struct newtype_struct tuple_struct struct struct_field tuple enum ignored_any } } ``` cc @nox	2016-09-06 00:37:18 +09:00
David Tolnay	8fe66c7f2a	Merge pull request #520 from serde-rs/bytes Add constructors for Bytes and ByteBuf	2016-09-05 08:37:10 -07:00
David Tolnay	e03dedabe4	Use peekable iterator to check for nonzero serialized fields	2016-09-05 08:22:17 -07:00
David Tolnay	08bc2d2e76	Use constructors to create Bytes and ByteBuf	2016-09-05 08:09:23 -07:00
David Tolnay	35be61d85f	Resolve merge conflict	2016-09-05 08:02:35 -07:00
David Tolnay	3692edfd08	Merge branch serde-rs/master into serde-rs/forward	2016-09-05 07:59:42 -07:00
Homu	5a258ade27	Auto merge of #527 - serde-rs:seqvisitor, r=oli-obk Impl SeqVisitor for MapDeserializer @nox is this what you were trying to implement?	2016-09-05 20:09:44 +09:00
Homu	f3052c392e	Auto merge of #538 - serde-rs:notfalse, r=oli-obk Remove `if !false { ... }` from generated serialization code I don't think this negatively affects maintainability of the code in serde_codegen and I think there is some value in keeping our generated code relatively clear so that people can use it as a template when implementing Serialize manually with minor modifications.	2016-09-05 19:52:43 +09:00
David Tolnay	d1ce4d62c9	Change to expression so that syntex keeps the semicolon	2016-09-02 18:07:26 -07:00
David Tolnay	869ebd9e4e	Remove `if !false { ... }` from generated serialization code	2016-09-02 17:22:58 -07:00
David Tolnay	14446af537	Fix "variable does not need to be mutable" warning	2016-09-02 11:42:33 -07:00
David Tolnay	248d937f9a	Release 0.8.6	2016-09-01 22:06:27 -07:00
David Tolnay	ffa2f80186	Merge pull request #530 from serde-rs/derive Macros 1.1	2016-09-01 21:59:32 -07:00
David Tolnay	ac1128a647	Update serde_derive to 0.8.5	2016-09-01 21:28:58 -07:00
David Tolnay	88d845c4d1	Include! test suite for serde_derive	2016-09-01 21:28:40 -07:00
David Tolnay	87a402a751	Remove rustc_macro test crate	2016-09-01 11:17:35 -07:00
David Tolnay	cdb0e6c899	Remove build script in favor of rust-lang/cargo#3064	2016-08-31 21:05:40 -07:00
David Tolnay	54cee86fd3	Bump to 0.8.5	2016-08-31 20:14:44 -07:00
David Tolnay	178edd1abc	Merge branch origin/master into origin/derive	2016-08-31 20:12:46 -07:00
David Tolnay	4bb9279074	Bump syntex to 0.43	2016-08-31 12:53:27 -07:00
David Tolnay	3c45e5c7a5	Next iteration	2016-08-30 23:55:08 -07:00
David Tolnay	d36f28971c	Support no_std in forward_to_deserialize macro	2016-08-29 00:27:11 -07:00
David Tolnay	d914fdf67b	Macros 1.1	2016-08-28 22:21:25 -07:00
David Tolnay	7014c105b4	Remove coverage shield	2016-08-28 08:39:53 -07:00
David Tolnay	f3d566af09	Remove clippy shield	2016-08-28 08:37:55 -07:00
David Tolnay	278e8eb720	Add deserialize_seq methods to MapDeserializer	2016-08-25 10:45:25 -04:00
David Tolnay	e9b04de9a5	Impl SeqVisitor for MapDeserializer	2016-08-25 10:12:23 -04:00
David Tolnay	2a2891d54b	Expose forward_to_deserialize macro	2016-08-24 00:16:22 -04:00
David Tolnay	123e040189	Merge pull request #524 from serde-rs/skeptic Remove skeptic	2016-08-23 22:17:13 -04:00
David Tolnay	6f0f273d9c	Remove skeptic	2016-08-23 22:04:50 -04:00
David Tolnay	fb7ba225d1	Add constructors for Bytes and ByteBuf This commit adds `Bytes::new(&[u8])` and `ByteBuf::from<T: Into<Vec<u8>>>(T)`.	2016-08-23 16:24:00 -04:00
David Tolnay	d690ffda8d	Release 0.8.4	2016-08-22 11:37:53 -04:00
David Tolnay	18a775277f	Merge pull request #514 from nox/maps Introduce MapDeserializer::unbounded (fixes #512)	2016-08-22 09:05:50 -04:00
Anthony Ramine	fbb250766d	Introduce MapDeserializer::unbounded (fixes #512 )	2016-08-22 09:11:10 +02:00
David Tolnay	71116b860a	Merge pull request #513 from nox/cow Implement ValueDeserializer for Cow<str>	2016-08-21 14:07:56 -04:00
Anthony Ramine	ce3f134145	Implement ValueDeserializer for Cow<str>	2016-08-21 19:52:13 +02:00
David Tolnay	80507d650c	Merge pull request #511 from serde-rs/extra Switch to syntex::with_extra_stack	2016-08-19 21:27:17 -04:00
David Tolnay	0ae61a3dd1	Switch to syntex::with_extra_stack	2016-08-19 21:09:55 -04:00
David Tolnay	5fb73073bd	Release 0.8.3	2016-08-19 13:11:59 -04:00
David Tolnay	63d484d50c	Merge pull request #510 from serde-rs/clippy Re-enable clippy	2016-08-19 13:01:24 -04:00
David Tolnay	f3f29f81bc	Fix new lints	2016-08-19 12:46:45 -04:00
David Tolnay	621588b258	Revert "Disable clippy until Manishearth/rust-clippy#1174 is fixed" This reverts commit `2bc1d62e50`.	2016-08-19 11:47:31 -04:00
Homu	7aba920dec	Auto merge of #509 - serde-rs:cow, r=oli-obk Fix codegen with lifetimes but no type parameters Fixes #507.	2016-08-20 00:16:54 +09:00
David Tolnay	a732b9bad3	Fix codegen with lifetimes but no type parameters	2016-08-19 11:12:38 -04:00
Oliver Schneider	6723da67b3	Merge pull request #506 from serde-rs/https HTTPS for serde.rs	2016-08-19 10:57:52 +02:00
David Tolnay	2d99a50c27	HTTPS for serde.rs	2016-08-18 17:08:05 -04:00
David Tolnay	01f6115d73	Merge pull request #503 from serde-rs/stack Set RUST_MIN_STACK if unset	2016-08-18 16:09:09 -04:00
David Tolnay	a4eb9d5788	Merge pull request #499 from serde-rs/ord Simplify BTreeMapVisitor trait bounds	2016-08-18 15:44:03 -04:00
David Tolnay	6f77ea58fd	Merge branch origin/master into origin/stack	2016-08-18 15:26:14 -04:00
David Tolnay	2cb55e8cb9	Merge branch origin/master into origin/ord	2016-08-18 15:25:47 -04:00
David Tolnay	671f5ebd07	Path override to prevent compiletest from seeing 2 versions of serde	2016-08-18 15:05:07 -04:00
David Tolnay	2bc1d62e50	Disable clippy until Manishearth/rust-clippy#1174 is fixed	2016-08-18 14:51:25 -04:00
David Tolnay	1796536962	Update syntex to 0.41	2016-08-18 14:33:14 -04:00
David Tolnay	dba1377d1f	Set RUST_MIN_STACK if unset	2016-08-18 13:55:58 -04:00
Oliver Schneider	ce66b230e3	Merge pull request #502 from serde-rs/help Getting help	2016-08-18 17:08:30 +02:00
David Tolnay	affc81b1d6	Getting help	2016-08-18 10:56:41 -04:00
Oliver Schneider	c3ec05f410	Merge pull request #501 from serde-rs/readme Condense readme and link to serde.rs	2016-08-18 13:22:53 +02:00
David Tolnay	332d59f362	Condense readme and link to serde.rs	2016-08-18 01:11:36 -04:00
David Tolnay	d98172f330	Simplify BTreeMapVisitor trait bounds `Ord` implies `Eq`.	2016-08-17 23:11:38 -04:00
David Tolnay	e0c9bd4b87	Remove doc-upload	2016-08-13 19:15:48 -07:00
David Tolnay	33d26c6d38	Remove CNAME This is now managed by github.com/serde-rs/docs.	2016-08-13 17:54:56 -07:00
David Tolnay	0557a7feac	Point links to docs.serde.rs	2016-08-13 15:01:57 -07:00
Oliver Schneider	d46db730ff	Merge pull request #490 from bluss/patch-1 Adjust doc(html_root_url)	2016-08-12 15:59:18 +02:00
bluss	07b1acc9f5	Adjust doc(html_root_url) The URL does not need to contain the crate name. With this URL rustdoc can generate correct external doc links.	2016-08-12 15:53:07 +02:00
David Tolnay	85864e6ccb	Bump remaining versions to 0.8.1	2016-08-11 09:16:29 -07:00
David Tolnay	1f31bb2db9	Merge pull request #489 from oli-obk/docs fix an example in the README	2016-08-11 08:41:59 -07:00
Oliver Schneider	6b5bd24edd	fix an example in the README (thanks @nox)	2016-08-11 13:57:43 +02:00