Bug 1396821 - Update vendored Rust crates. draft
authorHenrik Skupin <mail@hskupin.info>
Wed, 15 Aug 2018 16:47:14 +0200
changeset 829698 195c8b10ed2d8319dfe7aa7f5ea5dc35b5d82b3c
parent 829697 295bd1f706de0fe70892d8b1c5a5c2eb205295a9
push id118789
push userbmo:hskupin@gmail.com
push dateThu, 16 Aug 2018 12:52:34 +0000
bugs1396821
milestone63.0a1
Bug 1396821 - Update vendored Rust crates. MozReview-Commit-ID: D8W2mtdAmpb
Cargo.lock
third_party/rust/rustc-serialize/.cargo-checksum.json
third_party/rust/rustc-serialize/.travis.yml
third_party/rust/rustc-serialize/Cargo.toml
third_party/rust/rustc-serialize/LICENSE-APACHE
third_party/rust/rustc-serialize/LICENSE-MIT
third_party/rust/rustc-serialize/README.md
third_party/rust/rustc-serialize/appveyor.yml
third_party/rust/rustc-serialize/benches/base64.rs
third_party/rust/rustc-serialize/benches/hex.rs
third_party/rust/rustc-serialize/benches/json.rs
third_party/rust/rustc-serialize/src/base64.rs
third_party/rust/rustc-serialize/src/collection_impls.rs
third_party/rust/rustc-serialize/src/hex.rs
third_party/rust/rustc-serialize/src/json.rs
third_party/rust/rustc-serialize/src/lib.rs
third_party/rust/rustc-serialize/src/serialize.rs
third_party/rust/serde_json/.cargo-checksum.json
third_party/rust/serde_json/Cargo.toml
third_party/rust/serde_json/LICENSE-APACHE
third_party/rust/serde_json/LICENSE-MIT
third_party/rust/serde_json/README.md
third_party/rust/serde_json/src/de.rs
third_party/rust/serde_json/src/error.rs
third_party/rust/serde_json/src/iter.rs
third_party/rust/serde_json/src/lib.rs
third_party/rust/serde_json/src/macros.rs
third_party/rust/serde_json/src/map.rs
third_party/rust/serde_json/src/number.rs
third_party/rust/serde_json/src/read.rs
third_party/rust/serde_json/src/ser.rs
third_party/rust/serde_json/src/value/de.rs
third_party/rust/serde_json/src/value/from.rs
third_party/rust/serde_json/src/value/index.rs
third_party/rust/serde_json/src/value/mod.rs
third_party/rust/serde_json/src/value/partial_eq.rs
third_party/rust/serde_json/src/value/ser.rs
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -133,24 +133,16 @@ dependencies = [
  "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
  "slab 0.3.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "tokio-core 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "tokio-uds 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "base64"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "base64"
 version = "0.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "byteorder 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "safemem 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
@@ -809,17 +801,17 @@ dependencies = [
  "winapi 0.2.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "winapi-build 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "geckodriver"
 version = "0.21.0"
 dependencies = [
- "base64 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "base64 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "chrono 0.2.25 (registry+https://github.com/rust-lang/crates.io-index)",
  "clap 2.31.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "hyper 0.10.13 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "mozprofile 0.3.0",
  "mozrunner 0.7.0",
  "mozversion 0.1.3",
@@ -1801,17 +1793,17 @@ source = "registry+https://github.com/ru
 dependencies = [
  "serde 1.0.66 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "rsdparsa"
 version = "0.1.0"
 dependencies = [
- "log 0.3.9 (registry+https://github.com/rust-lang/crates.io-index)",
+ "log 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.66 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.66 (git+https://github.com/servo/serde?branch=deserialize_from_enums8)",
 ]
 
 [[package]]
 name = "rsdparsa_capi"
 version = "0.1.0"
 dependencies = [
@@ -2412,17 +2404,17 @@ dependencies = [
  "same-file 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "winapi 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "webdriver"
 version = "0.36.0"
 dependencies = [
- "base64 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "base64 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "cookie 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "hyper 0.10.13 (registry+https://github.com/rust-lang/crates.io-index)",
  "lazy_static 1.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "regex 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.66 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_derive 1.0.66 (git+https://github.com/servo/serde?branch=deserialize_from_enums8)",
  "serde_json 1.0.22 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2634,17 +2626,16 @@ dependencies = [
 "checksum ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ee49baf6cb617b853aa8d93bf420db2383fab46d314482ca2803b40d5fde979b"
 "checksum app_units 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "9dadc668390b373e73e4abbfc1f07238b09a25858f2f39c06cebc6d8e141d774"
 "checksum arrayref 0.3.4 (registry+https://github.com/rust-lang/crates.io-index)" = "0fd1479b7c29641adbd35ff3b5c293922d696a92f25c8c975da3e0acbc87258f"
 "checksum arrayvec 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)" = "2f0ef4a9820019a0c91d918918c93dc71d469f581a49b47ddc1d285d4270bbe2"
 "checksum ascii-canvas 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "b385d69402821a1c254533a011a312531cbcc0e3e24f19bbb4747a5a2daf37e2"
 "checksum atomic_refcell 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "fb2dcb6e6d35f20276943cc04bb98e538b348d525a04ac79c10021561d202f21"
 "checksum atty 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d0fd4c0631f06448cc45a6bbb3b710ebb7ff8ccb96a0800c994afe23a70d5df2"
 "checksum atty 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "d912da0db7fa85514874458ca3651fe2cddace8d0b0505571dbdcd41ab490159"
-"checksum base64 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "30e93c03064e7590d0466209155251b90c22e37fab1daf2771582598b5827557"
 "checksum base64 0.6.0 (registry+https://github.com/rust-lang/crates.io-index)" = "96434f987501f0ed4eb336a411e0631ecd1afa11574fe148587adc4ff96143c9"
 "checksum binary-space-partition 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "88ceb0d16c4fd0e42876e298d7d3ce3780dd9ebdcbe4199816a32c77e08597ff"
 "checksum bincode 1.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bda13183df33055cbb84b847becce220d392df502ebe7a4a78d7021771ed94d0"
 "checksum bindgen 0.37.4 (registry+https://github.com/rust-lang/crates.io-index)" = "1b25ab82877ea8fe6ce1ce1f8ac54361f0218bad900af9eb11803994bf67c221"
 "checksum binjs_meta 0.3.8 (registry+https://github.com/rust-lang/crates.io-index)" = "fd7ca5635f1c6f94aaef7de76cb834c5920578355ce41dbcaf731b7ebe348518"
 "checksum bit-set 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d9bf6104718e80d7b26a68fdbacff3481cfc05df670821affc7e9cbc1884400c"
 "checksum bit-vec 0.4.4 (registry+https://github.com/rust-lang/crates.io-index)" = "02b4ff8b16e6076c3e14220b39fbc1fabb6737522281a388998046859400895f"
 "checksum bitflags 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "aad18937a628ec6abcd26d1489012cc0e18c21798210f491af69ded9b881106d"
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/.cargo-checksum.json
+++ /dev/null
@@ -1,1 +0,0 @@
-{"files":{".travis.yml":"03dcea6dcd54625b42d91176e86718626dfd911744a343dee3edefa001e87dc5","Cargo.toml":"01199fa6ca6337a7513e9ef8951268b8882347e5affaa50e710ac4960d9c65e0","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"0aebc3beb6fc32d6073582d5fea170761689a2c83cddb5436aa26e57b7d04e7b","appveyor.yml":"da991211b72fa6f231af7adb84c9fb72f5a9131d1c0a3d47b8ceffe5a82c8542","benches/base64.rs":"96f7d0c7d260362e41b8cefb4839f1e1b3c18c2f10344f6ccafac7c434f99ca9","benches/hex.rs":"057821307b4b7de02f2c267f9248457386035382916c5afe4b72d6f2e905062c","benches/json.rs":"659f2ae2e1ad5ed022fafce6418d17dfe09c3dcb3f054857dce0effc907da850","src/base64.rs":"57649c590c1fba643ff955910f1d4427feda43414bb0863cd279bea56c3ff178","src/collection_impls.rs":"8ae6bc0d61a4777d834c2b24fa987550cb13c570e1564f87ee32eceff3cb2d5b","src/hex.rs":"a2ba86cf47035b5d9cbf4adf8dc3e941d4e0a6ce1a61a29cbb14ea1fdabac6bb","src/json.rs":"75a788a46612c73bfd14af20fb48855dc8c930747c5255a288d2d09de25ea960","src/lib.rs":"a0e4a368a609f019434e7584f54448cf33ebf3e37e3fb1dd5537d300088184b1","src/serialize.rs":"7ddcc3c32843850e30d05b82a8cda8ae63ec0016e2b0bfbcc46a03ea3ea986e8"},"package":"dcf128d1287d2ea9d80910b5f1120d0b8eede3fbf1abe91c40d39ea7d51e6fda"}
\ No newline at end of file
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/.travis.yml
+++ /dev/null
@@ -1,24 +0,0 @@
-language: rust
-rust:
-  - 1.0.0
-  - stable
-  - beta
-  - nightly
-sudo: false
-before_script:
-  - pip install 'travis-cargo<0.2' --user && export PATH=$HOME/.local/bin:$PATH
-script:
-  - cargo build --verbose
-  - cargo test --verbose
-  - cargo doc --no-deps
-after_success:
-  - travis-cargo --only nightly doc-upload
-env:
-  global:
-    secure: "kJnqqAXRl0C7Afx0c8Y3vA6TAEZsxlasu7eIZMdCbNS4N1+Rwh0jNTa2jy2D3CQCrzW5OCefnkpkPTu8mADrAjedM4p/9X5UXZi0sgg2lzCgfGwrRzitTnyPDkdYidiu4QeC/r0WPC8lYZKHkJXYhF8bZgchB9ypnZ6LAHCcDkA="
-
-
-
-notifications:
-  email:
-    on_success: never
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-
-name = "rustc-serialize"
-version = "0.3.24"
-authors = ["The Rust Project Developers"]
-license = "MIT/Apache-2.0"
-readme = "README.md"
-repository = "https://github.com/rust-lang/rustc-serialize"
-homepage = "https://github.com/rust-lang/rustc-serialize"
-documentation = "https://doc.rust-lang.org/rustc-serialize"
-description = """
-Generic serialization/deserialization support corresponding to the
-`derive(RustcEncodable, RustcDecodable)` mode in the compiler. Also includes
-support for hex, base64, and json encoding and decoding.
-"""
-
-[dev-dependencies]
-rand = "0.3"
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/README.md
+++ /dev/null
@@ -1,31 +0,0 @@
-# rustc-serialize
-
-> **NOTE**: This crate is deprecated in favor of [`serde`]. No new feature
-> development will happen in this crate, although bug fixes proposed through PRs
-> will still be merged. It is very highly recommended by the Rust Library Team
-> that you use [`serde`], not this crate.
-
-[`serde`]: https://serde.rs
-
-Serialization and deserialization support provided by the compiler in the form
-of `derive(RustcEncodable, RustcDecodable)`.
-
-[![Linux Build Status](https://travis-ci.org/rust-lang-nursery/rustc-serialize.svg?branch=master)](https://travis-ci.org/rust-lang-nursery/rustc-serialize)
-[![Windows Build Status](https://ci.appveyor.com/api/projects/status/ka194de75aapwpft?svg=true)](https://ci.appveyor.com/project/alexcrichton/rustc-serialize)
-
-[Documentation](https://doc.rust-lang.org/rustc-serialize)
-
-## Usage
-
-Add this to your `Cargo.toml`:
-
-```toml
-[dependencies]
-rustc-serialize = "0.3"
-```
-
-and this to your crate root:
-
-```rust
-extern crate rustc_serialize;
-```
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/appveyor.yml
+++ /dev/null
@@ -1,17 +0,0 @@
-environment:
-  matrix:
-  - TARGET: x86_64-pc-windows-msvc
-  - TARGET: i686-pc-windows-msvc
-  - TARGET: i686-pc-windows-gnu
-install:
-  - ps: Start-FileDownload "https://static.rust-lang.org/dist/rust-nightly-${env:TARGET}.exe"
-  - rust-nightly-%TARGET%.exe /VERYSILENT /NORESTART /DIR="C:\Program Files (x86)\Rust"
-  - SET PATH=%PATH%;C:\Program Files (x86)\Rust\bin
-  - SET PATH=%PATH%;C:\MinGW\bin
-  - rustc -V
-  - cargo -V
-
-build: false
-
-test_script:
-  - cargo test --verbose
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/benches/base64.rs
+++ /dev/null
@@ -1,48 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-extern crate rustc_serialize;
-
-use rustc_serialize::base64::{FromBase64, ToBase64, STANDARD};
-use test::Bencher;
-
-#[bench]
-fn bench_to_base64(b: &mut Bencher) {
-    let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
-             ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
-    b.iter(|| {
-        s.as_bytes().to_base64(STANDARD);
-    });
-    b.bytes = s.len() as u64;
-}
-
-#[bench]
-fn bench_from_base64(b: &mut Bencher) {
-    let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
-             ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
-    let sb = s.as_bytes().to_base64(STANDARD);
-    b.iter(|| {
-        sb.from_base64().unwrap();
-    });
-    b.bytes = sb.len() as u64;
-}
-
-
-#[bench]
-fn bench_to_base64_large(b: &mut Bencher) {
-    let s: Vec<_> = (0..10000).map(|i| ((i as u32 * 12345) % 256) as u8).collect();
-    b.iter(|| {
-        s.to_base64(STANDARD);
-    });
-    b.bytes = s.len() as u64;
-}
-
-#[bench]
-fn bench_from_base64_large(b: &mut Bencher) {
-    let s: Vec<_> = (0..10000).map(|i| ((i as u32 * 12345) % 256) as u8).collect();
-    let sb = s.to_base64(STANDARD);
-    b.iter(|| {
-        sb.from_base64().unwrap();
-    });
-    b.bytes = sb.len() as u64;
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/benches/hex.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-extern crate rustc_serialize;
-
-use test::Bencher;
-use rustc_serialize::hex::{FromHex, ToHex};
-
-#[bench]
-fn bench_to_hex(b: &mut Bencher) {
-    let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
-             ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
-    b.iter(|| {
-        s.as_bytes().to_hex();
-    });
-    b.bytes = s.len() as u64;
-}
-
-#[bench]
-fn bench_from_hex(b: &mut Bencher) {
-    let s = "イロハニホヘト チリヌルヲ ワカヨタレソ ツネナラム \
-             ウヰノオクヤマ ケフコエテ アサキユメミシ ヱヒモセスン";
-    let sb = s.as_bytes().to_hex();
-    b.iter(|| {
-        sb.from_hex().unwrap();
-    });
-    b.bytes = sb.len() as u64;
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/benches/json.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-#![feature(test)]
-
-extern crate test;
-extern crate rustc_serialize;
-
-use std::string;
-use rustc_serialize::json::{Json, Parser};
-use test::Bencher;
-
-#[bench]
-fn bench_streaming_small(b: &mut Bencher) {
-    b.iter( || {
-        let mut parser = Parser::new(
-            r#"{
-                "a": 1.0,
-                "b": [
-                    true,
-                    "foo\nbar",
-                    { "c": {"d": null} }
-                ]
-            }"#.chars()
-        );
-        loop {
-            match parser.next() {
-                None => return,
-                _ => {}
-            }
-        }
-    });
-}
-#[bench]
-fn bench_small(b: &mut Bencher) {
-    b.iter( || {
-        let _ = Json::from_str(r#"{
-            "a": 1.0,
-            "b": [
-                true,
-                "foo\nbar",
-                { "c": {"d": null} }
-            ]
-        }"#);
-    });
-}
-
-#[bench]
-fn bench_decode_hex_escape(b: &mut Bencher) {
-    let mut src = "\"".to_string();
-    for _ in 0..10 {
-        src.push_str("\\uF975\\uf9bc\\uF9A0\\uF9C4\\uF975\\uf9bc\\uF9A0\\uF9C4");
-    }
-    src.push_str("\"");
-    b.iter( || {
-        let _ = Json::from_str(&src);
-    });
-}
-
-fn big_json() -> string::String {
-    let mut src = "[\n".to_string();
-    for _ in 0..500 {
-        src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \
-                        [1,2,3]},"#);
-    }
-    src.push_str("{}]");
-    return src;
-}
-
-#[bench]
-fn bench_streaming_large(b: &mut Bencher) {
-    let src = big_json();
-    b.iter( || {
-        let mut parser = Parser::new(src.chars());
-        loop {
-            match parser.next() {
-                None => return,
-                _ => {}
-            }
-        }
-    });
-}
-#[bench]
-fn bench_large(b: &mut Bencher) {
-    let src = big_json();
-    b.iter( || { let _ = Json::from_str(&src); });
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/base64.rs
+++ /dev/null
@@ -1,489 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-//
-// ignore-lexer-test FIXME #15679
-
-//! Base64 binary-to-text encoding
-
-pub use self::FromBase64Error::*;
-pub use self::CharacterSet::*;
-
-use std::fmt;
-use std::error;
-
-/// Available encoding character sets
-#[derive(Clone, Copy, Debug)]
-pub enum CharacterSet {
-    /// The standard character set (uses `+` and `/`)
-    Standard,
-    /// The URL safe character set (uses `-` and `_`)
-    UrlSafe
-}
-
-/// Available newline types
-#[derive(Clone, Copy, Debug)]
-pub enum Newline {
-    /// A linefeed (i.e. Unix-style newline)
-    LF,
-    /// A carriage return and a linefeed (i.e. Windows-style newline)
-    CRLF
-}
-
-/// Contains configuration parameters for `to_base64`.
-#[derive(Clone, Copy, Debug)]
-pub struct Config {
-    /// Character set to use
-    pub char_set: CharacterSet,
-    /// Newline to use
-    pub newline: Newline,
-    /// True to pad output with `=` characters
-    pub pad: bool,
-    /// `Some(len)` to wrap lines at `len`, `None` to disable line wrapping
-    pub line_length: Option<usize>
-}
-
-/// Configuration for RFC 4648 standard base64 encoding
-pub static STANDARD: Config =
-    Config {char_set: Standard, newline: Newline::CRLF, pad: true, line_length: None};
-
-/// Configuration for RFC 4648 base64url encoding
-pub static URL_SAFE: Config =
-    Config {char_set: UrlSafe, newline: Newline::CRLF, pad: false, line_length: None};
-
-/// Configuration for RFC 2045 MIME base64 encoding
-pub static MIME: Config =
-    Config {char_set: Standard, newline: Newline::CRLF, pad: true, line_length: Some(76)};
-
-static STANDARD_CHARS: &'static[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
-                                        abcdefghijklmnopqrstuvwxyz\
-                                        0123456789+/";
-
-static URLSAFE_CHARS: &'static[u8] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ\
-                                       abcdefghijklmnopqrstuvwxyz\
-                                       0123456789-_";
-
-/// A trait for converting a value to base64 encoding.
-pub trait ToBase64 {
-    /// Converts the value of `self` to a base64 value following the specified
-    /// format configuration, returning the owned string.
-    fn to_base64(&self, config: Config) -> String;
-}
-
-impl ToBase64 for [u8] {
-    /// Turn a vector of `u8` bytes into a base64 string.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// extern crate rustc_serialize;
-    /// use rustc_serialize::base64::{ToBase64, STANDARD};
-    ///
-    /// fn main () {
-    ///     let str = [52,32].to_base64(STANDARD);
-    ///     println!("base 64 output: {:?}", str);
-    /// }
-    /// ```
-    fn to_base64(&self, config: Config) -> String {
-        let bytes = match config.char_set {
-            Standard => STANDARD_CHARS,
-            UrlSafe => URLSAFE_CHARS
-        };
-
-        let len = self.len();
-        let newline = match config.newline {
-            Newline::LF => "\n",
-            Newline::CRLF => "\r\n",
-        };
-
-        // Preallocate memory.
-        let mut prealloc_len = (len + 2) / 3 * 4;
-        if let Some(line_length) = config.line_length {
-            let num_lines = match prealloc_len {
-                0 => 0,
-                n => (n - 1) / line_length
-            };
-            prealloc_len += num_lines * newline.bytes().count();
-        }
-
-        let mut out_bytes = vec![b'='; prealloc_len];
-
-        // Deal with padding bytes
-        let mod_len = len % 3;
-
-        // Use iterators to reduce branching
-        {
-            let mut cur_length = 0;
-
-            let mut s_in = self[..len - mod_len].iter().map(|&x| x as u32);
-            let mut s_out = out_bytes.iter_mut();
-
-            // Convenient shorthand
-            let enc = |val| bytes[val as usize];
-            let mut write = |val| *s_out.next().unwrap() = val;
-
-            // Iterate though blocks of 4
-            while let (Some(first), Some(second), Some(third)) =
-                        (s_in.next(), s_in.next(), s_in.next()) {
-
-                // Line break if needed
-                if let Some(line_length) = config.line_length {
-                    if cur_length >= line_length {
-                        for b in newline.bytes() { write(b) };
-                        cur_length = 0;
-                    }
-                }
-
-                let n = first << 16 | second << 8 | third;
-
-                // This 24-bit number gets separated into four 6-bit numbers.
-                write(enc((n >> 18) & 63));
-                write(enc((n >> 12) & 63));
-                write(enc((n >> 6 ) & 63));
-                write(enc((n >> 0 ) & 63));
-
-                cur_length += 4;
-            }
-
-            // Line break only needed if padding is required
-            if mod_len != 0 {
-                if let Some(line_length) = config.line_length {
-                    if cur_length >= line_length {
-                        for b in newline.bytes() { write(b) };
-                    }
-                }
-            }
-
-            // Heh, would be cool if we knew this was exhaustive
-            // (the dream of bounded integer types)
-            match mod_len {
-                0 => (),
-                1 => {
-                    let n = (self[len-1] as u32) << 16;
-                    write(enc((n >> 18) & 63));
-                    write(enc((n >> 12) & 63));
-                }
-                2 => {
-                    let n = (self[len-2] as u32) << 16 |
-                            (self[len-1] as u32) << 8;
-                    write(enc((n >> 18) & 63));
-                    write(enc((n >> 12) & 63));
-                    write(enc((n >> 6 ) & 63));
-                }
-                _ => panic!("Algebra is broken, please alert the math police")
-            }
-        }
-
-        // We get padding for "free", so only have to drop it if unwanted.
-        if !config.pad {
-            while let Some(&b'=') = out_bytes.last() {
-                out_bytes.pop();
-            }
-        }
-
-        unsafe { String::from_utf8_unchecked(out_bytes) }
-    }
-}
-
-impl<'a, T: ?Sized + ToBase64> ToBase64 for &'a T {
-    fn to_base64(&self, config: Config) -> String {
-        (**self).to_base64(config)
-    }
-}
-
-/// A trait for converting from base64 encoded values.
-pub trait FromBase64 {
-    /// Converts the value of `self`, interpreted as base64 encoded data, into
-    /// an owned vector of bytes, returning the vector.
-    fn from_base64(&self) -> Result<Vec<u8>, FromBase64Error>;
-}
-
-/// Errors that can occur when decoding a base64 encoded string
-#[derive(Clone, Copy)]
-pub enum FromBase64Error {
-    /// The input contained a character not part of the base64 format
-    InvalidBase64Byte(u8, usize),
-    /// The input had an invalid length
-    InvalidBase64Length,
-}
-
-impl fmt::Debug for FromBase64Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            InvalidBase64Byte(ch, idx) =>
-                write!(f, "Invalid character '{}' at position {}", ch, idx),
-            InvalidBase64Length => write!(f, "Invalid length"),
-        }
-    }
-}
-
-impl error::Error for FromBase64Error {
-    fn description(&self) -> &str {
-        match *self {
-            InvalidBase64Byte(_, _) => "invalid character",
-            InvalidBase64Length => "invalid length",
-        }
-    }
-}
-
-impl fmt::Display for FromBase64Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self, f)
-    }
-}
-
-impl FromBase64 for str {
-    /// Convert any base64 encoded string (literal, `@`, `&`, or `~`)
-    /// to the byte values it encodes.
-    ///
-    /// You can use the `String::from_utf8` function to turn a `Vec<u8>` into a
-    /// string with characters corresponding to those values.
-    ///
-    /// # Example
-    ///
-    /// This converts a string literal to base64 and back.
-    ///
-    /// ```rust
-    /// extern crate rustc_serialize;
-    /// use rustc_serialize::base64::{ToBase64, FromBase64, STANDARD};
-    ///
-    /// fn main () {
-    ///     let hello_str = b"Hello, World".to_base64(STANDARD);
-    ///     println!("base64 output: {}", hello_str);
-    ///     let res = hello_str.from_base64();
-    ///     if res.is_ok() {
-    ///       let opt_bytes = String::from_utf8(res.unwrap());
-    ///       if opt_bytes.is_ok() {
-    ///         println!("decoded from base64: {:?}", opt_bytes.unwrap());
-    ///       }
-    ///     }
-    /// }
-    /// ```
-    #[inline]
-    fn from_base64(&self) -> Result<Vec<u8>, FromBase64Error> {
-        self.as_bytes().from_base64()
-    }
-}
-
-impl FromBase64 for [u8] {
-    fn from_base64(&self) -> Result<Vec<u8>, FromBase64Error> {
-        let mut r = Vec::with_capacity(self.len());
-        let mut buf: u32 = 0;
-        let mut modulus = 0;
-
-        let mut it = self.iter();
-        for byte in it.by_ref() {
-            let code = DECODE_TABLE[*byte as usize];
-            if code >= SPECIAL_CODES_START {
-                match code {
-                    NEWLINE_CODE => continue,
-                    EQUALS_CODE => break,
-                    INVALID_CODE => return Err(InvalidBase64Byte(
-                            *byte, (byte as *const _ as usize) - self.as_ptr() as usize)),
-                    _ => unreachable!(),
-                }
-            }
-            buf = (buf | code as u32) << 6;
-            modulus += 1;
-            if modulus == 4 {
-                modulus = 0;
-                r.push((buf >> 22) as u8);
-                r.push((buf >> 14) as u8);
-                r.push((buf >> 6 ) as u8);
-            }
-        }
-
-        for byte in it {
-            match *byte {
-                b'=' | b'\r' | b'\n' => continue,
-                _ => return Err(InvalidBase64Byte(
-                        *byte, (byte as *const _ as usize) - self.as_ptr() as usize)),
-            }
-        }
-
-        match modulus {
-            2 => {
-                r.push((buf >> 10) as u8);
-            }
-            3 => {
-                r.push((buf >> 16) as u8);
-                r.push((buf >> 8 ) as u8);
-            }
-            0 => (),
-            _ => return Err(InvalidBase64Length),
-        }
-
-        Ok(r)
-    }
-}
-
-impl<'a, T: ?Sized + FromBase64> FromBase64 for &'a T {
-    fn from_base64(&self) -> Result<Vec<u8>, FromBase64Error> {
-        (**self).from_base64()
-    }
-}
-
-/// Base64 decoding lookup table, generated using:
-///
-/// ```
-/// let mut ch = 0u8;
-/// for ch in 0..255 {
-///     let mut ch = ch as u8;
-///     let code = match ch {
-///         b'A'...b'Z' => ch - 0x41,
-///         b'a'...b'z' => ch - 0x47,
-///         b'0'...b'9' => ch + 0x04,
-///         b'+' | b'-' => 0x3E,
-///         b'/' | b'_' => 0x3F,
-///         b'=' => 0xFE,
-///         b'\r' | b'\n' => 0xFD,
-///         _ => 0xFF,
-///     };
-///     print!("0x{:02X}, ", code);
-///     if ch % 16  == 15 { println!(""); }
-///     else if ch == 0xFF { break; }
-///     ch += 1;
-/// }
-/// println!("");
-/// ```
-const DECODE_TABLE: [u8; 256] = [
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xFF, 0xFF, 0xFD, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x3E, 0xFF, 0x3E, 0xFF, 0x3F,
-    0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF,
-    0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
-    0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0x3F,
-    0xFF, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
-    0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-    0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
-];
-const INVALID_CODE: u8 = 0xFF;
-const EQUALS_CODE: u8 = 0xFE;
-const NEWLINE_CODE: u8 = 0xFD;
-const SPECIAL_CODES_START: u8 = NEWLINE_CODE;
-
-#[cfg(test)]
-mod tests {
-    use base64::{Config, Newline, FromBase64, ToBase64, STANDARD, URL_SAFE};
-
-    #[test]
-    fn test_to_base64_basic() {
-        assert_eq!("".as_bytes().to_base64(STANDARD), "");
-        assert_eq!("f".as_bytes().to_base64(STANDARD), "Zg==");
-        assert_eq!("fo".as_bytes().to_base64(STANDARD), "Zm8=");
-        assert_eq!("foo".as_bytes().to_base64(STANDARD), "Zm9v");
-        assert_eq!("foob".as_bytes().to_base64(STANDARD), "Zm9vYg==");
-        assert_eq!("fooba".as_bytes().to_base64(STANDARD), "Zm9vYmE=");
-        assert_eq!("foobar".as_bytes().to_base64(STANDARD), "Zm9vYmFy");
-    }
-
-    #[test]
-    fn test_to_base64_crlf_line_break() {
-        assert!(![0; 1000].to_base64(Config {line_length: None, ..STANDARD})
-                              .contains("\r\n"));
-        assert_eq!(b"foobar".to_base64(Config {line_length: Some(4),
-                                               ..STANDARD}),
-                   "Zm9v\r\nYmFy");
-    }
-
-    #[test]
-    fn test_to_base64_lf_line_break() {
-        assert!(![0; 1000].to_base64(Config {line_length: None,
-                                                 newline: Newline::LF,
-                                                 ..STANDARD})
-                              .contains("\n"));
-        assert_eq!(b"foobar".to_base64(Config {line_length: Some(4),
-                                               newline: Newline::LF,
-                                               ..STANDARD}),
-                   "Zm9v\nYmFy");
-    }
-
-    #[test]
-    fn test_to_base64_padding() {
-        assert_eq!("f".as_bytes().to_base64(Config {pad: false, ..STANDARD}), "Zg");
-        assert_eq!("fo".as_bytes().to_base64(Config {pad: false, ..STANDARD}), "Zm8");
-    }
-
-    #[test]
-    fn test_to_base64_url_safe() {
-        assert_eq!([251, 255].to_base64(URL_SAFE), "-_8");
-        assert_eq!([251, 255].to_base64(STANDARD), "+/8=");
-    }
-
-    #[test]
-    fn test_to_base64_empty_line_length() {
-        [].to_base64(Config {line_length: Some(72), ..STANDARD});
-    }
-
-    #[test]
-    fn test_from_base64_basic() {
-        assert_eq!("".from_base64().unwrap(), b"");
-        assert_eq!("Zg==".from_base64().unwrap(), b"f");
-        assert_eq!("Zm8=".from_base64().unwrap(), b"fo");
-        assert_eq!("Zm9v".from_base64().unwrap(), b"foo");
-        assert_eq!("Zm9vYg==".from_base64().unwrap(), b"foob");
-        assert_eq!("Zm9vYmE=".from_base64().unwrap(), b"fooba");
-        assert_eq!("Zm9vYmFy".from_base64().unwrap(), b"foobar");
-    }
-
-    #[test]
-    fn test_from_base64_bytes() {
-        assert_eq!(b"Zm9vYmFy".from_base64().unwrap(), b"foobar");
-    }
-
-    #[test]
-    fn test_from_base64_newlines() {
-        assert_eq!("Zm9v\r\nYmFy".from_base64().unwrap(),
-                   b"foobar");
-        assert_eq!("Zm9vYg==\r\n".from_base64().unwrap(),
-                   b"foob");
-        assert_eq!("Zm9v\nYmFy".from_base64().unwrap(),
-                   b"foobar");
-        assert_eq!("Zm9vYg==\n".from_base64().unwrap(),
-                   b"foob");
-    }
-
-    #[test]
-    fn test_from_base64_urlsafe() {
-        assert_eq!("-_8".from_base64().unwrap(), "+/8=".from_base64().unwrap());
-    }
-
-    #[test]
-    fn test_from_base64_invalid_char() {
-        assert!("Zm$=".from_base64().is_err());
-        assert!("Zg==$".from_base64().is_err());
-    }
-
-    #[test]
-    fn test_from_base64_invalid_padding() {
-        assert!("Z===".from_base64().is_err());
-    }
-
-    #[test]
-    fn test_base64_random() {
-        use rand::{thread_rng, Rng};
-
-        for _ in 0..1000 {
-            let times = thread_rng().gen_range(1, 100);
-            let v = thread_rng().gen_iter::<u8>().take(times)
-                                .collect::<Vec<_>>();
-            assert_eq!(v.to_base64(STANDARD)
-                        .from_base64()
-                        .unwrap(),
-                       v);
-        }
-    }
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/collection_impls.rs
+++ /dev/null
@@ -1,186 +0,0 @@
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Implementations of serialization for structures found in libcollections
-
-use std::hash::Hash;
-
-use {Decodable, Encodable, Decoder, Encoder, cap_capacity};
-use std::collections::{LinkedList, VecDeque, BTreeMap, BTreeSet, HashMap, HashSet};
-
-impl<
-    T: Encodable
-> Encodable for LinkedList<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_seq(self.len(), |s| {
-            for (i, e) in self.iter().enumerate() {
-                try!(s.emit_seq_elt(i, |s| e.encode(s)));
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<T:Decodable> Decodable for LinkedList<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<LinkedList<T>, D::Error> {
-        d.read_seq(|d, len| {
-            let mut list = LinkedList::new();
-            for i in 0..len {
-                list.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
-            }
-            Ok(list)
-        })
-    }
-}
-
-impl<T: Encodable> Encodable for VecDeque<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_seq(self.len(), |s| {
-            for (i, e) in self.iter().enumerate() {
-                try!(s.emit_seq_elt(i, |s| e.encode(s)));
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<T:Decodable> Decodable for VecDeque<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<VecDeque<T>, D::Error> {
-        d.read_seq(|d, len| {
-            let mut deque: VecDeque<T> = VecDeque::new();
-            for i in 0..len {
-                deque.push_back(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
-            }
-            Ok(deque)
-        })
-    }
-}
-
-impl<
-    K: Encodable + Ord,
-    V: Encodable
-> Encodable for BTreeMap<K, V> {
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        e.emit_map(self.len(), |e| {
-            let mut i = 0;
-            for (key, val) in self.iter() {
-                try!(e.emit_map_elt_key(i, |e| key.encode(e)));
-                try!(e.emit_map_elt_val(i, |e| val.encode(e)));
-                i += 1;
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<
-    K: Decodable + Ord,
-    V: Decodable
-> Decodable for BTreeMap<K, V> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<BTreeMap<K, V>, D::Error> {
-        d.read_map(|d, len| {
-            let mut map = BTreeMap::new();
-            for i in 0..len {
-                let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
-                let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
-                map.insert(key, val);
-            }
-            Ok(map)
-        })
-    }
-}
-
-impl<
-    T: Encodable + Ord
-> Encodable for BTreeSet<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_seq(self.len(), |s| {
-            let mut i = 0;
-            for e in self.iter() {
-                try!(s.emit_seq_elt(i, |s| e.encode(s)));
-                i += 1;
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<
-    T: Decodable + Ord
-> Decodable for BTreeSet<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<BTreeSet<T>, D::Error> {
-        d.read_seq(|d, len| {
-            let mut set = BTreeSet::new();
-            for i in 0..len {
-                set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
-            }
-            Ok(set)
-        })
-    }
-}
-
-impl<K, V> Encodable for HashMap<K, V>
-    where K: Encodable + Hash + Eq,
-          V: Encodable,
-{
-    fn encode<E: Encoder>(&self, e: &mut E) -> Result<(), E::Error> {
-        e.emit_map(self.len(), |e| {
-            let mut i = 0;
-            for (key, val) in self.iter() {
-                try!(e.emit_map_elt_key(i, |e| key.encode(e)));
-                try!(e.emit_map_elt_val(i, |e| val.encode(e)));
-                i += 1;
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<K, V> Decodable for HashMap<K, V>
-    where K: Decodable + Hash + Eq,
-          V: Decodable,
-{
-    fn decode<D: Decoder>(d: &mut D) -> Result<HashMap<K, V>, D::Error> {
-        d.read_map(|d, len| {
-            let mut map = HashMap::with_capacity(cap_capacity::<(K, V)>(len));
-            for i in 0..len {
-                let key = try!(d.read_map_elt_key(i, |d| Decodable::decode(d)));
-                let val = try!(d.read_map_elt_val(i, |d| Decodable::decode(d)));
-                map.insert(key, val);
-            }
-            Ok(map)
-        })
-    }
-}
-
-impl<T> Encodable for HashSet<T> where T: Encodable + Hash + Eq {
-    fn encode<E: Encoder>(&self, s: &mut E) -> Result<(), E::Error> {
-        s.emit_seq(self.len(), |s| {
-            let mut i = 0;
-            for e in self.iter() {
-                try!(s.emit_seq_elt(i, |s| e.encode(s)));
-                i += 1;
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<T> Decodable for HashSet<T> where T: Decodable + Hash + Eq, {
-    fn decode<D: Decoder>(d: &mut D) -> Result<HashSet<T>, D::Error> {
-        d.read_seq(|d, len| {
-            let mut set = HashSet::with_capacity(cap_capacity::<T>(len));
-            for i in 0..len {
-                set.insert(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
-            }
-            Ok(set)
-        })
-    }
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/hex.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-// Copyright 2013-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-//
-// ignore-lexer-test FIXME #15679
-
-//! Hex binary-to-text encoding
-
-pub use self::FromHexError::*;
-
-use std::fmt;
-use std::error;
-
-/// A trait for converting a value to hexadecimal encoding
-pub trait ToHex {
-    /// Converts the value of `self` to a hex value, returning the owned
-    /// string.
-    fn to_hex(&self) -> String;
-}
-
-static CHARS: &'static[u8] = b"0123456789abcdef";
-
-impl ToHex for [u8] {
-    /// Turn a vector of `u8` bytes into a hexadecimal string.
-    ///
-    /// # Example
-    ///
-    /// ```rust
-    /// extern crate rustc_serialize;
-    /// use rustc_serialize::hex::ToHex;
-    ///
-    /// fn main () {
-    ///     let str = [52,32].to_hex();
-    ///     println!("{}", str);
-    /// }
-    /// ```
-    fn to_hex(&self) -> String {
-        let mut v = Vec::with_capacity(self.len() * 2);
-        for &byte in self.iter() {
-            v.push(CHARS[(byte >> 4) as usize]);
-            v.push(CHARS[(byte & 0xf) as usize]);
-        }
-
-        unsafe {
-            String::from_utf8_unchecked(v)
-        }
-    }
-}
-
-impl<'a, T: ?Sized + ToHex> ToHex for &'a T {
-    fn to_hex(&self) -> String {
-        (**self).to_hex()
-    }
-}
-
-/// A trait for converting hexadecimal encoded values
-pub trait FromHex {
-    /// Converts the value of `self`, interpreted as hexadecimal encoded data,
-    /// into an owned vector of bytes, returning the vector.
-    fn from_hex(&self) -> Result<Vec<u8>, FromHexError>;
-}
-
-/// Errors that can occur when decoding a hex encoded string
-#[derive(Clone, Copy)]
-pub enum FromHexError {
-    /// The input contained a character not part of the hex format
-    InvalidHexCharacter(char, usize),
-    /// The input had an invalid length
-    InvalidHexLength,
-}
-
-impl fmt::Debug for FromHexError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            InvalidHexCharacter(ch, idx) =>
-                write!(f, "Invalid character '{}' at position {}", ch, idx),
-            InvalidHexLength => write!(f, "Invalid input length"),
-        }
-    }
-}
-
-impl error::Error for FromHexError {
-    fn description(&self) -> &str {
-        match *self {
-            InvalidHexCharacter(_, _) => "invalid character",
-            InvalidHexLength => "invalid length",
-        }
-    }
-}
-
-impl fmt::Display for FromHexError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self, f)
-    }
-}
-
-impl FromHex for str {
-    /// Convert any hexadecimal encoded string (literal, `@`, `&`, or `~`)
-    /// to the byte values it encodes.
-    ///
-    /// You can use the `String::from_utf8` function to turn a
-    /// `Vec<u8>` into a string with characters corresponding to those values.
-    ///
-    /// # Example
-    ///
-    /// This converts a string literal to hexadecimal and back.
-    ///
-    /// ```rust
-    /// extern crate rustc_serialize;
-    /// use rustc_serialize::hex::{FromHex, ToHex};
-    ///
-    /// fn main () {
-    ///     let hello_str = "Hello, World".as_bytes().to_hex();
-    ///     println!("{}", hello_str);
-    ///     let bytes = hello_str.from_hex().unwrap();
-    ///     println!("{:?}", bytes);
-    ///     let result_str = String::from_utf8(bytes).unwrap();
-    ///     println!("{}", result_str);
-    /// }
-    /// ```
-    fn from_hex(&self) -> Result<Vec<u8>, FromHexError> {
-        // This may be an overestimate if there is any whitespace
-        let mut b = Vec::with_capacity(self.len() / 2);
-        let mut modulus = 0;
-        let mut buf = 0;
-
-        for (idx, byte) in self.bytes().enumerate() {
-            buf <<= 4;
-
-            match byte {
-                b'A'...b'F' => buf |= byte - b'A' + 10,
-                b'a'...b'f' => buf |= byte - b'a' + 10,
-                b'0'...b'9' => buf |= byte - b'0',
-                b' '|b'\r'|b'\n'|b'\t' => {
-                    buf >>= 4;
-                    continue
-                }
-                _ => {
-                    let ch = self[idx..].chars().next().unwrap();
-                    return Err(InvalidHexCharacter(ch, idx))
-                }
-            }
-
-            modulus += 1;
-            if modulus == 2 {
-                modulus = 0;
-                b.push(buf);
-            }
-        }
-
-        match modulus {
-            0 => Ok(b.into_iter().collect()),
-            _ => Err(InvalidHexLength),
-        }
-    }
-}
-
-impl<'a, T: ?Sized + FromHex> FromHex for &'a T {
-    fn from_hex(&self) -> Result<Vec<u8>, FromHexError> {
-        (**self).from_hex()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use hex::{FromHex, ToHex};
-
-    #[test]
-    pub fn test_to_hex() {
-        assert_eq!("foobar".as_bytes().to_hex(), "666f6f626172");
-    }
-
-    #[test]
-    pub fn test_from_hex_okay() {
-        assert_eq!("666f6f626172".from_hex().unwrap(),
-                   b"foobar");
-        assert_eq!("666F6F626172".from_hex().unwrap(),
-                   b"foobar");
-    }
-
-    #[test]
-    pub fn test_from_hex_odd_len() {
-        assert!("666".from_hex().is_err());
-        assert!("66 6".from_hex().is_err());
-    }
-
-    #[test]
-    pub fn test_from_hex_invalid_char() {
-        assert!("66y6".from_hex().is_err());
-    }
-
-    #[test]
-    pub fn test_from_hex_ignores_whitespace() {
-        assert_eq!("666f 6f6\r\n26172 ".from_hex().unwrap(),
-                   b"foobar");
-    }
-
-    #[test]
-    pub fn test_to_hex_all_bytes() {
-        for i in 0..256 {
-            assert_eq!([i as u8].to_hex(), format!("{:02x}", i));
-        }
-    }
-
-    #[test]
-    pub fn test_from_hex_all_bytes() {
-        for i in 0..256 {
-            let ii: &[u8] = &[i as u8];
-            assert_eq!(format!("{:02x}", i).from_hex().unwrap(),
-                       ii);
-            assert_eq!(format!("{:02X}", i).from_hex().unwrap(),
-                       ii);
-        }
-    }
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/json.rs
+++ /dev/null
@@ -1,3999 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-// Rust JSON serialization library
-// Copyright (c) 2011 Google Inc.
-
-//! JSON parsing and serialization
-//!
-//! # What is JSON?
-//!
-//! JSON (JavaScript Object Notation) is a way to write data in Javascript.
-//! Like XML, it allows encoding structured data in a text format that can be
-//! easily read by humans. Its simple syntax and native compatibility with
-//! JavaScript have made it a widely used format.
-//!
-//! Data types that can be encoded are JavaScript types (see the `Json` enum
-//! for more details):
-//!
-//! * `I64`: equivalent to rust's `i64`
-//! * `U64`: equivalent to rust's `u64`
-//! * `F64`: equivalent to rust's `f64`
-//! * `Boolean`: equivalent to rust's `bool`
-//! * `String`: equivalent to rust's `String`
-//! * `Array`: equivalent to rust's `Vec<T>`, but also allowing objects of
-//!   different types in the
-//!   same array
-//! * `Object`: equivalent to rust's `BTreeMap<String, json::Json>`
-//! * `Null`
-//!
-//! An object is a series of string keys mapping to values, in `"key": value`
-//! format.  Arrays are enclosed in square brackets ([ ... ]) and objects in
-//! curly brackets ({ ... }).  A simple JSON document encoding a person,
-//! their age, address and phone numbers could look like
-//!
-//! ```ignore
-//! {
-//!     "FirstName": "John",
-//!     "LastName": "Doe",
-//!     "Age": 43,
-//!     "Address": {
-//!         "Street": "Downing Street 10",
-//!         "City": "London",
-//!         "Country": "Great Britain"
-//!     },
-//!     "PhoneNumbers": [
-//!         "+44 1234567",
-//!         "+44 2345678"
-//!     ]
-//! }
-//! ```
-//!
-//! # Rust Type-based Encoding and Decoding
-//!
-//! Rust provides a mechanism for low boilerplate encoding & decoding of values
-//! to and from JSON via the serialization API.  To be able to encode a piece
-//! of data, it must implement the `rustc_serialize::Encodable` trait.  To be
-//! able to decode a piece of data, it must implement the
-//! `rustc_serialize::Decodable` trait.  The Rust compiler provides an
-//! annotation to automatically generate the code for these traits:
-//! `#[derive(RustcDecodable, RustcEncodable)]`
-//!
-//! The JSON API provides an enum `json::Json` and a trait `ToJson` to encode
-//! objects.  The `ToJson` trait provides a `to_json` method to convert an
-//! object into a `json::Json` value.  A `json::Json` value can be encoded as a
-//! string or buffer using the functions described above.  You can also use the
-//! `json::Encoder` object, which implements the `Encoder` trait.
-//!
-//! When using `ToJson`, the `Encodable` trait implementation is not
-//! mandatory.
-//!
-//! # Examples of use
-//!
-//! ## Using Autoserialization
-//!
-//! Create a struct called `TestStruct` and serialize and deserialize it to and
-//! from JSON using the serialization API, using the derived serialization code.
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! use rustc_serialize::json;
-//!
-//! // Automatically generate `RustcDecodable` and `RustcEncodable` trait
-//! // implementations
-//! #[derive(RustcDecodable, RustcEncodable)]
-//! pub struct TestStruct  {
-//!     data_int: u8,
-//!     data_str: String,
-//!     data_vector: Vec<u8>,
-//! }
-//!
-//! fn main() {
-//!     let object = TestStruct {
-//!         data_int: 1,
-//!         data_str: "homura".to_string(),
-//!         data_vector: vec![2,3,4,5],
-//!     };
-//!
-//!     // Serialize using `json::encode`
-//!     let encoded = json::encode(&object).unwrap();
-//!
-//!     // Deserialize using `json::decode`
-//!     let decoded: TestStruct = json::decode(&encoded).unwrap();
-//! }
-//! ```
-//!
-//! ## Using the `ToJson` trait
-//!
-//! The examples below use the `ToJson` trait to generate the JSON string,
-//! which is required for custom mappings.
-//!
-//! ### Simple example of `ToJson` usage
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! use rustc_serialize::json::{self, ToJson, Json};
-//!
-//! // A custom data structure
-//! struct ComplexNum {
-//!     a: f64,
-//!     b: f64,
-//! }
-//!
-//! // JSON value representation
-//! impl ToJson for ComplexNum {
-//!     fn to_json(&self) -> Json {
-//!         Json::String(format!("{}+{}i", self.a, self.b))
-//!     }
-//! }
-//!
-//! // Only generate `RustcEncodable` trait implementation
-//! #[derive(RustcEncodable)]
-//! pub struct ComplexNumRecord {
-//!     uid: u8,
-//!     dsc: String,
-//!     val: Json,
-//! }
-//!
-//! fn main() {
-//!     let num = ComplexNum { a: 0.0001, b: 12.539 };
-//!     let data: String = json::encode(&ComplexNumRecord{
-//!         uid: 1,
-//!         dsc: "test".to_string(),
-//!         val: num.to_json(),
-//!     }).unwrap();
-//!     println!("data: {}", data);
-//!     // data: {"uid":1,"dsc":"test","val":"0.0001+12.539i"};
-//! }
-//! ```
-//!
-//! ### Verbose example of `ToJson` usage
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! use std::collections::BTreeMap;
-//! use rustc_serialize::json::{self, Json, ToJson};
-//!
-//! // Only generate `Decodable` trait implementation
-//! #[derive(RustcDecodable)]
-//! pub struct TestStruct {
-//!     data_int: u8,
-//!     data_str: String,
-//!     data_vector: Vec<u8>,
-//! }
-//!
-//! // Specify encoding method manually
-//! impl ToJson for TestStruct {
-//!     fn to_json(&self) -> Json {
-//!         let mut d = BTreeMap::new();
-//!         // All standard types implement `to_json()`, so use it
-//!         d.insert("data_int".to_string(), self.data_int.to_json());
-//!         d.insert("data_str".to_string(), self.data_str.to_json());
-//!         d.insert("data_vector".to_string(), self.data_vector.to_json());
-//!         Json::Object(d)
-//!     }
-//! }
-//!
-//! fn main() {
-//!     // Serialize using `ToJson`
-//!     let input_data = TestStruct {
-//!         data_int: 1,
-//!         data_str: "madoka".to_string(),
-//!         data_vector: vec![2,3,4,5],
-//!     };
-//!     let json_obj: Json = input_data.to_json();
-//!     let json_str: String = json_obj.to_string();
-//!
-//!     // Deserialize like before
-//!     let decoded: TestStruct = json::decode(&json_str).unwrap();
-//! }
-//! ```
-//!
-//! ## Parsing a `str` to `Json` and reading the result
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! use rustc_serialize::json::Json;
-//!
-//! fn main() {
-//!     let data = Json::from_str("{\"foo\": 13, \"bar\": \"baz\"}").unwrap();
-//!     println!("data: {}", data);
-//!     // data: {"bar":"baz","foo":13}
-//!     println!("object? {}", data.is_object());
-//!     // object? true
-//!
-//!     let obj = data.as_object().unwrap();
-//!     let foo = obj.get("foo").unwrap();
-//!
-//!     println!("array? {:?}", foo.as_array());
-//!     // array? None
-//!     println!("u64? {:?}", foo.as_u64());
-//!     // u64? Some(13u64)
-//!
-//!     for (key, value) in obj.iter() {
-//!         println!("{}: {}", key, match *value {
-//!             Json::U64(v) => format!("{} (u64)", v),
-//!             Json::String(ref v) => format!("{} (string)", v),
-//!             _ => format!("other")
-//!         });
-//!     }
-//!     // bar: baz (string)
-//!     // foo: 13 (u64)
-//! }
-//! ```
-//!
-//! # The status of this library
-//!
-//! While this library is the standard way of working with JSON in Rust,
-//! there is a next-generation library called Serde that's in the works (it's
-//! faster, overcomes some design limitations of rustc-serialize and has more
-//! features). You might consider using it when starting a new project or
-//! evaluating Rust JSON performance.
-
-use self::JsonEvent::*;
-use self::ErrorCode::*;
-use self::ParserError::*;
-use self::DecoderError::*;
-use self::ParserState::*;
-use self::InternalStackElement::*;
-
-use std::collections::{HashMap, BTreeMap};
-use std::error::Error as StdError;
-use std::i64;
-use std::io::prelude::*;
-use std::mem::swap;
-use std::ops::Index;
-use std::str::FromStr;
-use std::string;
-use std::{char, f64, fmt, io, str};
-
-use Encodable;
-
-/// Represents a json value
-#[derive(Clone, PartialEq, PartialOrd, Debug)]
-pub enum Json {
-    I64(i64),
-    U64(u64),
-    F64(f64),
-    String(string::String),
-    Boolean(bool),
-    Array(self::Array),
-    Object(self::Object),
-    Null,
-}
-
-pub type Array = Vec<Json>;
-pub type Object = BTreeMap<string::String, Json>;
-
-pub struct PrettyJson<'a> { inner: &'a Json }
-
-pub struct AsJson<'a, T: 'a> { inner: &'a T }
-pub struct AsPrettyJson<'a, T: 'a> { inner: &'a T, indent: Option<u32> }
-
-/// The errors that can arise while parsing a JSON stream.
-#[derive(Clone, Copy, PartialEq)]
-pub enum ErrorCode {
-    InvalidSyntax,
-    InvalidNumber,
-    EOFWhileParsingObject,
-    EOFWhileParsingArray,
-    EOFWhileParsingValue,
-    EOFWhileParsingString,
-    KeyMustBeAString,
-    ExpectedColon,
-    TrailingCharacters,
-    TrailingComma,
-    InvalidEscape,
-    InvalidUnicodeCodePoint,
-    LoneLeadingSurrogateInHexEscape,
-    UnexpectedEndOfHexEscape,
-    UnrecognizedHex,
-    NotFourDigit,
-    ControlCharacterInString,
-    NotUtf8,
-}
-
-#[derive(Debug)]
-pub enum ParserError {
-    /// msg, line, col
-    SyntaxError(ErrorCode, usize, usize),
-    IoError(io::Error),
-}
-
-impl PartialEq for ParserError {
-    fn eq(&self, other: &ParserError) -> bool {
-        match (self, other) {
-            (&SyntaxError(msg0, line0, col0), &SyntaxError(msg1, line1, col1)) =>
-                msg0 == msg1 && line0 == line1 && col0 == col1,
-            (&IoError(_), _) => false,
-            (_, &IoError(_)) => false,
-        }
-    }
-}
-
-// Builder and Parser have the same errors.
-pub type BuilderError = ParserError;
-
-#[derive(PartialEq, Debug)]
-pub enum DecoderError {
-    ParseError(ParserError),
-    ExpectedError(string::String, string::String),
-    MissingFieldError(string::String),
-    UnknownVariantError(string::String),
-    ApplicationError(string::String),
-    EOF,
-}
-
-#[derive(Copy, Debug)]
-pub enum EncoderError {
-    FmtError(fmt::Error),
-    BadHashmapKey,
-}
-
-impl PartialEq for EncoderError {
-    fn eq(&self, other: &EncoderError) -> bool {
-        match (*self, *other) {
-            (EncoderError::FmtError(_), EncoderError::FmtError(_)) => true,
-            (EncoderError::BadHashmapKey, EncoderError::BadHashmapKey) => true,
-            _ => false,
-        }
-    }
-}
-
-impl Clone for EncoderError {
-    fn clone(&self) -> Self { *self }
-}
-
-/// Returns a readable error string for a given error code.
-pub fn error_str(error: ErrorCode) -> &'static str {
-    match error {
-        InvalidSyntax => "invalid syntax",
-        InvalidNumber => "invalid number",
-        EOFWhileParsingObject => "EOF While parsing object",
-        EOFWhileParsingArray => "EOF While parsing array",
-        EOFWhileParsingValue => "EOF While parsing value",
-        EOFWhileParsingString => "EOF While parsing string",
-        KeyMustBeAString => "key must be a string",
-        ExpectedColon => "expected `:`",
-        TrailingCharacters => "trailing characters",
-        TrailingComma => "trailing comma",
-        InvalidEscape => "invalid escape",
-        UnrecognizedHex => "invalid \\u{ esc}ape (unrecognized hex)",
-        NotFourDigit => "invalid \\u{ esc}ape (not four digits)",
-        ControlCharacterInString => "unescaped control character in string",
-        NotUtf8 => "contents not utf-8",
-        InvalidUnicodeCodePoint => "invalid Unicode code point",
-        LoneLeadingSurrogateInHexEscape => "lone leading surrogate in hex escape",
-        UnexpectedEndOfHexEscape => "unexpected end of hex escape",
-    }
-}
-
-/// Shortcut function to decode a JSON `&str` into an object
-pub fn decode<T: ::Decodable>(s: &str) -> DecodeResult<T> {
-    let json = match Json::from_str(s) {
-        Ok(x) => x,
-        Err(e) => return Err(ParseError(e))
-    };
-
-    let mut decoder = Decoder::new(json);
-    ::Decodable::decode(&mut decoder)
-}
-
-/// Shortcut function to encode a `T` into a JSON `String`
-pub fn encode<T: ::Encodable>(object: &T) -> EncodeResult<string::String> {
-    let mut s = String::new();
-    {
-        let mut encoder = Encoder::new(&mut s);
-        try!(object.encode(&mut encoder));
-    }
-    Ok(s)
-}
-
-impl fmt::Debug for ErrorCode {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        error_str(*self).fmt(f)
-    }
-}
-
-impl StdError for DecoderError {
-    fn description(&self) -> &str { "decoder error" }
-    fn cause(&self) -> Option<&StdError> {
-        match *self {
-            DecoderError::ParseError(ref e) => Some(e),
-            _ => None,
-        }
-    }
-}
-
-impl fmt::Display for DecoderError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self, f)
-    }
-}
-
-impl From<ParserError> for DecoderError {
-    fn from(err: ParserError) -> DecoderError {
-        ParseError(From::from(err))
-    }
-}
-
-impl StdError for ParserError {
-    fn description(&self) -> &str { "failed to parse json" }
-}
-
-impl fmt::Display for ParserError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self, f)
-    }
-}
-
-impl From<io::Error> for ParserError {
-    fn from(err: io::Error) -> ParserError {
-        IoError(err)
-    }
-}
-
-impl StdError for EncoderError {
-    fn description(&self) -> &str { "encoder error" }
-}
-
-impl fmt::Display for EncoderError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self, f)
-    }
-}
-
-impl From<fmt::Error> for EncoderError {
-    fn from(err: fmt::Error) -> EncoderError { EncoderError::FmtError(err) }
-}
-
-pub type EncodeResult<T> = Result<T, EncoderError>;
-pub type DecodeResult<T> = Result<T, DecoderError>;
-
-fn escape_str(wr: &mut fmt::Write, v: &str) -> EncodeResult<()> {
-    try!(wr.write_str("\""));
-
-    let mut start = 0;
-
-    for (i, byte) in v.bytes().enumerate() {
-        let escaped = match byte {
-            b'"' => "\\\"",
-            b'\\' => "\\\\",
-            b'\x00' => "\\u0000",
-            b'\x01' => "\\u0001",
-            b'\x02' => "\\u0002",
-            b'\x03' => "\\u0003",
-            b'\x04' => "\\u0004",
-            b'\x05' => "\\u0005",
-            b'\x06' => "\\u0006",
-            b'\x07' => "\\u0007",
-            b'\x08' => "\\b",
-            b'\t' => "\\t",
-            b'\n' => "\\n",
-            b'\x0b' => "\\u000b",
-            b'\x0c' => "\\f",
-            b'\r' => "\\r",
-            b'\x0e' => "\\u000e",
-            b'\x0f' => "\\u000f",
-            b'\x10' => "\\u0010",
-            b'\x11' => "\\u0011",
-            b'\x12' => "\\u0012",
-            b'\x13' => "\\u0013",
-            b'\x14' => "\\u0014",
-            b'\x15' => "\\u0015",
-            b'\x16' => "\\u0016",
-            b'\x17' => "\\u0017",
-            b'\x18' => "\\u0018",
-            b'\x19' => "\\u0019",
-            b'\x1a' => "\\u001a",
-            b'\x1b' => "\\u001b",
-            b'\x1c' => "\\u001c",
-            b'\x1d' => "\\u001d",
-            b'\x1e' => "\\u001e",
-            b'\x1f' => "\\u001f",
-            b'\x7f' => "\\u007f",
-            _ => { continue; }
-        };
-
-        if start < i {
-            try!(wr.write_str(&v[start..i]));
-        }
-
-        try!(wr.write_str(escaped));
-
-        start = i + 1;
-    }
-
-    if start != v.len() {
-        try!(wr.write_str(&v[start..]));
-    }
-
-    try!(wr.write_str("\""));
-    Ok(())
-}
-
-fn escape_char(writer: &mut fmt::Write, v: char) -> EncodeResult<()> {
-    let mut buf = [0; 4];
-    let _ = write!(&mut &mut buf[..], "{}", v);
-    let buf = unsafe { str::from_utf8_unchecked(&buf[..v.len_utf8()]) };
-    escape_str(writer, buf)
-}
-
-fn spaces(wr: &mut fmt::Write, n: u32) -> EncodeResult<()> {
-    let mut n = n as usize;
-    const BUF: &'static str = "                ";
-
-    while n >= BUF.len() {
-        try!(wr.write_str(BUF));
-        n -= BUF.len();
-    }
-
-    if n > 0 {
-        try!(wr.write_str(&BUF[..n]));
-    }
-    Ok(())
-}
-
-fn fmt_number_or_null(v: f64) -> string::String {
-    use std::num::FpCategory::{Nan, Infinite};
-
-    match v.classify() {
-        Nan | Infinite => "null".to_string(),
-        _ => {
-            let s = v.to_string();
-            if s.contains(".") {s} else {s + ".0"}
-        }
-    }
-}
-
-macro_rules! emit_enquoted_if_mapkey {
-    ($enc:ident,$e:expr) => {
-        if $enc.is_emitting_map_key {
-            try!(write!($enc.writer, "\"{}\"", $e));
-            Ok(())
-        } else {
-            try!(write!($enc.writer, "{}", $e));
-            Ok(())
-        }
-    }
-}
-
-enum EncodingFormat {
-    Compact,
-    Pretty {
-        curr_indent: u32,
-        indent: u32
-    }
-}
-
-/// A structure for implementing serialization to JSON.
-pub struct Encoder<'a> {
-    writer: &'a mut (fmt::Write+'a),
-    format : EncodingFormat,
-    is_emitting_map_key: bool,
-}
-
-impl<'a> Encoder<'a> {
-    /// Creates a new encoder whose output will be written in human-readable
-    /// JSON to the specified writer
-    pub fn new_pretty(writer: &'a mut fmt::Write) -> Encoder<'a> {
-        Encoder {
-            writer: writer,
-            format: EncodingFormat::Pretty {
-                curr_indent: 0,
-                indent: 2,
-            },
-            is_emitting_map_key: false,
-        }
-    }
-
-    /// Creates a new encoder whose output will be written in compact
-    /// JSON to the specified writer
-    pub fn new(writer: &'a mut fmt::Write) -> Encoder<'a> {
-        Encoder {
-            writer: writer,
-            format: EncodingFormat::Compact,
-            is_emitting_map_key: false,
-        }
-    }
-
-    /// Set the number of spaces to indent for each level.
-    /// This is safe to set during encoding.
-    pub fn set_indent(&mut self, new_indent: u32) -> Result<(), ()> {
-        if let EncodingFormat::Pretty{ref mut curr_indent, ref mut indent} = self.format {
-            // self.indent very well could be 0 so we need to use checked division.
-            let level = curr_indent.checked_div(*indent).unwrap_or(0);
-            *indent = new_indent;
-            *curr_indent = level * *indent;
-            Ok(())
-        } else {
-            Err(())
-        }
-    }
-}
-
-impl<'a> ::Encoder for Encoder<'a> {
-    type Error = EncoderError;
-
-    fn emit_nil(&mut self) -> EncodeResult<()> {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        try!(write!(self.writer, "null"));
-        Ok(())
-    }
-
-    fn emit_usize(&mut self, v: usize) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_u64(&mut self, v: u64) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_u32(&mut self, v: u32) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_u16(&mut self, v: u16) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_u8(&mut self, v: u8) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-
-    fn emit_isize(&mut self, v: isize) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_i64(&mut self, v: i64) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_i32(&mut self, v: i32) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_i16(&mut self, v: i16) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-    fn emit_i8(&mut self, v: i8) -> EncodeResult<()> { emit_enquoted_if_mapkey!(self, v) }
-
-    fn emit_bool(&mut self, v: bool) -> EncodeResult<()> {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if v {
-            try!(write!(self.writer, "true"));
-        } else {
-            try!(write!(self.writer, "false"));
-        }
-        Ok(())
-    }
-
-    fn emit_f64(&mut self, v: f64) -> EncodeResult<()> {
-        emit_enquoted_if_mapkey!(self, fmt_number_or_null(v))
-    }
-    fn emit_f32(&mut self, v: f32) -> EncodeResult<()> {
-        self.emit_f64(v as f64)
-    }
-
-    fn emit_char(&mut self, v: char) -> EncodeResult<()> {
-        escape_char(self.writer, v)
-    }
-    fn emit_str(&mut self, v: &str) -> EncodeResult<()> {
-        escape_str(self.writer, v)
-    }
-
-    fn emit_enum<F>(&mut self, _name: &str, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        f(self)
-    }
-
-    fn emit_enum_variant<F>(&mut self,
-                            name: &str,
-                            _id: usize,
-                            cnt: usize,
-                            f: F)
-                            -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        // enums are encoded as strings or objects
-        // Bunny => "Bunny"
-        // Kangaroo(34,"William") => {"variant": "Kangaroo", "fields": [34,"William"]}
-        if cnt == 0 {
-            escape_str(self.writer, name)
-        } else {
-            if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                try!(write!(self.writer, "{{\n"));
-                *curr_indent += indent;
-                try!(spaces(self.writer, *curr_indent));
-                try!(write!(self.writer, "\"variant\": "));
-                try!(escape_str(self.writer, name));
-                try!(write!(self.writer, ",\n"));
-                try!(spaces(self.writer, *curr_indent));
-                try!(write!(self.writer, "\"fields\": [\n"));
-                *curr_indent += indent;
-            } else {
-                try!(write!(self.writer, "{{\"variant\":"));
-                try!(escape_str(self.writer, name));
-                try!(write!(self.writer, ",\"fields\":["));
-            }
-            try!(f(self));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent -= indent;
-                try!(write!(self.writer, "\n"));
-                try!(spaces(self.writer, *curr_indent));
-                *curr_indent -= indent;
-                try!(write!(self.writer, "]\n"));
-                try!(spaces(self.writer, *curr_indent));
-                try!(write!(self.writer, "}}"));
-            } else {
-                try!(write!(self.writer, "]}}"));
-            }
-            Ok(())
-        }
-    }
-
-    fn emit_enum_variant_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if idx != 0 {
-            try!(write!(self.writer, ","));
-            if let EncodingFormat::Pretty{..} = self.format {
-                try!(write!(self.writer, "\n"));
-            }
-        }
-        if let EncodingFormat::Pretty{curr_indent, ..} = self.format {
-            try!(spaces(self.writer, curr_indent));
-        }
-        f(self)
-    }
-
-    fn emit_enum_struct_variant<F>(&mut self,
-                                   name: &str,
-                                   id: usize,
-                                   cnt: usize,
-                                   f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_enum_variant(name, id, cnt, f)
-    }
-
-    fn emit_enum_struct_variant_field<F>(&mut self,
-                                         _: &str,
-                                         idx: usize,
-                                         f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_enum_variant_arg(idx, f)
-    }
-
-
-    fn emit_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if len == 0 {
-            try!(write!(self.writer, "{{}}"));
-        } else {
-            try!(write!(self.writer, "{{"));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent += indent;
-            }
-            try!(f(self));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent -= indent;
-                try!(write!(self.writer, "\n"));
-                try!(spaces(self.writer, *curr_indent));
-            }
-            try!(write!(self.writer, "}}"));
-        }
-        Ok(())
-    }
-
-    fn emit_struct_field<F>(&mut self, name: &str, idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if idx != 0 {
-            try!(write!(self.writer, ","));
-        }
-        if let EncodingFormat::Pretty{curr_indent, ..} = self.format {
-            try!(write!(self.writer, "\n"));
-            try!(spaces(self.writer, curr_indent));
-        }
-        try!(escape_str(self.writer, name));
-        if let EncodingFormat::Pretty{..} = self.format {
-            try!(write!(self.writer, ": "));
-        } else {
-            try!(write!(self.writer, ":"));
-        }
-        f(self)
-    }
-
-    fn emit_tuple<F>(&mut self, len: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_seq(len, f)
-    }
-    fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_seq_elt(idx, f)
-    }
-
-    fn emit_tuple_struct<F>(&mut self, _: &str, len: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_seq(len, f)
-    }
-    fn emit_tuple_struct_arg<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_seq_elt(idx, f)
-    }
-
-    fn emit_option<F>(&mut self, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        f(self)
-    }
-    fn emit_option_none(&mut self) -> EncodeResult<()> {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        self.emit_nil()
-    }
-    fn emit_option_some<F>(&mut self, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        f(self)
-    }
-
-    fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if len == 0 {
-            try!(write!(self.writer, "[]"));
-        } else {
-            try!(write!(self.writer, "["));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent += indent;
-            }
-            try!(f(self));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent -= indent;
-                try!(write!(self.writer, "\n"));
-                try!(spaces(self.writer, *curr_indent));
-            }
-            try!(write!(self.writer, "]"));
-        }
-        Ok(())
-    }
-
-    fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if idx != 0 {
-            try!(write!(self.writer, ","));
-        }
-        if let EncodingFormat::Pretty{ref mut curr_indent, ..} = self.format {
-            try!(write!(self.writer, "\n"));
-            try!(spaces(self.writer, *curr_indent));
-        }
-        f(self)
-    }
-
-    fn emit_map<F>(&mut self, len: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if len == 0 {
-            try!(write!(self.writer, "{{}}"));
-        } else {
-            try!(write!(self.writer, "{{"));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent += indent;
-            }
-            try!(f(self));
-            if let EncodingFormat::Pretty{ref mut curr_indent, indent} = self.format {
-                *curr_indent -= indent;
-                try!(write!(self.writer, "\n"));
-                try!(spaces(self.writer, *curr_indent));
-            }
-            try!(write!(self.writer, "}}"));
-        }
-        Ok(())
-    }
-
-    fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if idx != 0 {
-            try!(write!(self.writer, ","));
-        }
-        if let EncodingFormat::Pretty{curr_indent, ..} = self.format {
-            try!(write!(self.writer, "\n"));
-            try!(spaces(self.writer, curr_indent));
-        }
-        self.is_emitting_map_key = true;
-        try!(f(self));
-        self.is_emitting_map_key = false;
-        Ok(())
-    }
-
-    fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> EncodeResult<()> where
-        F: FnOnce(&mut Encoder<'a>) -> EncodeResult<()>,
-    {
-        if self.is_emitting_map_key { return Err(EncoderError::BadHashmapKey); }
-        if let EncodingFormat::Pretty{..} = self.format {
-            try!(write!(self.writer, ": "));
-        } else {
-            try!(write!(self.writer, ":"));
-        }
-        f(self)
-    }
-}
-
-impl Encodable for Json {
-    fn encode<S: ::Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        match *self {
-            Json::I64(v) => v.encode(e),
-            Json::U64(v) => v.encode(e),
-            Json::F64(v) => v.encode(e),
-            Json::String(ref v) => v.encode(e),
-            Json::Boolean(v) => v.encode(e),
-            Json::Array(ref v) => v.encode(e),
-            Json::Object(ref v) => v.encode(e),
-            Json::Null => e.emit_nil(),
-        }
-    }
-}
-
-/// Create an `AsJson` wrapper which can be used to print a value as JSON
-/// on-the-fly via `write!`
-pub fn as_json<T: Encodable>(t: &T) -> AsJson<T> {
-    AsJson { inner: t }
-}
-
-/// Create an `AsPrettyJson` wrapper which can be used to print a value as JSON
-/// on-the-fly via `write!`
-pub fn as_pretty_json<T: Encodable>(t: &T) -> AsPrettyJson<T> {
-    AsPrettyJson { inner: t, indent: None }
-}
-
-impl Json {
-    /// Decodes a json value from an `&mut io::Read`
-    pub fn from_reader(rdr: &mut io::Read) -> Result<Self, BuilderError> {
-        let contents = {
-            let mut c = Vec::new();
-            try!(rdr.read_to_end(&mut c));
-            c
-        };
-        let s = match str::from_utf8(&contents).ok() {
-            Some(s) => s,
-            _       => return Err(SyntaxError(NotUtf8, 0, 0))
-        };
-        let mut builder = Builder::new(s.chars());
-        builder.build()
-    }
-
-    /// Decodes a json value from a string
-    pub fn from_str(s: &str) -> Result<Self, BuilderError> {
-        let mut builder = Builder::new(s.chars());
-        builder.build()
-    }
-
-    /// Borrow this json object as a pretty object to generate a pretty
-    /// representation for it via `Display`.
-    pub fn pretty(&self) -> PrettyJson {
-        PrettyJson { inner: self }
-    }
-
-     /// If the Json value is an Object, returns the value associated with the provided key.
-    /// Otherwise, returns None.
-    pub fn find<'a>(&'a self, key: &str) -> Option<&'a Json>{
-        match self {
-            &Json::Object(ref map) => map.get(key),
-            _ => None
-        }
-    }
-
-    /// Attempts to get a nested Json Object for each key in `keys`.
-    /// If any key is found not to exist, find_path will return None.
-    /// Otherwise, it will return the Json value associated with the final key.
-    pub fn find_path<'a>(&'a self, keys: &[&str]) -> Option<&'a Json>{
-        let mut target = self;
-        for key in keys.iter() {
-            match target.find(*key) {
-                Some(t) => { target = t; },
-                None => return None
-            }
-        }
-        Some(target)
-    }
-
-    /// If the Json value is an Object, performs a depth-first search until
-    /// a value associated with the provided key is found. If no value is found
-    /// or the Json value is not an Object, returns None.
-    pub fn search<'a>(&'a self, key: &str) -> Option<&'a Json> {
-        match self {
-            &Json::Object(ref map) => {
-                match map.get(key) {
-                    Some(json_value) => Some(json_value),
-                    None => {
-                        for (_, v) in map.iter() {
-                            match v.search(key) {
-                                x if x.is_some() => return x,
-                                _ => ()
-                            }
-                        }
-                        None
-                    }
-                }
-            },
-            _ => None
-        }
-    }
-
-    /// Returns true if the Json value is an Object. Returns false otherwise.
-    pub fn is_object<'a>(&'a self) -> bool {
-        self.as_object().is_some()
-    }
-
-    /// If the Json value is an Object, returns a reference to the associated BTreeMap.
-    /// Returns None otherwise.
-    pub fn as_object<'a>(&'a self) -> Option<&'a Object> {
-        match self {
-            &Json::Object(ref map) => Some(map),
-            _ => None
-        }
-    }
-
-    /// If the Json value is an Object, returns a mutable reference to the associated BTreeMap.
-    /// Returns None otherwise.
-    pub fn as_object_mut<'a>(&'a mut self) -> Option<&'a mut Object> {
-        match self {
-            &mut Json::Object(ref mut map) => Some(map),
-            _ => None
-        }
-    }
-
-    /// If the Json value is an Object, returns the associated BTreeMap.
-    /// Returns None otherwise.
-    pub fn into_object(self) -> Option<Object> {
-        match self {
-            Json::Object(map) => Some(map),
-            _ => None
-        }
-    }
-
-    /// Returns true if the Json value is an Array. Returns false otherwise.
-    pub fn is_array<'a>(&'a self) -> bool {
-        self.as_array().is_some()
-    }
-
-    /// If the Json value is an Array, returns a reference to the associated vector.
-    /// Returns None otherwise.
-    pub fn as_array<'a>(&'a self) -> Option<&'a Array> {
-        match self {
-            &Json::Array(ref array) => Some(&*array),
-            _ => None
-        }
-    }
-
-    /// If the Json value is an Array, returns a mutable reference to the associated vector.
-    /// Returns None otherwise.
-    pub fn as_array_mut<'a>(&'a mut self) -> Option<&'a mut Array> {
-        match self {
-            &mut Json::Array(ref mut list) => Some(list),
-            _ => None
-        }
-    }
-
-    /// If the Json value is an Array, returns the associated vector.
-    /// Returns None otherwise.
-    pub fn into_array(self) -> Option<Array> {
-        match self {
-            Json::Array(array) => Some(array),
-            _ => None
-        }
-    }
-
-    /// Returns true if the Json value is a String. Returns false otherwise.
-    pub fn is_string<'a>(&'a self) -> bool {
-        self.as_string().is_some()
-    }
-
-    /// If the Json value is a String, returns the associated str.
-    /// Returns None otherwise.
-    pub fn as_string<'a>(&'a self) -> Option<&'a str> {
-        match *self {
-            Json::String(ref s) => Some(&s),
-            _ => None
-        }
-    }
-
-    /// Returns true if the Json value is a Number. Returns false otherwise.
-    pub fn is_number(&self) -> bool {
-        match *self {
-            Json::I64(_) | Json::U64(_) | Json::F64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the Json value is a i64. Returns false otherwise.
-    pub fn is_i64(&self) -> bool {
-        match *self {
-            Json::I64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the Json value is a u64. Returns false otherwise.
-    pub fn is_u64(&self) -> bool {
-        match *self {
-            Json::U64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// Returns true if the Json value is a f64. Returns false otherwise.
-    pub fn is_f64(&self) -> bool {
-        match *self {
-            Json::F64(_) => true,
-            _ => false,
-        }
-    }
-
-    /// If the Json value is a number, return or cast it to a i64.
-    /// Returns None otherwise.
-    pub fn as_i64(&self) -> Option<i64> {
-        match *self {
-            Json::I64(n) => Some(n),
-            Json::U64(n) if n >= i64::MAX as u64 => None,
-            Json::U64(n) => Some(n as i64),
-            _ => None
-        }
-    }
-
-    /// If the Json value is a number, return or cast it to a u64.
-    /// Returns None otherwise.
-    pub fn as_u64(&self) -> Option<u64> {
-        match *self {
-            Json::I64(n) if n >= 0 => Some(n as u64),
-            Json::U64(n) => Some(n),
-            _ => None
-        }
-    }
-
-    /// If the Json value is a number, return or cast it to a f64.
-    /// Returns None otherwise.
-    pub fn as_f64(&self) -> Option<f64> {
-        match *self {
-            Json::I64(n) => Some(n as f64),
-            Json::U64(n) => Some(n as f64),
-            Json::F64(n) => Some(n),
-            _ => None
-        }
-    }
-
-    /// Returns true if the Json value is a Boolean. Returns false otherwise.
-    pub fn is_boolean(&self) -> bool {
-        self.as_boolean().is_some()
-    }
-
-    /// If the Json value is a Boolean, returns the associated bool.
-    /// Returns None otherwise.
-    pub fn as_boolean(&self) -> Option<bool> {
-        match self {
-            &Json::Boolean(b) => Some(b),
-            _ => None
-        }
-    }
-
-    /// Returns true if the Json value is a Null. Returns false otherwise.
-    pub fn is_null(&self) -> bool {
-        self.as_null().is_some()
-    }
-
-    /// If the Json value is a Null, returns ().
-    /// Returns None otherwise.
-    pub fn as_null(&self) -> Option<()> {
-        match self {
-            &Json::Null => Some(()),
-            _ => None
-        }
-    }
-}
-
-impl<'a> Index<&'a str>  for Json {
-    type Output = Json;
-
-    fn index(&self, idx: &str) -> &Json {
-        self.find(idx).unwrap()
-    }
-}
-
-impl Index<usize> for Json {
-    type Output = Json;
-
-    fn index<'a>(&'a self, idx: usize) -> &'a Json {
-        match self {
-            &Json::Array(ref v) => &v[idx],
-            _ => panic!("can only index Json with usize if it is an array")
-        }
-    }
-}
-
-/// The output of the streaming parser.
-#[derive(PartialEq, Debug)]
-pub enum JsonEvent {
-    ObjectStart,
-    ObjectEnd,
-    ArrayStart,
-    ArrayEnd,
-    BooleanValue(bool),
-    I64Value(i64),
-    U64Value(u64),
-    F64Value(f64),
-    StringValue(string::String),
-    NullValue,
-    Error(ParserError),
-}
-
-#[derive(PartialEq, Debug)]
-enum ParserState {
-    // Parse a value in an array, true means first element.
-    ParseArray(bool),
-    // Parse ',' or ']' after an element in an array.
-    ParseArrayComma,
-    // Parse a key:value in an object, true means first element.
-    ParseObject(bool),
-    // Parse ',' or ']' after an element in an object.
-    ParseObjectComma,
-    // Initial state.
-    ParseStart,
-    // Expecting the stream to end.
-    ParseBeforeFinish,
-    // Parsing can't continue.
-    ParseFinished,
-}
-
-/// A Stack represents the current position of the parser in the logical
-/// structure of the JSON stream.
-/// For example foo.bar[3].x
-pub struct Stack {
-    stack: Vec<InternalStackElement>,
-    str_buffer: Vec<u8>,
-}
-
-/// StackElements compose a Stack.
-/// For example, Key("foo"), Key("bar"), Index(3) and Key("x") are the
-/// StackElements compositing the stack that represents foo.bar[3].x
-#[derive(PartialEq, Clone, Debug)]
-pub enum StackElement<'l> {
-    Index(u32),
-    Key(&'l str),
-}
-
-// Internally, Key elements are stored as indices in a buffer to avoid
-// allocating a string for every member of an object.
-#[derive(PartialEq, Clone, Debug)]
-enum InternalStackElement {
-    InternalIndex(u32),
-    InternalKey(u16, u16), // start, size
-}
-
-impl Stack {
-    pub fn new() -> Stack {
-        Stack { stack: Vec::new(), str_buffer: Vec::new() }
-    }
-
-    /// Returns The number of elements in the Stack.
-    pub fn len(&self) -> usize { self.stack.len() }
-
-    /// Returns true if the stack is empty.
-    pub fn is_empty(&self) -> bool { self.stack.is_empty() }
-
-    /// Provides access to the StackElement at a given index.
-    /// lower indices are at the bottom of the stack while higher indices are
-    /// at the top.
-    pub fn get<'l>(&'l self, idx: usize) -> StackElement<'l> {
-        match self.stack[idx] {
-            InternalIndex(i) => StackElement::Index(i),
-            InternalKey(start, size) => {
-                StackElement::Key(str::from_utf8(
-                    &self.str_buffer[start as usize .. start as usize + size as usize]).unwrap())
-            }
-        }
-    }
-
-    /// Compares this stack with an array of StackElements.
-    pub fn is_equal_to(&self, rhs: &[StackElement]) -> bool {
-        if self.stack.len() != rhs.len() { return false; }
-        for i in 0..rhs.len() {
-            if self.get(i) != rhs[i] { return false; }
-        }
-        return true;
-    }
-
-    /// Returns true if the bottom-most elements of this stack are the same as
-    /// the ones passed as parameter.
-    pub fn starts_with(&self, rhs: &[StackElement]) -> bool {
-        if self.stack.len() < rhs.len() { return false; }
-        for i in 0..rhs.len() {
-            if self.get(i) != rhs[i] { return false; }
-        }
-        return true;
-    }
-
-    /// Returns true if the top-most elements of this stack are the same as
-    /// the ones passed as parameter.
-    pub fn ends_with(&self, rhs: &[StackElement]) -> bool {
-        if self.stack.len() < rhs.len() { return false; }
-        let offset = self.stack.len() - rhs.len();
-        for i in 0..rhs.len() {
-            if self.get(i + offset) != rhs[i] { return false; }
-        }
-        return true;
-    }
-
-    /// Returns the top-most element (if any).
-    pub fn top<'l>(&'l self) -> Option<StackElement<'l>> {
-        return match self.stack.last() {
-            None => None,
-            Some(&InternalIndex(i)) => Some(StackElement::Index(i)),
-            Some(&InternalKey(start, size)) => {
-                Some(StackElement::Key(str::from_utf8(
-                    &self.str_buffer[start as usize .. (start+size) as usize]
-                ).unwrap()))
-            }
-        }
-    }
-
-    // Used by Parser to insert Key elements at the top of the stack.
-    fn push_key(&mut self, key: string::String) {
-        self.stack.push(InternalKey(self.str_buffer.len() as u16, key.len() as u16));
-        for c in key.as_bytes().iter() {
-            self.str_buffer.push(*c);
-        }
-    }
-
-    // Used by Parser to insert Index elements at the top of the stack.
-    fn push_index(&mut self, index: u32) {
-        self.stack.push(InternalIndex(index));
-    }
-
-    // Used by Parser to remove the top-most element of the stack.
-    fn pop(&mut self) {
-        assert!(!self.is_empty());
-        match *self.stack.last().unwrap() {
-            InternalKey(_, sz) => {
-                let new_size = self.str_buffer.len() - sz as usize;
-                self.str_buffer.truncate(new_size);
-            }
-            InternalIndex(_) => {}
-        }
-        self.stack.pop();
-    }
-
-    // Used by Parser to test whether the top-most element is an index.
-    fn last_is_index(&self) -> bool {
-        if self.is_empty() { return false; }
-        return match *self.stack.last().unwrap() {
-            InternalIndex(_) => true,
-            _ => false,
-        }
-    }
-
-    // Used by Parser to increment the index of the top-most element.
-    fn bump_index(&mut self) {
-        let len = self.stack.len();
-        let idx = match *self.stack.last().unwrap() {
-            InternalIndex(i) => { i + 1 }
-            _ => { panic!(); }
-        };
-        self.stack[len - 1] = InternalIndex(idx);
-    }
-}
-
-/// A streaming JSON parser implemented as an iterator of JsonEvent, consuming
-/// an iterator of char.
-pub struct Parser<T> {
-    rdr: T,
-    ch: Option<char>,
-    line: usize,
-    col: usize,
-    // We maintain a stack representing where we are in the logical structure
-    // of the JSON stream.
-    stack: Stack,
-    // A state machine is kept to make it possible to interrupt and resume parsing.
-    state: ParserState,
-}
-
-impl<T: Iterator<Item = char>> Iterator for Parser<T> {
-    type Item = JsonEvent;
-
-    fn next(&mut self) -> Option<JsonEvent> {
-        if self.state == ParseFinished {
-            return None;
-        }
-
-        if self.state == ParseBeforeFinish {
-            self.parse_whitespace();
-            // Make sure there is no trailing characters.
-            if self.eof() {
-                self.state = ParseFinished;
-                return None;
-            } else {
-                return Some(self.error_event(TrailingCharacters));
-            }
-        }
-
-        return Some(self.parse());
-    }
-}
-
-impl<T: Iterator<Item = char>> Parser<T> {
-    /// Creates the JSON parser.
-    pub fn new(rdr: T) -> Parser<T> {
-        let mut p = Parser {
-            rdr: rdr,
-            ch: Some('\x00'),
-            line: 1,
-            col: 0,
-            stack: Stack::new(),
-            state: ParseStart,
-        };
-        p.bump();
-        return p;
-    }
-
-    /// Provides access to the current position in the logical structure of the
-    /// JSON stream.
-    pub fn stack<'l>(&'l self) -> &'l Stack {
-        return &self.stack;
-    }
-
-    fn eof(&self) -> bool { self.ch.is_none() }
-    fn ch_or_null(&self) -> char { self.ch.unwrap_or('\x00') }
-    fn bump(&mut self) {
-        self.ch = self.rdr.next();
-
-        if self.ch_is('\n') {
-            self.line += 1;
-            self.col = 1;
-        } else {
-            self.col += 1;
-        }
-    }
-
-    fn next_char(&mut self) -> Option<char> {
-        self.bump();
-        self.ch
-    }
-    fn ch_is(&self, c: char) -> bool {
-        self.ch == Some(c)
-    }
-
-    fn error<E>(&self, reason: ErrorCode) -> Result<E, ParserError> {
-        Err(SyntaxError(reason, self.line, self.col))
-    }
-
-    fn parse_whitespace(&mut self) {
-        while self.ch_is(' ') ||
-              self.ch_is('\n') ||
-              self.ch_is('\t') ||
-              self.ch_is('\r') { self.bump(); }
-    }
-
-    fn parse_number(&mut self) -> JsonEvent {
-        let mut neg = false;
-
-        if self.ch_is('-') {
-            self.bump();
-            neg = true;
-        }
-
-        let res = match self.parse_u64() {
-            Ok(res) => res,
-            Err(e) => { return Error(e); }
-        };
-
-        if self.ch_is('.') || self.ch_is('e') || self.ch_is('E') {
-            let mut res = res as f64;
-
-            if self.ch_is('.') {
-                res = match self.parse_decimal(res) {
-                    Ok(res) => res,
-                    Err(e) => { return Error(e); }
-                };
-            }
-
-            if self.ch_is('e') || self.ch_is('E') {
-                res = match self.parse_exponent(res) {
-                    Ok(res) => res,
-                    Err(e) => { return Error(e); }
-                };
-            }
-
-            if neg {
-                res *= -1.0;
-            }
-
-            F64Value(res)
-        } else {
-            if neg {
-                // Make sure we don't underflow.
-                if res > (i64::MAX as u64) + 1 {
-                    Error(SyntaxError(InvalidNumber, self.line, self.col))
-                } else if res == 0 {
-                    I64Value(res as i64)
-                } else {
-                    I64Value((!res + 1) as i64)
-                }
-            } else {
-                U64Value(res)
-            }
-        }
-    }
-
-    fn parse_u64(&mut self) -> Result<u64, ParserError> {
-        let mut accum: u64 = 0;
-
-        match self.ch_or_null() {
-            '0' => {
-                self.bump();
-
-                // A leading '0' must be the only digit before the decimal point.
-                match self.ch_or_null() {
-                    '0' ... '9' => return self.error(InvalidNumber),
-                    _ => ()
-                }
-            },
-            '1' ... '9' => {
-                while !self.eof() {
-                    match self.ch_or_null() {
-                        c @ '0' ... '9' => {
-                            macro_rules! try_or_invalid {
-                                ($e: expr) => {
-                                    match $e {
-                                        Some(v) => v,
-                                        None => return self.error(InvalidNumber)
-                                    }
-                                }
-                            }
-                            accum = try_or_invalid!(accum.checked_mul(10));
-                            accum = try_or_invalid!(accum.checked_add((c as u64) - ('0' as u64)));
-
-                            self.bump();
-                        }
-                        _ => break,
-                    }
-                }
-            }
-            _ => return self.error(InvalidNumber),
-        }
-
-        Ok(accum)
-    }
-
-    fn parse_decimal(&mut self, mut res: f64) -> Result<f64, ParserError> {
-        self.bump();
-
-        // Make sure a digit follows the decimal place.
-        match self.ch_or_null() {
-            '0' ... '9' => (),
-             _ => return self.error(InvalidNumber)
-        }
-
-        let mut dec = 1.0;
-        let mut frac = 0.0;
-        while !self.eof() {
-            match self.ch_or_null() {
-                c @ '0' ... '9' => {
-                    dec /= 10.0;
-                    frac += (((c as isize) - ('0' as isize)) as f64) * dec;
-                    self.bump();
-                }
-                _ => break,
-            }
-        }
-
-        res += frac;
-
-        Ok(res)
-    }
-
-    fn parse_exponent(&mut self, mut res: f64) -> Result<f64, ParserError> {
-        self.bump();
-
-        let mut exp = 0;
-        let mut neg_exp = false;
-
-        if self.ch_is('+') {
-            self.bump();
-        } else if self.ch_is('-') {
-            self.bump();
-            neg_exp = true;
-        }
-
-        // Make sure a digit follows the exponent place.
-        match self.ch_or_null() {
-            '0' ... '9' => (),
-            _ => return self.error(InvalidNumber)
-        }
-        while !self.eof() {
-            match self.ch_or_null() {
-                c @ '0' ... '9' => {
-                    exp *= 10;
-                    exp += (c as usize) - ('0' as usize);
-
-                    self.bump();
-                }
-                _ => break
-            }
-        }
-
-        let exp = 10_f64.powi(exp as i32);
-        if neg_exp {
-            res /= exp;
-        } else {
-            res *= exp;
-        }
-
-        Ok(res)
-    }
-
-    fn decode_hex_escape(&mut self) -> Result<u16, ParserError> {
-        let mut i = 0;
-        let mut n = 0;
-        while i < 4 {
-            self.bump();
-            n = match self.ch_or_null() {
-                c @ '0' ... '9' => n * 16 + ((c as u16) - ('0' as u16)),
-                c @ 'a' ... 'f' => n * 16 + (10 + (c as u16) - ('a' as u16)),
-                c @ 'A' ... 'F' => n * 16 + (10 + (c as u16) - ('A' as u16)),
-                _ => return self.error(InvalidEscape)
-            };
-
-            i += 1;
-        }
-
-        Ok(n)
-    }
-
-    fn parse_str(&mut self) -> Result<string::String, ParserError> {
-        let mut escape = false;
-        let mut res = string::String::new();
-
-        loop {
-            self.bump();
-            if self.eof() {
-                return self.error(EOFWhileParsingString);
-            }
-
-            if escape {
-                match self.ch_or_null() {
-                    '"' => res.push('"'),
-                    '\\' => res.push('\\'),
-                    '/' => res.push('/'),
-                    'b' => res.push('\x08'),
-                    'f' => res.push('\x0c'),
-                    'n' => res.push('\n'),
-                    'r' => res.push('\r'),
-                    't' => res.push('\t'),
-                    'u' => match try!(self.decode_hex_escape()) {
-                        0xDC00 ... 0xDFFF => {
-                            return self.error(LoneLeadingSurrogateInHexEscape)
-                        }
-
-                        // Non-BMP characters are encoded as a sequence of
-                        // two hex escapes, representing UTF-16 surrogates.
-                        n1 @ 0xD800 ... 0xDBFF => {
-                            match (self.next_char(), self.next_char()) {
-                                (Some('\\'), Some('u')) => (),
-                                _ => return self.error(UnexpectedEndOfHexEscape),
-                            }
-
-                            let n2 = try!(self.decode_hex_escape());
-                            if n2 < 0xDC00 || n2 > 0xDFFF {
-                                return self.error(LoneLeadingSurrogateInHexEscape)
-                            }
-                            let c = (((n1 - 0xD800) as u32) << 10 |
-                                     (n2 - 0xDC00) as u32) + 0x1_0000;
-                            res.push(char::from_u32(c).unwrap());
-                        }
-
-                        n => match char::from_u32(n as u32) {
-                            Some(c) => res.push(c),
-                            None => return self.error(InvalidUnicodeCodePoint),
-                        },
-                    },
-                    _ => return self.error(InvalidEscape),
-                }
-                escape = false;
-            } else if self.ch_is('\\') {
-                escape = true;
-            } else {
-                match self.ch {
-                    Some('"') => {
-                        self.bump();
-                        return Ok(res);
-                    },
-                    Some(c) if c <= '\u{1F}' =>
-                        return self.error(ControlCharacterInString),
-                    Some(c) => res.push(c),
-                    None => unreachable!()
-                }
-            }
-        }
-    }
-
-    // Invoked at each iteration, consumes the stream until it has enough
-    // information to return a JsonEvent.
-    // Manages an internal state so that parsing can be interrupted and resumed.
-    // Also keeps track of the position in the logical structure of the json
-    // stream int the form of a stack that can be queried by the user using the
-    // stack() method.
-    fn parse(&mut self) -> JsonEvent {
-        loop {
-            // The only paths where the loop can spin a new iteration
-            // are in the cases ParseArrayComma and ParseObjectComma if ','
-            // is parsed. In these cases the state is set to (respectively)
-            // ParseArray(false) and ParseObject(false), which always return,
-            // so there is no risk of getting stuck in an infinite loop.
-            // All other paths return before the end of the loop's iteration.
-            self.parse_whitespace();
-
-            match self.state {
-                ParseStart => {
-                    return self.parse_start();
-                }
-                ParseArray(first) => {
-                    return self.parse_array(first);
-                }
-                ParseArrayComma => {
-                    match self.parse_array_comma_or_end() {
-                        Some(evt) => { return evt; }
-                        None => {}
-                    }
-                }
-                ParseObject(first) => {
-                    return self.parse_object(first);
-                }
-                ParseObjectComma => {
-                    self.stack.pop();
-                    if self.ch_is(',') {
-                        self.state = ParseObject(false);
-                        self.bump();
-                    } else {
-                        return self.parse_object_end();
-                    }
-                }
-                _ => {
-                    return self.error_event(InvalidSyntax);
-                }
-            }
-        }
-    }
-
-    fn parse_start(&mut self) -> JsonEvent {
-        let val = self.parse_value();
-        self.state = match val {
-            Error(_) => ParseFinished,
-            ArrayStart => ParseArray(true),
-            ObjectStart => ParseObject(true),
-            _ => ParseBeforeFinish,
-        };
-        return val;
-    }
-
-    fn parse_array(&mut self, first: bool) -> JsonEvent {
-        if self.ch_is(']') {
-            if !first {
-                self.error_event(InvalidSyntax)
-            } else {
-                self.state = if self.stack.is_empty() {
-                    ParseBeforeFinish
-                } else if self.stack.last_is_index() {
-                    ParseArrayComma
-                } else {
-                    ParseObjectComma
-                };
-                self.bump();
-                ArrayEnd
-            }
-        } else {
-            if first {
-                self.stack.push_index(0);
-            }
-            let val = self.parse_value();
-            self.state = match val {
-                Error(_) => ParseFinished,
-                ArrayStart => ParseArray(true),
-                ObjectStart => ParseObject(true),
-                _ => ParseArrayComma,
-            };
-            val
-        }
-    }
-
-    fn parse_array_comma_or_end(&mut self) -> Option<JsonEvent> {
-        if self.ch_is(',') {
-            self.stack.bump_index();
-            self.state = ParseArray(false);
-            self.bump();
-            None
-        } else if self.ch_is(']') {
-            self.stack.pop();
-            self.state = if self.stack.is_empty() {
-                ParseBeforeFinish
-            } else if self.stack.last_is_index() {
-                ParseArrayComma
-            } else {
-                ParseObjectComma
-            };
-            self.bump();
-            Some(ArrayEnd)
-        } else if self.eof() {
-            Some(self.error_event(EOFWhileParsingArray))
-        } else {
-            Some(self.error_event(InvalidSyntax))
-        }
-    }
-
-    fn parse_object(&mut self, first: bool) -> JsonEvent {
-        if self.ch_is('}') {
-            if !first {
-                if self.stack.is_empty() {
-                    return self.error_event(TrailingComma);
-                } else {
-                    self.stack.pop();
-                }
-            }
-            self.state = if self.stack.is_empty() {
-                ParseBeforeFinish
-            } else if self.stack.last_is_index() {
-                ParseArrayComma
-            } else {
-                ParseObjectComma
-            };
-            self.bump();
-            return ObjectEnd;
-        }
-        if self.eof() {
-            return self.error_event(EOFWhileParsingObject);
-        }
-        if !self.ch_is('"') {
-            return self.error_event(KeyMustBeAString);
-        }
-        let s = match self.parse_str() {
-            Ok(s) => s,
-            Err(e) => {
-                self.state = ParseFinished;
-                return Error(e);
-            }
-        };
-        self.parse_whitespace();
-        if self.eof() {
-            return self.error_event(EOFWhileParsingObject);
-        } else if self.ch_or_null() != ':' {
-            return self.error_event(ExpectedColon);
-        }
-        self.stack.push_key(s);
-        self.bump();
-        self.parse_whitespace();
-
-        let val = self.parse_value();
-
-        self.state = match val {
-            Error(_) => ParseFinished,
-            ArrayStart => ParseArray(true),
-            ObjectStart => ParseObject(true),
-            _ => ParseObjectComma,
-        };
-        return val;
-    }
-
-    fn parse_object_end(&mut self) -> JsonEvent {
-        if self.ch_is('}') {
-            self.state = if self.stack.is_empty() {
-                ParseBeforeFinish
-            } else if self.stack.last_is_index() {
-                ParseArrayComma
-            } else {
-                ParseObjectComma
-            };
-            self.bump();
-            ObjectEnd
-        } else if self.eof() {
-            self.error_event(EOFWhileParsingObject)
-        } else {
-            self.error_event(InvalidSyntax)
-        }
-    }
-
-    fn parse_value(&mut self) -> JsonEvent {
-        if self.eof() { return self.error_event(EOFWhileParsingValue); }
-        match self.ch_or_null() {
-            'n' => { self.parse_ident("ull", NullValue) }
-            't' => { self.parse_ident("rue", BooleanValue(true)) }
-            'f' => { self.parse_ident("alse", BooleanValue(false)) }
-            '0' ... '9' | '-' => self.parse_number(),
-            '"' => match self.parse_str() {
-                Ok(s) => StringValue(s),
-                Err(e) => Error(e),
-            },
-            '[' => {
-                self.bump();
-                ArrayStart
-            }
-            '{' => {
-                self.bump();
-                ObjectStart
-            }
-            _ => { self.error_event(InvalidSyntax) }
-        }
-    }
-
-    fn parse_ident(&mut self, ident: &str, value: JsonEvent) -> JsonEvent {
-        if ident.chars().all(|c| Some(c) == self.next_char()) {
-            self.bump();
-            value
-        } else {
-            Error(SyntaxError(InvalidSyntax, self.line, self.col))
-        }
-    }
-
-    fn error_event(&mut self, reason: ErrorCode) -> JsonEvent {
-        self.state = ParseFinished;
-        Error(SyntaxError(reason, self.line, self.col))
-    }
-}
-
-/// A Builder consumes a json::Parser to create a generic Json structure.
-pub struct Builder<T> {
-    parser: Parser<T>,
-    token: Option<JsonEvent>,
-}
-
-impl<T: Iterator<Item = char>> Builder<T> {
-    /// Create a JSON Builder.
-    pub fn new(src: T) -> Builder<T> {
-        Builder { parser: Parser::new(src), token: None, }
-    }
-
-    // Decode a Json value from a Parser.
-    pub fn build(&mut self) -> Result<Json, BuilderError> {
-        self.bump();
-        let result = self.build_value();
-        self.bump();
-        match self.token.take() {
-            None => {}
-            Some(Error(e)) => { return Err(e); }
-            _ => { return Err(SyntaxError(InvalidSyntax, self.parser.line, self.parser.col)); }
-        }
-        result
-    }
-
-    fn bump(&mut self) {
-        self.token = self.parser.next();
-    }
-
-    fn build_value(&mut self) -> Result<Json, BuilderError> {
-        return match self.token.take() {
-            Some(NullValue) => Ok(Json::Null),
-            Some(I64Value(n)) => Ok(Json::I64(n)),
-            Some(U64Value(n)) => Ok(Json::U64(n)),
-            Some(F64Value(n)) => Ok(Json::F64(n)),
-            Some(BooleanValue(b)) => Ok(Json::Boolean(b)),
-            Some(StringValue(ref mut s)) => {
-                let mut temp = string::String::new();
-                swap(s, &mut temp);
-                Ok(Json::String(temp))
-            }
-            Some(Error(e)) => Err(e),
-            Some(ArrayStart) => self.build_array(),
-            Some(ObjectStart) => self.build_object(),
-            Some(ObjectEnd) => self.parser.error(InvalidSyntax),
-            Some(ArrayEnd) => self.parser.error(InvalidSyntax),
-            None => self.parser.error(EOFWhileParsingValue),
-        }
-    }
-
-    fn build_array(&mut self) -> Result<Json, BuilderError> {
-        self.bump();
-        let mut values = Vec::new();
-
-        loop {
-            if let Some(ArrayEnd) = self.token {
-                return Ok(Json::Array(values.into_iter().collect()));
-            }
-            match self.build_value() {
-                Ok(v) => values.push(v),
-                Err(e) => { return Err(e) }
-            }
-            self.bump();
-        }
-    }
-
-    fn build_object(&mut self) -> Result<Json, BuilderError> {
-        self.bump();
-
-        let mut values = BTreeMap::new();
-
-        loop {
-            match self.token.take() {
-                Some(ObjectEnd) => { return Ok(Json::Object(values)); }
-                Some(Error(e)) => { return Err(e); }
-                None => { break; }
-                token => { self.token = token; }
-            }
-            let key = match self.parser.stack().top() {
-                Some(StackElement::Key(k)) => { k.to_string() }
-                _ => { panic!("invalid state"); }
-            };
-            match self.build_value() {
-                Ok(value) => { values.insert(key, value); }
-                Err(e) => { return Err(e); }
-            }
-            self.bump();
-        }
-        return self.parser.error(EOFWhileParsingObject);
-    }
-}
-
-/// A structure to decode JSON to values in rust.
-pub struct Decoder {
-    stack: Vec<Json>,
-}
-
-impl Decoder {
-    /// Creates a new decoder instance for decoding the specified JSON value.
-    pub fn new(json: Json) -> Decoder {
-        Decoder { stack: vec![json] }
-    }
-}
-
-impl Decoder {
-    fn pop(&mut self) -> DecodeResult<Json> {
-        match self.stack.pop() {
-            Some(s) => Ok(s),
-            None => Err(EOF),
-        }
-    }
-}
-
-macro_rules! expect {
-    ($e:expr, Null) => ({
-        match try!($e) {
-            Json::Null => Ok(()),
-            other => Err(ExpectedError("Null".to_string(),
-                                       format!("{}", other)))
-        }
-    });
-    ($e:expr, $t:ident) => ({
-        match try!($e) {
-            Json::$t(v) => Ok(v),
-            other => {
-                Err(ExpectedError(stringify!($t).to_string(),
-                                  format!("{}", other)))
-            }
-        }
-    })
-}
-
-macro_rules! read_primitive {
-    ($name:ident, $ty:ident) => {
-        #[allow(unused_comparisons)]
-        fn $name(&mut self) -> DecodeResult<$ty> {
-            match try!(self.pop()) {
-                Json::I64(i) => {
-                    let other = i as $ty;
-                    if i == other as i64 && (other > 0) == (i > 0) {
-                        Ok(other)
-                    } else {
-                        Err(ExpectedError("Number".to_string(), i.to_string()))
-                    }
-                }
-                Json::U64(u) => {
-                    let other = u as $ty;
-                    if u == other as u64 && other >= 0 {
-                        Ok(other)
-                    } else {
-                        Err(ExpectedError("Number".to_string(), u.to_string()))
-                    }
-                }
-                Json::F64(f) => {
-                    Err(ExpectedError("Integer".to_string(), f.to_string()))
-                }
-                // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
-                // is going to have a string here, as per JSON spec.
-                Json::String(s) => match s.parse() {
-                    Ok(f)  => Ok(f),
-                    Err(_) => Err(ExpectedError("Number".to_string(), s)),
-                },
-                value => {
-                    Err(ExpectedError("Number".to_string(), value.to_string()))
-                }
-            }
-        }
-    }
-}
-
-impl ::Decoder for Decoder {
-    type Error = DecoderError;
-
-    fn read_nil(&mut self) -> DecodeResult<()> {
-        expect!(self.pop(), Null)
-    }
-
-    read_primitive! { read_usize, usize }
-    read_primitive! { read_u8, u8 }
-    read_primitive! { read_u16, u16 }
-    read_primitive! { read_u32, u32 }
-    read_primitive! { read_u64, u64 }
-    read_primitive! { read_isize, isize }
-    read_primitive! { read_i8, i8 }
-    read_primitive! { read_i16, i16 }
-    read_primitive! { read_i32, i32 }
-    read_primitive! { read_i64, i64 }
-
-    fn read_f32(&mut self) -> DecodeResult<f32> {
-        self.read_f64().map(|x| x as f32)
-    }
-
-    fn read_f64(&mut self) -> DecodeResult<f64> {
-        match try!(self.pop()) {
-            Json::I64(f) => Ok(f as f64),
-            Json::U64(f) => Ok(f as f64),
-            Json::F64(f) => Ok(f),
-            Json::String(s) => {
-                // re: #12967.. a type w/ numeric keys (ie HashMap<usize, V> etc)
-                // is going to have a string here, as per JSON spec.
-                match s.parse() {
-                    Ok(f)  => Ok(f),
-                    Err(_) => Err(ExpectedError("Number".to_string(), s)),
-                }
-            },
-            Json::Null => Ok(f64::NAN),
-            value => Err(ExpectedError("Number".to_string(), format!("{}", value)))
-        }
-    }
-
-    fn read_bool(&mut self) -> DecodeResult<bool> {
-        expect!(self.pop(), Boolean)
-    }
-
-    fn read_char(&mut self) -> DecodeResult<char> {
-        let s = try!(self.read_str());
-        {
-            let mut it = s.chars();
-            match (it.next(), it.next()) {
-                // exactly one character
-                (Some(c), None) => return Ok(c),
-                _ => ()
-            }
-        }
-        Err(ExpectedError("single character string".to_string(), format!("{}", s)))
-    }
-
-    fn read_str(&mut self) -> DecodeResult<string::String> {
-        expect!(self.pop(), String)
-    }
-
-    fn read_enum<T, F>(&mut self, _name: &str, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        f(self)
-    }
-
-    fn read_enum_variant<T, F>(&mut self, names: &[&str],
-                               mut f: F) -> DecodeResult<T>
-        where F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
-    {
-        let name = match try!(self.pop()) {
-            Json::String(s) => s,
-            Json::Object(mut o) => {
-                let n = match o.remove(&"variant".to_string()) {
-                    Some(Json::String(s)) => s,
-                    Some(val) => {
-                        return Err(ExpectedError("String".to_string(), format!("{}", val)))
-                    }
-                    None => {
-                        return Err(MissingFieldError("variant".to_string()))
-                    }
-                };
-                match o.remove(&"fields".to_string()) {
-                    Some(Json::Array(l)) => {
-                        for field in l.into_iter().rev() {
-                            self.stack.push(field);
-                        }
-                    },
-                    Some(val) => {
-                        return Err(ExpectedError("Array".to_string(), format!("{}", val)))
-                    }
-                    None => {
-                        return Err(MissingFieldError("fields".to_string()))
-                    }
-                }
-                n
-            }
-            json => {
-                return Err(ExpectedError("String or Object".to_string(), format!("{}", json)))
-            }
-        };
-        let idx = match names.iter().position(|n| *n == name) {
-            Some(idx) => idx,
-            None => return Err(UnknownVariantError(name))
-        };
-        f(self, idx)
-    }
-
-    fn read_enum_variant_arg<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        f(self)
-    }
-
-    fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> DecodeResult<T> where
-        F: FnMut(&mut Decoder, usize) -> DecodeResult<T>,
-    {
-        self.read_enum_variant(names, f)
-    }
-
-
-    fn read_enum_struct_variant_field<T, F>(&mut self,
-                                         _name: &str,
-                                         idx: usize,
-                                         f: F)
-                                         -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        self.read_enum_variant_arg(idx, f)
-    }
-
-    fn read_struct<T, F>(&mut self, _name: &str, _len: usize, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        let value = try!(f(self));
-        try!(self.pop());
-        Ok(value)
-    }
-
-    fn read_struct_field<T, F>(&mut self,
-                               name: &str,
-                               _idx: usize,
-                               f: F)
-                               -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        let mut obj = try!(expect!(self.pop(), Object));
-
-        let value = match obj.remove(&name.to_string()) {
-            None => {
-                // Add a Null and try to parse it as an Option<_>
-                // to get None as a default value.
-                self.stack.push(Json::Null);
-                match f(self) {
-                    Ok(x) => x,
-                    Err(_) => return Err(MissingFieldError(name.to_string())),
-                }
-            },
-            Some(json) => {
-                self.stack.push(json);
-                try!(f(self))
-            }
-        };
-        self.stack.push(Json::Object(obj));
-        Ok(value)
-    }
-
-    fn read_tuple<T, F>(&mut self, tuple_len: usize, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        self.read_seq(move |d, len| {
-            if len == tuple_len {
-                f(d)
-            } else {
-                Err(ExpectedError(format!("Tuple{}", tuple_len), format!("Tuple{}", len)))
-            }
-        })
-    }
-
-    fn read_tuple_arg<T, F>(&mut self, idx: usize, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        self.read_seq_elt(idx, f)
-    }
-
-    fn read_tuple_struct<T, F>(&mut self,
-                               _name: &str,
-                               len: usize,
-                               f: F)
-                               -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        self.read_tuple(len, f)
-    }
-
-    fn read_tuple_struct_arg<T, F>(&mut self,
-                                   idx: usize,
-                                   f: F)
-                                   -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        self.read_tuple_arg(idx, f)
-    }
-
-    fn read_option<T, F>(&mut self, mut f: F) -> DecodeResult<T> where
-        F: FnMut(&mut Decoder, bool) -> DecodeResult<T>,
-    {
-        match try!(self.pop()) {
-            Json::Null => f(self, false),
-            value => { self.stack.push(value); f(self, true) }
-        }
-    }
-
-    fn read_seq<T, F>(&mut self, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
-    {
-        let array = try!(expect!(self.pop(), Array));
-        let len = array.len();
-        for v in array.into_iter().rev() {
-            self.stack.push(v);
-        }
-        f(self, len)
-    }
-
-    fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        f(self)
-    }
-
-    fn read_map<T, F>(&mut self, f: F) -> DecodeResult<T> where
-        F: FnOnce(&mut Decoder, usize) -> DecodeResult<T>,
-    {
-        let obj = try!(expect!(self.pop(), Object));
-        let len = obj.len();
-        for (key, value) in obj.into_iter() {
-            self.stack.push(value);
-            self.stack.push(Json::String(key));
-        }
-        f(self, len)
-    }
-
-    fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
-       F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        f(self)
-    }
-
-    fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> DecodeResult<T> where
-       F: FnOnce(&mut Decoder) -> DecodeResult<T>,
-    {
-        f(self)
-    }
-
-    fn error(&mut self, err: &str) -> DecoderError {
-        ApplicationError(err.to_string())
-    }
-}
-
-/// A trait for converting values to JSON
-pub trait ToJson {
-    /// Converts the value of `self` to an instance of JSON
-    fn to_json(&self) -> Json;
-}
-
-macro_rules! to_json_impl_i64 {
-    ($($t:ty), +) => (
-        $(impl ToJson for $t {
-            fn to_json(&self) -> Json { Json::I64(*self as i64) }
-        })+
-    )
-}
-
-to_json_impl_i64! { isize, i8, i16, i32, i64 }
-
-macro_rules! to_json_impl_u64 {
-    ($($t:ty), +) => (
-        $(impl ToJson for $t {
-            fn to_json(&self) -> Json { Json::U64(*self as u64) }
-        })+
-    )
-}
-
-to_json_impl_u64! { usize, u8, u16, u32, u64 }
-
-impl ToJson for Json {
-    fn to_json(&self) -> Json { self.clone() }
-}
-
-impl ToJson for f32 {
-    fn to_json(&self) -> Json { (*self as f64).to_json() }
-}
-
-impl ToJson for f64 {
-    fn to_json(&self) -> Json {
-        use std::num::FpCategory::{Nan, Infinite};
-
-        match self.classify() {
-            Nan | Infinite => Json::Null,
-            _                  => Json::F64(*self)
-        }
-    }
-}
-
-impl ToJson for () {
-    fn to_json(&self) -> Json { Json::Null }
-}
-
-impl ToJson for bool {
-    fn to_json(&self) -> Json { Json::Boolean(*self) }
-}
-
-impl ToJson for str {
-    fn to_json(&self) -> Json { Json::String(self.to_string()) }
-}
-
-impl ToJson for string::String {
-    fn to_json(&self) -> Json { Json::String((*self).clone()) }
-}
-
-macro_rules! tuple_impl {
-    // use variables to indicate the arity of the tuple
-    ($($tyvar:ident),* ) => {
-        // the trailing commas are for the 1 tuple
-        impl<
-            $( $tyvar : ToJson ),*
-            > ToJson for ( $( $tyvar ),* , ) {
-
-            #[inline]
-            #[allow(non_snake_case)]
-            fn to_json(&self) -> Json {
-                match *self {
-                    ($(ref $tyvar),*,) => Json::Array(vec![$($tyvar.to_json()),*])
-                }
-            }
-        }
-    }
-}
-
-tuple_impl!{A}
-tuple_impl!{A, B}
-tuple_impl!{A, B, C}
-tuple_impl!{A, B, C, D}
-tuple_impl!{A, B, C, D, E}
-tuple_impl!{A, B, C, D, E, F}
-tuple_impl!{A, B, C, D, E, F, G}
-tuple_impl!{A, B, C, D, E, F, G, H}
-tuple_impl!{A, B, C, D, E, F, G, H, I}
-tuple_impl!{A, B, C, D, E, F, G, H, I, J}
-tuple_impl!{A, B, C, D, E, F, G, H, I, J, K}
-tuple_impl!{A, B, C, D, E, F, G, H, I, J, K, L}
-
-impl<A: ToJson> ToJson for [A] {
-    fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
-}
-
-impl<A: ToJson> ToJson for Vec<A> {
-    fn to_json(&self) -> Json { Json::Array(self.iter().map(|elt| elt.to_json()).collect()) }
-}
-
-impl<A: ToJson> ToJson for BTreeMap<string::String, A> {
-    fn to_json(&self) -> Json {
-        let mut d = BTreeMap::new();
-        for (key, value) in self.iter() {
-            d.insert((*key).clone(), value.to_json());
-        }
-        Json::Object(d)
-    }
-}
-
-impl<A: ToJson> ToJson for HashMap<string::String, A> {
-    fn to_json(&self) -> Json {
-        let mut d = BTreeMap::new();
-        for (key, value) in self.iter() {
-            d.insert((*key).clone(), value.to_json());
-        }
-        Json::Object(d)
-    }
-}
-
-impl<A:ToJson> ToJson for Option<A> {
-    fn to_json(&self) -> Json {
-        match *self {
-            None => Json::Null,
-            Some(ref value) => value.to_json()
-        }
-    }
-}
-
-struct FormatShim<'a, 'b: 'a> {
-    inner: &'a mut fmt::Formatter<'b>,
-}
-
-impl<'a, 'b> fmt::Write for FormatShim<'a, 'b> {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        match self.inner.write_str(s) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(fmt::Error)
-        }
-    }
-}
-
-impl fmt::Display for Json {
-    /// Encodes a json value into a string
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut shim = FormatShim { inner: f };
-        let mut encoder = Encoder::new(&mut shim);
-        match self.encode(&mut encoder) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(fmt::Error)
-        }
-    }
-}
-
-impl<'a> fmt::Display for PrettyJson<'a> {
-    /// Encodes a json value into a string
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut shim = FormatShim { inner: f };
-        let mut encoder = Encoder::new_pretty(&mut shim);
-        match self.inner.encode(&mut encoder) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(fmt::Error)
-        }
-    }
-}
-
-impl<'a, T: Encodable> fmt::Display for AsJson<'a, T> {
-    /// Encodes a json value into a string
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut shim = FormatShim { inner: f };
-        let mut encoder = Encoder::new(&mut shim);
-        match self.inner.encode(&mut encoder) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(fmt::Error)
-        }
-    }
-}
-
-impl<'a, T> AsPrettyJson<'a, T> {
-    /// Set the indentation level for the emitted JSON
-    pub fn indent(mut self, indent: u32) -> AsPrettyJson<'a, T> {
-        self.indent = Some(indent);
-        self
-    }
-}
-
-impl<'a, T: Encodable> fmt::Display for AsPrettyJson<'a, T> {
-    /// Encodes a json value into a string
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let mut shim = FormatShim { inner: f };
-        let mut encoder = Encoder::new_pretty(&mut shim);
-        if let Some(n) = self.indent {
-            // unwrap cannot panic for pretty encoders
-            let _ = encoder.set_indent(n);
-        }
-        match self.inner.encode(&mut encoder) {
-            Ok(_) => Ok(()),
-            Err(_) => Err(fmt::Error)
-        }
-    }
-}
-
-impl FromStr for Json {
-    type Err = ParserError;
-    fn from_str(s: &str) -> Result<Json, ParserError> {
-        Json::from_str(s)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use self::Animal::*;
-    use {Encodable, Decodable};
-    use super::Json::*;
-    use super::ErrorCode::*;
-    use super::ParserError::*;
-    use super::DecoderError::*;
-    use super::JsonEvent::*;
-    use super::StackElement::*;
-    use super::{Json, DecodeResult, DecoderError, JsonEvent, Parser,
-                StackElement, Stack, Decoder, Encoder, EncoderError};
-    use std::{i64, u64, f32, f64};
-    use std::collections::BTreeMap;
-    use std::string;
-
-    #[derive(RustcDecodable, Eq, PartialEq, Debug)]
-    struct OptionData {
-        opt: Option<usize>,
-    }
-
-    #[test]
-    fn test_decode_option_none() {
-        let s ="{}";
-        let obj: OptionData = super::decode(s).unwrap();
-        assert_eq!(obj, OptionData { opt: None });
-    }
-
-    #[test]
-    fn test_decode_option_some() {
-        let s = "{ \"opt\": 10 }";
-        let obj: OptionData = super::decode(s).unwrap();
-        assert_eq!(obj, OptionData { opt: Some(10) });
-    }
-
-    #[test]
-    fn test_decode_option_malformed() {
-        check_err::<OptionData>("{ \"opt\": [] }",
-                                ExpectedError("Number".to_string(), "[]".to_string()));
-        check_err::<OptionData>("{ \"opt\": false }",
-                                ExpectedError("Number".to_string(), "false".to_string()));
-    }
-
-    #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
-    enum Animal {
-        Dog,
-        Frog(string::String, isize)
-    }
-
-    #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
-    struct Inner {
-        a: (),
-        b: usize,
-        c: Vec<string::String>,
-    }
-
-    #[derive(PartialEq, RustcEncodable, RustcDecodable, Debug)]
-    struct Outer {
-        inner: Vec<Inner>,
-    }
-
-    fn mk_object(items: &[(string::String, Json)]) -> Json {
-        let mut d = BTreeMap::new();
-
-        for item in items.iter() {
-            match *item {
-                (ref key, ref value) => { d.insert((*key).clone(), (*value).clone()); },
-            }
-        };
-
-        Object(d)
-    }
-
-    #[test]
-    fn test_from_str_trait() {
-        let s = "null";
-        assert!(s.parse::<Json>().unwrap() == s.parse().unwrap());
-    }
-
-    #[test]
-    fn test_write_null() {
-        assert_eq!(Null.to_string(), "null");
-        assert_eq!(Null.pretty().to_string(), "null");
-    }
-
-    #[test]
-    fn test_write_i64() {
-        assert_eq!(U64(0).to_string(), "0");
-        assert_eq!(U64(0).pretty().to_string(), "0");
-
-        assert_eq!(U64(1234).to_string(), "1234");
-        assert_eq!(U64(1234).pretty().to_string(), "1234");
-
-        assert_eq!(I64(-5678).to_string(), "-5678");
-        assert_eq!(I64(-5678).pretty().to_string(), "-5678");
-
-        assert_eq!(U64(7650007200025252000).to_string(), "7650007200025252000");
-        assert_eq!(U64(7650007200025252000).pretty().to_string(), "7650007200025252000");
-    }
-
-    #[test]
-    fn test_write_f64() {
-        assert_eq!(F64(3.0).to_string(), "3.0");
-        assert_eq!(F64(3.0).pretty().to_string(), "3.0");
-
-        assert_eq!(F64(3.1).to_string(), "3.1");
-        assert_eq!(F64(3.1).pretty().to_string(), "3.1");
-
-        assert_eq!(F64(-1.5).to_string(), "-1.5");
-        assert_eq!(F64(-1.5).pretty().to_string(), "-1.5");
-
-        assert_eq!(F64(0.5).to_string(), "0.5");
-        assert_eq!(F64(0.5).pretty().to_string(), "0.5");
-
-        assert_eq!(F64(f64::NAN).to_string(), "null");
-        assert_eq!(F64(f64::NAN).pretty().to_string(), "null");
-
-        assert_eq!(F64(f64::INFINITY).to_string(), "null");
-        assert_eq!(F64(f64::INFINITY).pretty().to_string(), "null");
-
-        assert_eq!(F64(f64::NEG_INFINITY).to_string(), "null");
-        assert_eq!(F64(f64::NEG_INFINITY).pretty().to_string(), "null");
-    }
-
-    #[test]
-    fn test_write_str() {
-        assert_eq!(String("".to_string()).to_string(), "\"\"");
-        assert_eq!(String("".to_string()).pretty().to_string(), "\"\"");
-
-        assert_eq!(String("homura".to_string()).to_string(), "\"homura\"");
-        assert_eq!(String("madoka".to_string()).pretty().to_string(), "\"madoka\"");
-    }
-
-    #[test]
-    fn test_write_bool() {
-        assert_eq!(Boolean(true).to_string(), "true");
-        assert_eq!(Boolean(true).pretty().to_string(), "true");
-
-        assert_eq!(Boolean(false).to_string(), "false");
-        assert_eq!(Boolean(false).pretty().to_string(), "false");
-    }
-
-    #[test]
-    fn test_write_array() {
-        assert_eq!(Array(vec![]).to_string(), "[]");
-        assert_eq!(Array(vec![]).pretty().to_string(), "[]");
-
-        assert_eq!(Array(vec![Boolean(true)]).to_string(), "[true]");
-        assert_eq!(
-            Array(vec![Boolean(true)]).pretty().to_string(),
-            "\
-            [\n  \
-                true\n\
-            ]"
-        );
-
-        let long_test_array = Array(vec![
-            Boolean(false),
-            Null,
-            Array(vec![String("foo\nbar".to_string()), F64(3.5)])]);
-
-        assert_eq!(long_test_array.to_string(),
-            "[false,null,[\"foo\\nbar\",3.5]]");
-        assert_eq!(
-            long_test_array.pretty().to_string(),
-            "\
-            [\n  \
-                false,\n  \
-                null,\n  \
-                [\n    \
-                    \"foo\\nbar\",\n    \
-                    3.5\n  \
-                ]\n\
-            ]"
-        );
-    }
-
-    #[test]
-    fn test_write_object() {
-        assert_eq!(mk_object(&[]).to_string(), "{}");
-        assert_eq!(mk_object(&[]).pretty().to_string(), "{}");
-
-        assert_eq!(
-            mk_object(&[
-                ("a".to_string(), Boolean(true))
-            ]).to_string(),
-            "{\"a\":true}"
-        );
-        assert_eq!(
-            mk_object(&[("a".to_string(), Boolean(true))]).pretty().to_string(),
-            "\
-            {\n  \
-                \"a\": true\n\
-            }"
-        );
-
-        let complex_obj = mk_object(&[
-                ("b".to_string(), Array(vec![
-                    mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
-                    mk_object(&[("d".to_string(), String("".to_string()))])
-                ]))
-            ]);
-
-        assert_eq!(
-            complex_obj.to_string(),
-            "{\
-                \"b\":[\
-                    {\"c\":\"\\f\\r\"},\
-                    {\"d\":\"\"}\
-                ]\
-            }"
-        );
-        assert_eq!(
-            complex_obj.pretty().to_string(),
-            "\
-            {\n  \
-                \"b\": [\n    \
-                    {\n      \
-                        \"c\": \"\\f\\r\"\n    \
-                    },\n    \
-                    {\n      \
-                        \"d\": \"\"\n    \
-                    }\n  \
-                ]\n\
-            }"
-        );
-
-        let a = mk_object(&[
-            ("a".to_string(), Boolean(true)),
-            ("b".to_string(), Array(vec![
-                mk_object(&[("c".to_string(), String("\x0c\r".to_string()))]),
-                mk_object(&[("d".to_string(), String("".to_string()))])
-            ]))
-        ]);
-
-        // We can't compare the strings directly because the object fields be
-        // printed in a different order.
-        assert_eq!(a.clone(), a.to_string().parse().unwrap());
-        assert_eq!(a.clone(), a.pretty().to_string().parse().unwrap());
-    }
-
-    #[test]
-    fn test_write_enum() {
-        let animal = Dog;
-        assert_eq!(
-            format!("{}", super::as_json(&animal)),
-            "\"Dog\""
-        );
-        assert_eq!(
-            format!("{}", super::as_pretty_json(&animal)),
-            "\"Dog\""
-        );
-
-        let animal = Frog("Henry".to_string(), 349);
-        assert_eq!(
-            format!("{}", super::as_json(&animal)),
-            "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}"
-        );
-        assert_eq!(
-            format!("{}", super::as_pretty_json(&animal)),
-            "{\n  \
-               \"variant\": \"Frog\",\n  \
-               \"fields\": [\n    \
-                 \"Henry\",\n    \
-                 349\n  \
-               ]\n\
-             }"
-        );
-    }
-
-    macro_rules! check_encoder_for_simple {
-        ($value:expr, $expected:expr) => ({
-            let s = format!("{}", super::as_json(&$value));
-            assert_eq!(s, $expected);
-
-            let s = format!("{}", super::as_pretty_json(&$value));
-            assert_eq!(s, $expected);
-        })
-    }
-
-    #[test]
-    fn test_write_some() {
-        check_encoder_for_simple!(Some("jodhpurs".to_string()), "\"jodhpurs\"");
-    }
-
-    #[test]
-    fn test_write_none() {
-        check_encoder_for_simple!(None::<string::String>, "null");
-    }
-
-    #[test]
-    fn test_write_char() {
-        check_encoder_for_simple!('a', "\"a\"");
-        check_encoder_for_simple!('\t', "\"\\t\"");
-        check_encoder_for_simple!('\u{0000}', "\"\\u0000\"");
-        check_encoder_for_simple!('\u{001b}', "\"\\u001b\"");
-        check_encoder_for_simple!('\u{007f}', "\"\\u007f\"");
-        check_encoder_for_simple!('\u{00a0}', "\"\u{00a0}\"");
-        check_encoder_for_simple!('\u{abcd}', "\"\u{abcd}\"");
-        check_encoder_for_simple!('\u{10ffff}', "\"\u{10ffff}\"");
-    }
-
-    #[test]
-    fn test_trailing_characters() {
-        assert_eq!(Json::from_str("nulla"),  Err(SyntaxError(TrailingCharacters, 1, 5)));
-        assert_eq!(Json::from_str("truea"),  Err(SyntaxError(TrailingCharacters, 1, 5)));
-        assert_eq!(Json::from_str("falsea"), Err(SyntaxError(TrailingCharacters, 1, 6)));
-        assert_eq!(Json::from_str("1a"),     Err(SyntaxError(TrailingCharacters, 1, 2)));
-        assert_eq!(Json::from_str("[]a"),    Err(SyntaxError(TrailingCharacters, 1, 3)));
-        assert_eq!(Json::from_str("{}a"),    Err(SyntaxError(TrailingCharacters, 1, 3)));
-    }
-
-    #[test]
-    fn test_read_identifiers() {
-        assert_eq!(Json::from_str("n"),    Err(SyntaxError(InvalidSyntax, 1, 2)));
-        assert_eq!(Json::from_str("nul"),  Err(SyntaxError(InvalidSyntax, 1, 4)));
-        assert_eq!(Json::from_str("t"),    Err(SyntaxError(InvalidSyntax, 1, 2)));
-        assert_eq!(Json::from_str("truz"), Err(SyntaxError(InvalidSyntax, 1, 4)));
-        assert_eq!(Json::from_str("f"),    Err(SyntaxError(InvalidSyntax, 1, 2)));
-        assert_eq!(Json::from_str("faz"),  Err(SyntaxError(InvalidSyntax, 1, 3)));
-
-        assert_eq!(Json::from_str("null"), Ok(Null));
-        assert_eq!(Json::from_str("true"), Ok(Boolean(true)));
-        assert_eq!(Json::from_str("false"), Ok(Boolean(false)));
-        assert_eq!(Json::from_str(" null "), Ok(Null));
-        assert_eq!(Json::from_str(" true "), Ok(Boolean(true)));
-        assert_eq!(Json::from_str(" false "), Ok(Boolean(false)));
-    }
-
-    #[test]
-    fn test_decode_identifiers() {
-        let v: () = super::decode("null").unwrap();
-        assert_eq!(v, ());
-
-        let v: bool = super::decode("true").unwrap();
-        assert_eq!(v, true);
-
-        let v: bool = super::decode("false").unwrap();
-        assert_eq!(v, false);
-    }
-
-    #[test]
-    fn test_read_number() {
-        assert_eq!(Json::from_str("+"),   Err(SyntaxError(InvalidSyntax, 1, 1)));
-        assert_eq!(Json::from_str("."),   Err(SyntaxError(InvalidSyntax, 1, 1)));
-        assert_eq!(Json::from_str("NaN"), Err(SyntaxError(InvalidSyntax, 1, 1)));
-        assert_eq!(Json::from_str("-"),   Err(SyntaxError(InvalidNumber, 1, 2)));
-        assert_eq!(Json::from_str("00"),  Err(SyntaxError(InvalidNumber, 1, 2)));
-        assert_eq!(Json::from_str("1."),  Err(SyntaxError(InvalidNumber, 1, 3)));
-        assert_eq!(Json::from_str("1e"),  Err(SyntaxError(InvalidNumber, 1, 3)));
-        assert_eq!(Json::from_str("1e+"), Err(SyntaxError(InvalidNumber, 1, 4)));
-
-        assert_eq!(Json::from_str("18446744073709551616"), Err(SyntaxError(InvalidNumber, 1, 20)));
-        assert_eq!(Json::from_str("18446744073709551617"), Err(SyntaxError(InvalidNumber, 1, 20)));
-        assert_eq!(Json::from_str("-9223372036854775809"), Err(SyntaxError(InvalidNumber, 1, 21)));
-
-        assert_eq!(Json::from_str("3"), Ok(U64(3)));
-        assert_eq!(Json::from_str("3.1"), Ok(F64(3.1)));
-        assert_eq!(Json::from_str("-1.2"), Ok(F64(-1.2)));
-        assert_eq!(Json::from_str("0.4"), Ok(F64(0.4)));
-        assert_eq!(Json::from_str("0.4e5"), Ok(F64(0.4e5)));
-        assert_eq!(Json::from_str("0.4e+15"), Ok(F64(0.4e15)));
-        assert_eq!(Json::from_str("0.4e-01"), Ok(F64(0.4e-01)));
-        assert_eq!(Json::from_str("123456789.5024"), Ok(F64(123456789.5024)));
-        assert_eq!(Json::from_str(" 3 "), Ok(U64(3)));
-
-        assert_eq!(Json::from_str("-9223372036854775808"), Ok(I64(i64::MIN)));
-        assert_eq!(Json::from_str("9223372036854775807"), Ok(U64(i64::MAX as u64)));
-        assert_eq!(Json::from_str("18446744073709551615"), Ok(U64(u64::MAX)));
-    }
-
-    #[test]
-    fn test_decode_numbers() {
-        let v: f64 = super::decode("3").unwrap();
-        assert_eq!(v, 3.0);
-
-        let v: f64 = super::decode("3.1").unwrap();
-        assert_eq!(v, 3.1);
-
-        let v: f64 = super::decode("-1.2").unwrap();
-        assert_eq!(v, -1.2);
-
-        let v: f64 = super::decode("0.4").unwrap();
-        assert_eq!(v, 0.4);
-
-        let v: f64 = super::decode("0.4e5").unwrap();
-        assert_eq!(v, 0.4e5);
-
-        let v: f64 = super::decode("0.4e15").unwrap();
-        assert_eq!(v, 0.4e15);
-
-        let v: f64 = super::decode("0.4e-01").unwrap();
-        assert_eq!(v, 0.4e-01);
-
-        let v: f64 = super::decode("123456789.5024").unwrap();
-        assert_eq!(v, 123456789.5024);
-
-        let v: u64 = super::decode("0").unwrap();
-        assert_eq!(v, 0);
-
-        let v: u64 = super::decode("18446744073709551615").unwrap();
-        assert_eq!(v, u64::MAX);
-
-        let v: i64 = super::decode("-9223372036854775808").unwrap();
-        assert_eq!(v, i64::MIN);
-
-        let v: i64 = super::decode("9223372036854775807").unwrap();
-        assert_eq!(v, i64::MAX);
-
-        let res: DecodeResult<i64> = super::decode("765.25252");
-        match res {
-            Ok(..) => panic!("expected an error"),
-            Err(ExpectedError(ref s, _)) => assert_eq!(s, "Integer"),
-            Err(..) => panic!("expected an 'expected integer' error"),
-        }
-    }
-
-    #[test]
-    fn test_read_str() {
-        assert_eq!(Json::from_str("\""),     Err(SyntaxError(EOFWhileParsingString, 1, 2)));
-        assert_eq!(Json::from_str("\"lol"),  Err(SyntaxError(EOFWhileParsingString, 1, 5)));
-        assert_eq!(Json::from_str("\"\n\""), Err(SyntaxError(ControlCharacterInString, 2, 1)));
-        assert_eq!(Json::from_str("\"\0\""), Err(SyntaxError(ControlCharacterInString, 1, 2)));
-        assert_eq!(Json::from_str("\"\u{1}\""), Err(SyntaxError(ControlCharacterInString, 1, 2)));
-        assert_eq!(Json::from_str("\"\u{1F}\""), Err(SyntaxError(ControlCharacterInString, 1, 2)));
-
-        // Only C0 control characters are excluded.
-        assert!('\u{7F}'.is_control());
-        assert!('\u{80}'.is_control());
-        assert!('\u{9F}'.is_control());
-        let c1_controls = "\u{7F}\u{80}\u{9F}".to_string();
-        assert_eq!(Json::from_str(&format!("\"{}\"", c1_controls)), Ok(String(c1_controls)));
-
-        assert_eq!(Json::from_str("\"\""), Ok(String("".to_string())));
-        assert_eq!(Json::from_str("\"foo\""), Ok(String("foo".to_string())));
-        assert_eq!(Json::from_str("\"\\\"\""), Ok(String("\"".to_string())));
-        assert_eq!(Json::from_str("\"\\b\""), Ok(String("\x08".to_string())));
-        assert_eq!(Json::from_str("\"\\n\""), Ok(String("\n".to_string())));
-        assert_eq!(Json::from_str("\"\\r\""), Ok(String("\r".to_string())));
-        assert_eq!(Json::from_str("\"\\t\""), Ok(String("\t".to_string())));
-        assert_eq!(Json::from_str(" \"foo\" "), Ok(String("foo".to_string())));
-        assert_eq!(Json::from_str("\"\\u12ab\""), Ok(String("\u{12ab}".to_string())));
-        assert_eq!(Json::from_str("\"\\uAB12\""), Ok(String("\u{AB12}".to_string())));
-    }
-
-    #[test]
-    fn test_decode_str() {
-        let s = [("\"\"", ""),
-                 ("\"foo\"", "foo"),
-                 ("\"\\\"\"", "\""),
-                 ("\"\\b\"", "\x08"),
-                 ("\"\\n\"", "\n"),
-                 ("\"\\r\"", "\r"),
-                 ("\"\\t\"", "\t"),
-                 ("\"\\u12ab\"", "\u{12ab}"),
-                 ("\"\\uAB12\"", "\u{AB12}")];
-
-        for &(i, o) in s.iter() {
-            let v: string::String = super::decode(i).unwrap();
-            assert_eq!(v, o);
-        }
-    }
-
-    #[test]
-    fn test_read_array() {
-        assert_eq!(Json::from_str("["),     Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
-        assert_eq!(Json::from_str("[1"),    Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
-        assert_eq!(Json::from_str("[1,"),   Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
-        assert_eq!(Json::from_str("[1,]"),  Err(SyntaxError(InvalidSyntax,        1, 4)));
-        assert_eq!(Json::from_str("[6 7]"), Err(SyntaxError(InvalidSyntax,        1, 4)));
-
-        assert_eq!(Json::from_str("[]"), Ok(Array(vec![])));
-        assert_eq!(Json::from_str("[ ]"), Ok(Array(vec![])));
-        assert_eq!(Json::from_str("[true]"), Ok(Array(vec![Boolean(true)])));
-        assert_eq!(Json::from_str("[ false ]"), Ok(Array(vec![Boolean(false)])));
-        assert_eq!(Json::from_str("[null]"), Ok(Array(vec![Null])));
-        assert_eq!(Json::from_str("[3, 1]"),
-                     Ok(Array(vec![U64(3), U64(1)])));
-        assert_eq!(Json::from_str("\n[3, 2]\n"),
-                     Ok(Array(vec![U64(3), U64(2)])));
-        assert_eq!(Json::from_str("[2, [4, 1]]"),
-               Ok(Array(vec![U64(2), Array(vec![U64(4), U64(1)])])));
-    }
-
-    #[test]
-    fn test_decode_array() {
-        let v: Vec<()> = super::decode("[]").unwrap();
-        assert_eq!(v, vec![]);
-
-        let v: Vec<()> = super::decode("[null]").unwrap();
-        assert_eq!(v, vec![()]);
-
-        let v: Vec<bool> = super::decode("[true]").unwrap();
-        assert_eq!(v, vec![true]);
-
-        let v: Vec<isize> = super::decode("[3, 1]").unwrap();
-        assert_eq!(v, vec![3, 1]);
-
-        let v: Vec<Vec<usize>> = super::decode("[[3], [1, 2]]").unwrap();
-        assert_eq!(v, vec![vec![3], vec![1, 2]]);
-    }
-
-    #[test]
-    fn test_decode_tuple() {
-        let t: (usize, usize, usize) = super::decode("[1, 2, 3]").unwrap();
-        assert_eq!(t, (1, 2, 3));
-
-        let t: (usize, string::String) = super::decode("[1, \"two\"]").unwrap();
-        assert_eq!(t, (1, "two".to_string()));
-    }
-
-    #[test]
-    fn test_decode_tuple_malformed_types() {
-        assert!(super::decode::<(usize, string::String)>("[1, 2]").is_err());
-    }
-
-    #[test]
-    fn test_decode_tuple_malformed_length() {
-        assert!(super::decode::<(usize, usize)>("[1, 2, 3]").is_err());
-    }
-
-    #[test]
-    fn test_read_object() {
-        assert_eq!(Json::from_str("{"),       Err(SyntaxError(EOFWhileParsingObject, 1, 2)));
-        assert_eq!(Json::from_str("{ "),      Err(SyntaxError(EOFWhileParsingObject, 1, 3)));
-        assert_eq!(Json::from_str("{1"),      Err(SyntaxError(KeyMustBeAString,      1, 2)));
-        assert_eq!(Json::from_str("{ \"a\""), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
-        assert_eq!(Json::from_str("{\"a\""),  Err(SyntaxError(EOFWhileParsingObject, 1, 5)));
-        assert_eq!(Json::from_str("{\"a\" "), Err(SyntaxError(EOFWhileParsingObject, 1, 6)));
-
-        assert_eq!(Json::from_str("{\"a\" 1"),   Err(SyntaxError(ExpectedColon,         1, 6)));
-        assert_eq!(Json::from_str("{\"a\":"),    Err(SyntaxError(EOFWhileParsingValue,  1, 6)));
-        assert_eq!(Json::from_str("{\"a\":1"),   Err(SyntaxError(EOFWhileParsingObject, 1, 7)));
-        assert_eq!(Json::from_str("{\"a\":1 1"), Err(SyntaxError(InvalidSyntax,         1, 8)));
-        assert_eq!(Json::from_str("{\"a\":1,"),  Err(SyntaxError(EOFWhileParsingObject, 1, 8)));
-
-        assert_eq!(Json::from_str("{}").unwrap(), mk_object(&[]));
-        assert_eq!(Json::from_str("{\"a\": 3}").unwrap(),
-                  mk_object(&[("a".to_string(), U64(3))]));
-
-        assert_eq!(Json::from_str(
-                      "{ \"a\": null, \"b\" : true }").unwrap(),
-                  mk_object(&[
-                      ("a".to_string(), Null),
-                      ("b".to_string(), Boolean(true))]));
-        assert_eq!(Json::from_str("\n{ \"a\": null, \"b\" : true }\n").unwrap(),
-                  mk_object(&[
-                      ("a".to_string(), Null),
-                      ("b".to_string(), Boolean(true))]));
-        assert_eq!(Json::from_str(
-                      "{\"a\" : 1.0 ,\"b\": [ true ]}").unwrap(),
-                  mk_object(&[
-                      ("a".to_string(), F64(1.0)),
-                      ("b".to_string(), Array(vec![Boolean(true)]))
-                  ]));
-        assert_eq!(Json::from_str(
-                      "{\
-                          \"a\": 1.0, \
-                          \"b\": [\
-                              true,\
-                              \"foo\\nbar\", \
-                              { \"c\": {\"d\": null} } \
-                          ]\
-                      }").unwrap(),
-                  mk_object(&[
-                      ("a".to_string(), F64(1.0)),
-                      ("b".to_string(), Array(vec![
-                          Boolean(true),
-                          String("foo\nbar".to_string()),
-                          mk_object(&[
-                              ("c".to_string(), mk_object(&[("d".to_string(), Null)]))
-                          ])
-                      ]))
-                  ]));
-    }
-
-    #[test]
-    fn test_decode_struct() {
-        let s = "{
-            \"inner\": [
-                { \"a\": null, \"b\": 2, \"c\": [\"abc\", \"xyz\"] }
-            ]
-        }";
-
-        let v: Outer = super::decode(s).unwrap();
-        assert_eq!(
-            v,
-            Outer {
-                inner: vec![
-                    Inner { a: (), b: 2, c: vec!["abc".to_string(), "xyz".to_string()] }
-                ]
-            }
-        );
-    }
-
-    #[derive(RustcDecodable)]
-    struct FloatStruct {
-        f: f64,
-        a: Vec<f64>
-    }
-    #[test]
-    fn test_decode_struct_with_nan() {
-        let s = "{\"f\":null,\"a\":[null,123]}";
-        let obj: FloatStruct = super::decode(s).unwrap();
-        assert!(obj.f.is_nan());
-        assert!(obj.a[0].is_nan());
-        assert_eq!(obj.a[1], 123f64);
-    }
-
-    #[test]
-    fn test_decode_option() {
-        let value: Option<string::String> = super::decode("null").unwrap();
-        assert_eq!(value, None);
-
-        let value: Option<string::String> = super::decode("\"jodhpurs\"").unwrap();
-        assert_eq!(value, Some("jodhpurs".to_string()));
-    }
-
-    #[test]
-    fn test_decode_enum() {
-        let value: Animal = super::decode("\"Dog\"").unwrap();
-        assert_eq!(value, Dog);
-
-        let s = "{\"variant\":\"Frog\",\"fields\":[\"Henry\",349]}";
-        let value: Animal = super::decode(s).unwrap();
-        assert_eq!(value, Frog("Henry".to_string(), 349));
-    }
-
-    #[test]
-    fn test_decode_result() {
-        let value: Result<i32, i8> = Ok(4);
-        let json_value = super::encode(&value).unwrap();
-        assert_eq!(json_value, "{\"variant\":\"Ok\",\"fields\":[4]}");
-        let decoded_value: Result<i32, i8> = super::decode(&json_value).unwrap();
-        assert_eq!(decoded_value, Ok(4));
-    }
-
-    #[test]
-    fn test_decode_map() {
-        let s = "{\"a\": \"Dog\", \"b\": {\"variant\":\"Frog\",\
-                  \"fields\":[\"Henry\", 349]}}";
-        let mut map: BTreeMap<string::String, Animal> = super::decode(s).unwrap();
-
-        assert_eq!(map.remove(&"a".to_string()), Some(Dog));
-        assert_eq!(map.remove(&"b".to_string()), Some(Frog("Henry".to_string(), 349)));
-    }
-
-    #[test]
-    fn test_multiline_errors() {
-        assert_eq!(Json::from_str("{\n  \"foo\":\n \"bar\""),
-            Err(SyntaxError(EOFWhileParsingObject, 3, 8)));
-    }
-
-    #[derive(RustcDecodable)]
-    #[allow(dead_code)]
-    struct DecodeStruct {
-        x: f64,
-        y: bool,
-        z: string::String,
-        w: Vec<DecodeStruct>
-    }
-    #[derive(RustcDecodable)]
-    enum DecodeEnum {
-        A(f64),
-        B(string::String)
-    }
-    fn check_err<T: Decodable>(to_parse: &'static str, expected: DecoderError) {
-        let res: DecodeResult<T> = match Json::from_str(to_parse) {
-            Err(e) => Err(ParseError(e)),
-            Ok(json) => Decodable::decode(&mut Decoder::new(json))
-        };
-        match res {
-            Ok(_) => panic!("`{:?}` parsed & decoded ok, expecting error `{:?}`",
-                              to_parse, expected),
-            Err(ParseError(e)) => panic!("`{}` is not valid json: {:?}",
-                                           to_parse, e),
-            Err(e) => {
-                assert_eq!(e, expected);
-            }
-        }
-    }
-    #[test]
-    fn test_decode_errors_struct() {
-        check_err::<DecodeStruct>("[]", ExpectedError("Object".to_string(), "[]".to_string()));
-        check_err::<DecodeStruct>("{\"x\": true, \"y\": true, \"z\": \"\", \"w\": []}",
-                                  ExpectedError("Number".to_string(), "true".to_string()));
-        check_err::<DecodeStruct>("{\"x\": 1, \"y\": [], \"z\": \"\", \"w\": []}",
-                                  ExpectedError("Boolean".to_string(), "[]".to_string()));
-        check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": {}, \"w\": []}",
-                                  ExpectedError("String".to_string(), "{}".to_string()));
-        check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\", \"w\": null}",
-                                  ExpectedError("Array".to_string(), "null".to_string()));
-        check_err::<DecodeStruct>("{\"x\": 1, \"y\": true, \"z\": \"\"}",
-                                  MissingFieldError("w".to_string()));
-    }
-    #[test]
-    fn test_decode_errors_enum() {
-        check_err::<DecodeEnum>("{}",
-                                MissingFieldError("variant".to_string()));
-        check_err::<DecodeEnum>("{\"variant\": 1}",
-                                ExpectedError("String".to_string(), "1".to_string()));
-        check_err::<DecodeEnum>("{\"variant\": \"A\"}",
-                                MissingFieldError("fields".to_string()));
-        check_err::<DecodeEnum>("{\"variant\": \"A\", \"fields\": null}",
-                                ExpectedError("Array".to_string(), "null".to_string()));
-        check_err::<DecodeEnum>("{\"variant\": \"C\", \"fields\": []}",
-                                UnknownVariantError("C".to_string()));
-    }
-
-    #[test]
-    fn test_find(){
-        let json_value = Json::from_str("{\"dog\" : \"cat\"}").unwrap();
-        let found_str = json_value.find("dog");
-        assert!(found_str.unwrap().as_string().unwrap() == "cat");
-    }
-
-    #[test]
-    fn test_find_path(){
-        let json_value = Json::from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
-        let found_str = json_value.find_path(&["dog", "cat", "mouse"]);
-        assert!(found_str.unwrap().as_string().unwrap() == "cheese");
-    }
-
-    #[test]
-    fn test_search(){
-        let json_value = Json::from_str("{\"dog\":{\"cat\": {\"mouse\" : \"cheese\"}}}").unwrap();
-        let found_str = json_value.search("mouse").and_then(|j| j.as_string());
-        assert!(found_str.unwrap() == "cheese");
-    }
-
-    #[test]
-    fn test_index(){
-        let json_value = Json::from_str("{\"animals\":[\"dog\",\"cat\",\"mouse\"]}").unwrap();
-        let ref array = json_value["animals"];
-        assert_eq!(array[0].as_string().unwrap(), "dog");
-        assert_eq!(array[1].as_string().unwrap(), "cat");
-        assert_eq!(array[2].as_string().unwrap(), "mouse");
-    }
-
-    #[test]
-    fn test_is_object(){
-        let json_value = Json::from_str("{}").unwrap();
-        assert!(json_value.is_object());
-    }
-
-    #[test]
-    fn test_as_object(){
-        let json_value = Json::from_str("{}").unwrap();
-        let json_object = json_value.as_object();
-        assert!(json_object.is_some());
-    }
-
-    #[test]
-    fn test_is_array(){
-        let json_value = Json::from_str("[1, 2, 3]").unwrap();
-        assert!(json_value.is_array());
-    }
-
-    #[test]
-    fn test_as_array(){
-        let json_value = Json::from_str("[1, 2, 3]").unwrap();
-        let json_array = json_value.as_array();
-        let expected_length = 3;
-        assert!(json_array.is_some() && json_array.unwrap().len() == expected_length);
-    }
-
-    #[test]
-    fn test_is_string(){
-        let json_value = Json::from_str("\"dog\"").unwrap();
-        assert!(json_value.is_string());
-    }
-
-    #[test]
-    fn test_as_string(){
-        let json_value = Json::from_str("\"dog\"").unwrap();
-        let json_str = json_value.as_string();
-        let expected_str = "dog";
-        assert_eq!(json_str, Some(expected_str));
-    }
-
-    #[test]
-    fn test_is_number(){
-        let json_value = Json::from_str("12").unwrap();
-        assert!(json_value.is_number());
-    }
-
-    #[test]
-    fn test_is_i64(){
-        let json_value = Json::from_str("-12").unwrap();
-        assert!(json_value.is_i64());
-
-        let json_value = Json::from_str("12").unwrap();
-        assert!(!json_value.is_i64());
-
-        let json_value = Json::from_str("12.0").unwrap();
-        assert!(!json_value.is_i64());
-    }
-
-    #[test]
-    fn test_is_u64(){
-        let json_value = Json::from_str("12").unwrap();
-        assert!(json_value.is_u64());
-
-        let json_value = Json::from_str("-12").unwrap();
-        assert!(!json_value.is_u64());
-
-        let json_value = Json::from_str("12.0").unwrap();
-        assert!(!json_value.is_u64());
-    }
-
-    #[test]
-    fn test_is_f64(){
-        let json_value = Json::from_str("12").unwrap();
-        assert!(!json_value.is_f64());
-
-        let json_value = Json::from_str("-12").unwrap();
-        assert!(!json_value.is_f64());
-
-        let json_value = Json::from_str("12.0").unwrap();
-        assert!(json_value.is_f64());
-
-        let json_value = Json::from_str("-12.0").unwrap();
-        assert!(json_value.is_f64());
-    }
-
-    #[test]
-    fn test_as_i64(){
-        let json_value = Json::from_str("-12").unwrap();
-        let json_num = json_value.as_i64();
-        assert_eq!(json_num, Some(-12));
-    }
-
-    #[test]
-    fn test_as_u64(){
-        let json_value = Json::from_str("12").unwrap();
-        let json_num = json_value.as_u64();
-        assert_eq!(json_num, Some(12));
-    }
-
-    #[test]
-    fn test_as_f64(){
-        let json_value = Json::from_str("12.0").unwrap();
-        let json_num = json_value.as_f64();
-        assert_eq!(json_num, Some(12f64));
-    }
-
-    #[test]
-    fn test_is_boolean(){
-        let json_value = Json::from_str("false").unwrap();
-        assert!(json_value.is_boolean());
-    }
-
-    #[test]
-    fn test_as_boolean(){
-        let json_value = Json::from_str("false").unwrap();
-        let json_bool = json_value.as_boolean();
-        let expected_bool = false;
-        assert!(json_bool.is_some() && json_bool.unwrap() == expected_bool);
-    }
-
-    #[test]
-    fn test_is_null(){
-        let json_value = Json::from_str("null").unwrap();
-        assert!(json_value.is_null());
-    }
-
-    #[test]
-    fn test_as_null(){
-        let json_value = Json::from_str("null").unwrap();
-        let json_null = json_value.as_null();
-        let expected_null = ();
-        assert!(json_null.is_some() && json_null.unwrap() == expected_null);
-    }
-
-    #[test]
-    fn test_encode_hashmap_with_numeric_key() {
-        use std::collections::HashMap;
-        let mut hm: HashMap<usize, bool> = HashMap::new();
-        hm.insert(1, true);
-        let json_str = super::as_pretty_json(&hm).to_string();
-        match Json::from_str(&json_str) {
-            Err(_) => panic!("Unable to parse json_str: {}", json_str),
-            _ => {} // it parsed and we are good to go
-        }
-    }
-
-    #[test]
-    fn test_negative_zero() {
-        Json::from_str("{\"test\":-0}").unwrap();
-    }
-
-    #[test]
-    fn test_prettyencode_hashmap_with_numeric_key() {
-        use std::collections::HashMap;
-        let mut hm: HashMap<usize, bool> = HashMap::new();
-        hm.insert(1, true);
-        let json_str = super::as_pretty_json(&hm).to_string();
-        match Json::from_str(&json_str) {
-            Err(_) => panic!("Unable to parse json_str: {}", json_str),
-            _ => {} // it parsed and we are good to go
-        }
-    }
-
-    #[test]
-    fn test_prettyencoder_indent_level_param() {
-        use std::collections::BTreeMap;
-
-        let mut tree = BTreeMap::new();
-
-        tree.insert("hello".to_string(), String("guten tag".to_string()));
-        tree.insert("goodbye".to_string(), String("sayonara".to_string()));
-
-        let json = Array(
-            // The following layout below should look a lot like
-            // the pretty-printed JSON (indent * x)
-            vec!
-            ( // 0x
-                String("greetings".to_string()), // 1x
-                Object(tree), // 1x + 2x + 2x + 1x
-            ) // 0x
-            // End JSON array (7 lines)
-        );
-
-        // Helper function for counting indents
-        fn indents(source: &str) -> usize {
-            let trimmed = source.trim_left_matches(' ');
-            source.len() - trimmed.len()
-        }
-
-        // Test up to 4 spaces of indents (more?)
-        for i in 0..4 {
-            let printed = super::as_pretty_json(&json).indent(i as u32)
-                                .to_string();
-
-            // Check for indents at each line
-            let lines: Vec<&str> = printed.lines().collect();
-            assert_eq!(lines.len(), 7); // JSON should be 7 lines
-
-            assert_eq!(indents(lines[0]), 0 * i); // [
-            assert_eq!(indents(lines[1]), 1 * i); //   "greetings",
-            assert_eq!(indents(lines[2]), 1 * i); //   {
-            assert_eq!(indents(lines[3]), 2 * i); //     "hello": "guten tag",
-            assert_eq!(indents(lines[4]), 2 * i); //     "goodbye": "sayonara"
-            assert_eq!(indents(lines[5]), 1 * i); //   },
-            assert_eq!(indents(lines[6]), 0 * i); // ]
-
-            // Finally, test that the pretty-printed JSON is valid
-            Json::from_str(&printed).ok()
-                 .expect("Pretty-printed JSON is invalid!");
-        }
-    }
-
-    #[test]
-    fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
-        use std::collections::HashMap;
-        use Decodable;
-        let json_str = "{\"1\":true}";
-        let json_obj = match Json::from_str(json_str) {
-            Err(_) => panic!("Unable to parse json_str: {}", json_str),
-            Ok(o) => o
-        };
-        let mut decoder = Decoder::new(json_obj);
-        let _hm: HashMap<usize, bool> = Decodable::decode(&mut decoder).unwrap();
-    }
-
-    #[test]
-    fn test_hashmap_with_enum_key() {
-        use std::collections::HashMap;
-        use json;
-        #[derive(RustcEncodable, Eq, Hash, PartialEq, RustcDecodable, Debug)]
-        enum Enum {
-            Foo,
-            #[allow(dead_code)]
-            Bar,
-        }
-        let mut map = HashMap::new();
-        map.insert(Enum::Foo, 0);
-        let result = json::encode(&map).unwrap();
-        assert_eq!(result, r#"{"Foo":0}"#);
-        let decoded: HashMap<Enum, _> = json::decode(&result).unwrap();
-        assert_eq!(map, decoded);
-    }
-
-    #[test]
-    fn test_hashmap_with_numeric_key_will_error_with_string_keys() {
-        use std::collections::HashMap;
-        use Decodable;
-        let json_str = "{\"a\":true}";
-        let json_obj = match Json::from_str(json_str) {
-            Err(_) => panic!("Unable to parse json_str: {}", json_str),
-            Ok(o) => o
-        };
-        let mut decoder = Decoder::new(json_obj);
-        let result: Result<HashMap<usize, bool>, DecoderError> = Decodable::decode(&mut decoder);
-        assert_eq!(result, Err(ExpectedError("Number".to_string(), "a".to_string())));
-    }
-
-    fn assert_stream_equal(src: &str,
-                           expected: Vec<(JsonEvent, Vec<StackElement>)>) {
-        let mut parser = Parser::new(src.chars());
-        let mut i = 0;
-        loop {
-            let evt = match parser.next() {
-                Some(e) => e,
-                None => { break; }
-            };
-            let (ref expected_evt, ref expected_stack) = expected[i];
-            if !parser.stack().is_equal_to(&expected_stack) {
-                panic!("Parser stack is not equal to {:?}", expected_stack);
-            }
-            assert_eq!(&evt, expected_evt);
-            i+=1;
-        }
-    }
-    #[test]
-    #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
-    fn test_streaming_parser() {
-        assert_stream_equal(
-            r#"{ "foo":"bar", "array" : [0, 1, 2, 3, 4, 5], "idents":[null,true,false]}"#,
-            vec![
-                (ObjectStart,             vec![]),
-                  (StringValue("bar".to_string()),   vec![Key("foo")]),
-                  (ArrayStart,            vec![Key("array")]),
-                    (U64Value(0),         vec![Key("array"), Index(0)]),
-                    (U64Value(1),         vec![Key("array"), Index(1)]),
-                    (U64Value(2),         vec![Key("array"), Index(2)]),
-                    (U64Value(3),         vec![Key("array"), Index(3)]),
-                    (U64Value(4),         vec![Key("array"), Index(4)]),
-                    (U64Value(5),         vec![Key("array"), Index(5)]),
-                  (ArrayEnd,              vec![Key("array")]),
-                  (ArrayStart,            vec![Key("idents")]),
-                    (NullValue,           vec![Key("idents"), Index(0)]),
-                    (BooleanValue(true),  vec![Key("idents"), Index(1)]),
-                    (BooleanValue(false), vec![Key("idents"), Index(2)]),
-                  (ArrayEnd,              vec![Key("idents")]),
-                (ObjectEnd,               vec![]),
-            ]
-        );
-    }
-    fn last_event(src: &str) -> JsonEvent {
-        let mut parser = Parser::new(src.chars());
-        let mut evt = NullValue;
-        loop {
-            evt = match parser.next() {
-                Some(e) => e,
-                None => return evt,
-            }
-        }
-    }
-
-    #[test]
-    #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
-    fn test_read_object_streaming() {
-        assert_eq!(last_event("{ "),      Error(SyntaxError(EOFWhileParsingObject, 1, 3)));
-        assert_eq!(last_event("{1"),      Error(SyntaxError(KeyMustBeAString,      1, 2)));
-        assert_eq!(last_event("{ \"a\""), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
-        assert_eq!(last_event("{\"a\""),  Error(SyntaxError(EOFWhileParsingObject, 1, 5)));
-        assert_eq!(last_event("{\"a\" "), Error(SyntaxError(EOFWhileParsingObject, 1, 6)));
-
-        assert_eq!(last_event("{\"a\" 1"),   Error(SyntaxError(ExpectedColon,         1, 6)));
-        assert_eq!(last_event("{\"a\":"),    Error(SyntaxError(EOFWhileParsingValue,  1, 6)));
-        assert_eq!(last_event("{\"a\":1"),   Error(SyntaxError(EOFWhileParsingObject, 1, 7)));
-        assert_eq!(last_event("{\"a\":1 1"), Error(SyntaxError(InvalidSyntax,         1, 8)));
-        assert_eq!(last_event("{\"a\":1,"),  Error(SyntaxError(EOFWhileParsingObject, 1, 8)));
-        assert_eq!(last_event("{\"a\":1,}"), Error(SyntaxError(TrailingComma, 1, 8)));
-
-        assert_stream_equal(
-            "{}",
-            vec![(ObjectStart, vec![]), (ObjectEnd, vec![])]
-        );
-        assert_stream_equal(
-            "{\"a\": 3}",
-            vec![
-                (ObjectStart,        vec![]),
-                  (U64Value(3),      vec![Key("a")]),
-                (ObjectEnd,          vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "{ \"a\": null, \"b\" : true }",
-            vec![
-                (ObjectStart,           vec![]),
-                  (NullValue,           vec![Key("a")]),
-                  (BooleanValue(true),  vec![Key("b")]),
-                (ObjectEnd,             vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "{\"a\" : 1.0 ,\"b\": [ true ]}",
-            vec![
-                (ObjectStart,           vec![]),
-                  (F64Value(1.0),       vec![Key("a")]),
-                  (ArrayStart,          vec![Key("b")]),
-                    (BooleanValue(true),vec![Key("b"), Index(0)]),
-                  (ArrayEnd,            vec![Key("b")]),
-                (ObjectEnd,             vec![]),
-            ]
-        );
-        assert_stream_equal(
-            r#"{
-                "a": 1.0,
-                "b": [
-                    true,
-                    "foo\nbar",
-                    { "c": {"d": null} },
-                    "\uD834\uDF06"
-                ]
-            }"#,
-            vec![
-                (ObjectStart,                   vec![]),
-                  (F64Value(1.0),               vec![Key("a")]),
-                  (ArrayStart,                  vec![Key("b")]),
-                    (BooleanValue(true),        vec![Key("b"), Index(0)]),
-                    (StringValue("foo\nbar".to_string()),  vec![Key("b"), Index(1)]),
-                    (ObjectStart,               vec![Key("b"), Index(2)]),
-                      (ObjectStart,             vec![Key("b"), Index(2), Key("c")]),
-                        (NullValue,             vec![Key("b"), Index(2), Key("c"), Key("d")]),
-                      (ObjectEnd,               vec![Key("b"), Index(2), Key("c")]),
-                    (ObjectEnd,                 vec![Key("b"), Index(2)]),
-                    (StringValue("\u{1D306}".to_string()),  vec![Key("b"), Index(3)]),
-                  (ArrayEnd,                    vec![Key("b")]),
-                (ObjectEnd,                     vec![]),
-            ]
-        );
-    }
-    #[test]
-    #[cfg_attr(target_word_size = "32", ignore)] // FIXME(#14064)
-    fn test_read_array_streaming() {
-        assert_stream_equal(
-            "[]",
-            vec![
-                (ArrayStart, vec![]),
-                (ArrayEnd,   vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "[ ]",
-            vec![
-                (ArrayStart, vec![]),
-                (ArrayEnd,   vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "[true]",
-            vec![
-                (ArrayStart,             vec![]),
-                    (BooleanValue(true), vec![Index(0)]),
-                (ArrayEnd,               vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "[ false ]",
-            vec![
-                (ArrayStart,              vec![]),
-                    (BooleanValue(false), vec![Index(0)]),
-                (ArrayEnd,                vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "[null]",
-            vec![
-                (ArrayStart,    vec![]),
-                    (NullValue, vec![Index(0)]),
-                (ArrayEnd,      vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "[3, 1]",
-            vec![
-                (ArrayStart,      vec![]),
-                    (U64Value(3), vec![Index(0)]),
-                    (U64Value(1), vec![Index(1)]),
-                (ArrayEnd,        vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "\n[3, 2]\n",
-            vec![
-                (ArrayStart,      vec![]),
-                    (U64Value(3), vec![Index(0)]),
-                    (U64Value(2), vec![Index(1)]),
-                (ArrayEnd,        vec![]),
-            ]
-        );
-        assert_stream_equal(
-            "[2, [4, 1]]",
-            vec![
-                (ArrayStart,           vec![]),
-                    (U64Value(2),      vec![Index(0)]),
-                    (ArrayStart,       vec![Index(1)]),
-                        (U64Value(4),  vec![Index(1), Index(0)]),
-                        (U64Value(1),  vec![Index(1), Index(1)]),
-                    (ArrayEnd,         vec![Index(1)]),
-                (ArrayEnd,             vec![]),
-            ]
-        );
-
-        assert_eq!(last_event("["), Error(SyntaxError(EOFWhileParsingValue, 1,  2)));
-
-        assert_eq!(Json::from_str("["),     Err(SyntaxError(EOFWhileParsingValue, 1, 2)));
-        assert_eq!(Json::from_str("[1"),    Err(SyntaxError(EOFWhileParsingArray, 1, 3)));
-        assert_eq!(Json::from_str("[1,"),   Err(SyntaxError(EOFWhileParsingValue, 1, 4)));
-        assert_eq!(Json::from_str("[1,]"),  Err(SyntaxError(InvalidSyntax,        1, 4)));
-        assert_eq!(Json::from_str("[6 7]"), Err(SyntaxError(InvalidSyntax,        1, 4)));
-
-    }
-    #[test]
-    fn test_trailing_characters_streaming() {
-        assert_eq!(last_event("nulla"),  Error(SyntaxError(TrailingCharacters, 1, 5)));
-        assert_eq!(last_event("truea"),  Error(SyntaxError(TrailingCharacters, 1, 5)));
-        assert_eq!(last_event("falsea"), Error(SyntaxError(TrailingCharacters, 1, 6)));
-        assert_eq!(last_event("1a"),     Error(SyntaxError(TrailingCharacters, 1, 2)));
-        assert_eq!(last_event("[]a"),    Error(SyntaxError(TrailingCharacters, 1, 3)));
-        assert_eq!(last_event("{}a"),    Error(SyntaxError(TrailingCharacters, 1, 3)));
-    }
-    #[test]
-    fn test_read_identifiers_streaming() {
-        assert_eq!(Parser::new("null".chars()).next(), Some(NullValue));
-        assert_eq!(Parser::new("true".chars()).next(), Some(BooleanValue(true)));
-        assert_eq!(Parser::new("false".chars()).next(), Some(BooleanValue(false)));
-
-        assert_eq!(last_event("n"),    Error(SyntaxError(InvalidSyntax, 1, 2)));
-        assert_eq!(last_event("nul"),  Error(SyntaxError(InvalidSyntax, 1, 4)));
-        assert_eq!(last_event("t"),    Error(SyntaxError(InvalidSyntax, 1, 2)));
-        assert_eq!(last_event("truz"), Error(SyntaxError(InvalidSyntax, 1, 4)));
-        assert_eq!(last_event("f"),    Error(SyntaxError(InvalidSyntax, 1, 2)));
-        assert_eq!(last_event("faz"),  Error(SyntaxError(InvalidSyntax, 1, 3)));
-    }
-
-    #[test]
-    fn test_stack() {
-        let mut stack = Stack::new();
-
-        assert!(stack.is_empty());
-        assert!(stack.len() == 0);
-        assert!(!stack.last_is_index());
-
-        stack.push_index(0);
-        stack.bump_index();
-
-        assert!(stack.len() == 1);
-        assert!(stack.is_equal_to(&[Index(1)]));
-        assert!(stack.starts_with(&[Index(1)]));
-        assert!(stack.ends_with(&[Index(1)]));
-        assert!(stack.last_is_index());
-        assert!(stack.get(0) == Index(1));
-
-        stack.push_key("foo".to_string());
-
-        assert!(stack.len() == 2);
-        assert!(stack.is_equal_to(&[Index(1), Key("foo")]));
-        assert!(stack.starts_with(&[Index(1), Key("foo")]));
-        assert!(stack.starts_with(&[Index(1)]));
-        assert!(stack.ends_with(&[Index(1), Key("foo")]));
-        assert!(stack.ends_with(&[Key("foo")]));
-        assert!(!stack.last_is_index());
-        assert!(stack.get(0) == Index(1));
-        assert!(stack.get(1) == Key("foo"));
-
-        stack.push_key("bar".to_string());
-
-        assert!(stack.len() == 3);
-        assert!(stack.is_equal_to(&[Index(1), Key("foo"), Key("bar")]));
-        assert!(stack.starts_with(&[Index(1)]));
-        assert!(stack.starts_with(&[Index(1), Key("foo")]));
-        assert!(stack.starts_with(&[Index(1), Key("foo"), Key("bar")]));
-        assert!(stack.ends_with(&[Key("bar")]));
-        assert!(stack.ends_with(&[Key("foo"), Key("bar")]));
-        assert!(stack.ends_with(&[Index(1), Key("foo"), Key("bar")]));
-        assert!(!stack.last_is_index());
-        assert!(stack.get(0) == Index(1));
-        assert!(stack.get(1) == Key("foo"));
-        assert!(stack.get(2) == Key("bar"));
-
-        stack.pop();
-
-        assert!(stack.len() == 2);
-        assert!(stack.is_equal_to(&[Index(1), Key("foo")]));
-        assert!(stack.starts_with(&[Index(1), Key("foo")]));
-        assert!(stack.starts_with(&[Index(1)]));
-        assert!(stack.ends_with(&[Index(1), Key("foo")]));
-        assert!(stack.ends_with(&[Key("foo")]));
-        assert!(!stack.last_is_index());
-        assert!(stack.get(0) == Index(1));
-        assert!(stack.get(1) == Key("foo"));
-    }
-
-    #[test]
-    fn test_to_json() {
-        use std::collections::{HashMap,BTreeMap};
-        use super::ToJson;
-
-        let array2 = Array(vec!(I64(1), I64(2)));
-        let array3 = Array(vec!(I64(1), I64(2), I64(3)));
-        let object = {
-            let mut tree_map = BTreeMap::new();
-            tree_map.insert("a".to_string(), U64(1));
-            tree_map.insert("b".to_string(), U64(2));
-            Object(tree_map)
-        };
-
-        assert_eq!(array2.to_json(), array2);
-        assert_eq!(object.to_json(), object);
-        assert_eq!(3_isize.to_json(), I64(3));
-        assert_eq!(4_i8.to_json(), I64(4));
-        assert_eq!(5_i16.to_json(), I64(5));
-        assert_eq!(6_i32.to_json(), I64(6));
-        assert_eq!(7_i64.to_json(), I64(7));
-        assert_eq!(8_usize.to_json(), U64(8));
-        assert_eq!(9_u8.to_json(), U64(9));
-        assert_eq!(10_u16.to_json(), U64(10));
-        assert_eq!(11_u32.to_json(), U64(11));
-        assert_eq!(12_u64.to_json(), U64(12));
-        assert_eq!(13.0_f32.to_json(), F64(13.0_f64));
-        assert_eq!(14.0_f64.to_json(), F64(14.0_f64));
-        assert_eq!(().to_json(), Null);
-        assert_eq!(f32::INFINITY.to_json(), Null);
-        assert_eq!(f64::NAN.to_json(), Null);
-        assert_eq!(true.to_json(), Boolean(true));
-        assert_eq!(false.to_json(), Boolean(false));
-        assert_eq!("abc".to_json(), String("abc".to_string()));
-        assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
-        assert_eq!((1, 2).to_json(), array2);
-        assert_eq!((1, 2, 3).to_json(), array3);
-        assert_eq!([1, 2].to_json(), array2);
-        assert_eq!((&[1, 2, 3]).to_json(), array3);
-        assert_eq!((vec![1, 2]).to_json(), array2);
-        assert_eq!(vec!(1, 2, 3).to_json(), array3);
-        let mut tree_map = BTreeMap::new();
-        tree_map.insert("a".to_string(), 1 as u32);
-        tree_map.insert("b".to_string(), 2);
-        assert_eq!(tree_map.to_json(), object);
-        let mut hash_map = HashMap::new();
-        hash_map.insert("a".to_string(), 1 as u32);
-        hash_map.insert("b".to_string(), 2);
-        assert_eq!(hash_map.to_json(), object);
-        assert_eq!(Some(15).to_json(), I64(15));
-        assert_eq!(Some(15 as u32).to_json(), U64(15));
-        assert_eq!(None::<isize>.to_json(), Null);
-    }
-
-    #[test]
-    fn test_encode_hashmap_with_arbitrary_key() {
-        use std::collections::HashMap;
-        #[derive(PartialEq, Eq, Hash, RustcEncodable)]
-        struct ArbitraryType(u32);
-        let mut hm: HashMap<ArbitraryType, bool> = HashMap::new();
-        hm.insert(ArbitraryType(1), true);
-        let mut mem_buf = string::String::new();
-        let mut encoder = Encoder::new(&mut mem_buf);
-        let result = hm.encode(&mut encoder);
-        match result.err().unwrap() {
-            EncoderError::BadHashmapKey => (),
-            _ => panic!("expected bad hash map key")
-        }
-    }
-
-    #[test]
-    fn test_encode_decode_phantom_data() {
-        use std::marker::PhantomData;
-
-        #[derive(Debug, RustcDecodable, RustcEncodable, Eq, PartialEq)]
-        struct Foo<P> {
-            phantom_data: PhantomData<P>
-        }
-
-        let f: Foo<u8> = Foo {
-            phantom_data: PhantomData
-        };
-        let s = super::encode(&f).unwrap();
-        let d: Foo<u8> = super::decode(&s).unwrap();
-        assert_eq!(f, d);
-    }
-
-    #[test]
-    fn test_bad_json_stack_depleted() {
-        use json;
-        #[derive(Debug, RustcDecodable)]
-        enum ChatEvent {
-            Variant(i32)
-        }
-        let serialized = "{\"variant\": \"Variant\", \"fields\": []}";
-        let r: Result<ChatEvent, _> = json::decode(serialized);
-        assert!(r.unwrap_err() == EOF);
-    }
-
-    #[test]
-    fn fixed_length_array() {
-        #[derive(Debug, RustcDecodable, RustcEncodable, Eq, PartialEq)]
-        struct Foo {
-            a: [u8; 1],
-            b: [i32; 2],
-            c: [u64; 3],
-        }
-        let f = Foo {
-            a: [0],
-            b: [1, 2],
-            c: [3, 4, 5],
-        };
-        let s = super::encode(&f).unwrap();
-        let d = super::decode(&s).unwrap();
-        assert_eq!(f, d);
-    }
-
-    #[test]
-    fn test_unexpected_token() {
-        match Json::from_str("{\"\":\"\",\"\":{\"\":\"\",\"\":[{\"\":\"\",}}}") {
-            Err(e) => assert_eq!(e, SyntaxError(InvalidSyntax, 1, 32)),
-            _ => ()
-        };
-    }
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/lib.rs
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Support code for encoding and decoding types.
-//!
-//! > **NOTE**: This crate is deprecated in favor of [`serde`]. No new feature
-//! > development will happen in this crate, although bug fixes proposed through
-//! > PRs will still be merged. It is very highly recommended by the Rust
-//! > Library Team that you use [`serde`], not this crate.
-//!
-//! [`serde`]: https://serde.rs
-//!
-//! # Usage
-//!
-//! This crate is [on crates.io](https://crates.io/crates/rustc-serialize) and
-//! can be used by adding `rustc-serialize` to the dependencies in your
-//! project's `Cargo.toml`.
-//!
-//! ```toml
-//! [dependencies]
-//! rustc-serialize = "0.3"
-//! ```
-//!
-//! and this to your crate root:
-//!
-//! ```rust
-//! extern crate rustc_serialize;
-//! ```
-
-#![cfg_attr(rustbuild, feature(staged_api, rustc_private))]
-#![cfg_attr(rustbuild, unstable(feature = "rustc_private", issue = "27812"))]
-
-#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
-       html_favicon_url = "https://www.rust-lang.org/favicon.ico",
-       html_root_url = "https://doc.rust-lang.org/rustc-serialize/")]
-#![cfg_attr(test, deny(warnings))]
-#![allow(trivial_numeric_casts)]
-#![cfg_attr(rust_build, feature(staged_api))]
-#![cfg_attr(rust_build, staged_api)]
-#![cfg_attr(rust_build,
-            unstable(feature = "rustc_private",
-                     reason = "use the crates.io `rustc-serialize` library instead"))]
-
-#[cfg(test)] extern crate rand;
-
-pub use self::serialize::{Decoder, Encoder, Decodable, Encodable,
-                          DecoderHelpers, EncoderHelpers};
-
-
-// Limit collections from allocating more than
-// 1 MB for calls to `with_capacity`.
-fn cap_capacity<T>(given_len: usize) -> usize {
-    use std::cmp::min;
-    use std::mem::size_of;
-    const PRE_ALLOCATE_CAP: usize = 0x100000;
-
-    match size_of::<T>() {
-        0 => min(given_len, PRE_ALLOCATE_CAP),
-        n => min(given_len, PRE_ALLOCATE_CAP / n)
-    }
-}
-
-mod serialize;
-mod collection_impls;
-
-pub mod base64;
-pub mod hex;
-pub mod json;
-
-mod rustc_serialize {
-    pub use serialize::*;
-}
deleted file mode 100644
--- a/third_party/rust/rustc-serialize/src/serialize.rs
+++ /dev/null
@@ -1,1671 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-//! Support code for encoding and decoding types.
-//!
-//! In order to allow extensibility in both what types can be encoded and how
-//! they are encoded, encoding and decoding are split into two part each. An
-//! implementation of the Encodable trait knows how to turn a specific type into
-//! a generic form, and then uses an implementation of the Encoder trait to turn
-//! this into concrete output (such as a JSON string). Decoder and Decodable do
-//! the same for decoding.
-
-/*
-Core encoding and decoding interfaces.
-*/
-
-use std::cell::{Cell, RefCell};
-use std::ffi::OsString;
-use std::path;
-use std::rc::Rc;
-use std::sync::Arc;
-use std::marker::PhantomData;
-use std::borrow::Cow;
-
-use cap_capacity;
-
-/// Trait for writing out an encoding when serializing.
-///
-/// This trait provides methods to encode basic types and generic forms of
-/// collections.  Implementations of `Encodable` use it to perform the actual
-/// encoding of a type.
-///
-/// It is unspecified what is done with the encoding - it could be stored in a
-/// variable, or written directly to a file, for example.
-///
-/// Encoders can expect to only have a single "root" method call made on this
-/// trait. Non-trivial types will call one of the collection-emitting methods,
-/// passing a function that may call other methods on the trait, but once the
-/// collection-emitting method has returned, encoding should be complete.
-pub trait Encoder {
-    /// The error type for method results.
-    type Error;
-
-    // Primitive types:
-    /// Emit a nil value.
-    ///
-    /// For example, this might be stored as the null keyword in JSON.
-    fn emit_nil(&mut self) -> Result<(), Self::Error>;
-
-    /// Emit a usize value.
-    fn emit_usize(&mut self, v: usize) -> Result<(), Self::Error>;
-
-    /// Emit a u64 value.
-    fn emit_u64(&mut self, v: u64) -> Result<(), Self::Error>;
-
-    /// Emit a u32 value.
-    fn emit_u32(&mut self, v: u32) -> Result<(), Self::Error>;
-
-    /// Emit a u16 value.
-    fn emit_u16(&mut self, v: u16) -> Result<(), Self::Error>;
-
-    /// Emit a u8 value.
-    fn emit_u8(&mut self, v: u8) -> Result<(), Self::Error>;
-
-    /// Emit a isize value.
-    fn emit_isize(&mut self, v: isize) -> Result<(), Self::Error>;
-
-    /// Emit a i64 value.
-    fn emit_i64(&mut self, v: i64) -> Result<(), Self::Error>;
-
-    /// Emit a i32 value.
-    fn emit_i32(&mut self, v: i32) -> Result<(), Self::Error>;
-
-    /// Emit a i16 value.
-    fn emit_i16(&mut self, v: i16) -> Result<(), Self::Error>;
-
-    /// Emit a i8 value.
-    fn emit_i8(&mut self, v: i8) -> Result<(), Self::Error>;
-
-    /// Emit a bool value.
-    ///
-    /// For example, this might be stored as the true and false keywords in
-    /// JSON.
-    fn emit_bool(&mut self, v: bool) -> Result<(), Self::Error>;
-
-    /// Emit a f64 value.
-    fn emit_f64(&mut self, v: f64) -> Result<(), Self::Error>;
-
-    /// Emit a f32 value.
-    fn emit_f32(&mut self, v: f32) -> Result<(), Self::Error>;
-
-    /// Emit a char value.
-    ///
-    /// Note that strings should be emitted using `emit_str`, not as a sequence
-    /// of `emit_char` calls.
-    fn emit_char(&mut self, v: char) -> Result<(), Self::Error>;
-
-    /// Emit a string value.
-    fn emit_str(&mut self, v: &str) -> Result<(), Self::Error>;
-
-    // Compound types:
-    /// Emit an enumeration value.
-    ///
-    /// * `name` indicates the enumeration type name.
-    /// * `f` is a function that will call `emit_enum_variant` or
-    ///   `emit_enum_struct_variant` as appropriate to write the actual value.
-    fn emit_enum<F>(&mut self, name: &str, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a enumeration variant value with no or unnamed data.
-    ///
-    /// This should only be called from a function passed to `emit_enum`.
-    /// Variants with named data should use `emit_enum_struct_variant`.
-    ///
-    /// * `v_name` is the variant name
-    /// * `v_id` is the numeric identifier for the variant.
-    /// * `len` is the number of data items associated with the variant.
-    /// * `f` is a function that will call `emit_enum_variant_arg` for each data
-    ///   item. It may not be called if len is 0.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Encodable;
-    /// use rustc_serialize::Encoder;
-    ///
-    /// enum Message {
-    ///     Quit,
-    ///     ChangeColor(i32, i32, i32),
-    /// }
-    ///
-    /// impl Encodable for Message {
-    ///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-    ///         s.emit_enum("Message", |s| {
-    ///             match *self {
-    ///                 Message::Quit => {
-    ///                     s.emit_enum_variant("Quit", 0, 0, |s| Ok(()))
-    ///                 }
-    ///                 Message::ChangeColor(r, g, b) => {
-    ///                     s.emit_enum_variant("ChangeColor", 1, 3, |s| {
-    ///                         try!(s.emit_enum_variant_arg(0, |s| {
-    ///                             s.emit_i32(r)
-    ///                         }));
-    ///                         try!(s.emit_enum_variant_arg(1, |s| {
-    ///                             s.emit_i32(g)
-    ///                         }));
-    ///                         try!(s.emit_enum_variant_arg(2, |s| {
-    ///                             s.emit_i32(b)
-    ///                         }));
-    ///                         Ok(())
-    ///                     })
-    ///                 }
-    ///             }
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn emit_enum_variant<F>(&mut self, v_name: &str,
-                            v_id: usize,
-                            len: usize,
-                            f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit an unnamed data item for an enumeration variant.
-    ///
-    /// This should only be called from a function passed to
-    /// `emit_enum_variant`.
-    ///
-    /// * `a_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the data object.
-    ///
-    /// Note that variant data items must be emitted in order - starting with
-    /// index `0` and finishing with index `len-1`.
-    fn emit_enum_variant_arg<F>(&mut self, a_idx: usize, f: F)
-                                -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a enumeration variant value with no or named data.
-    ///
-    /// This should only be called from a function passed to `emit_enum`.
-    /// Variants with unnamed data should use `emit_enum_variant`.
-    ///
-    /// * `v_name` is the variant name.
-    /// * `v_id` is the numeric identifier for the variant.
-    /// * `len` is the number of data items associated with the variant.
-    /// * `f` is a function that will call `emit_enum_struct_variant_field` for
-    ///   each data item. It may not be called if `len` is `0`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Encodable;
-    /// use rustc_serialize::Encoder;
-    ///
-    /// enum Message {
-    ///     Quit,
-    ///     Move { x: i32, y: i32 },
-    /// }
-    ///
-    /// impl Encodable for Message {
-    ///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-    ///         s.emit_enum("Message", |s| {
-    ///             match *self {
-    ///                 Message::Quit => {
-    ///                     s.emit_enum_struct_variant("Quit", 0, 0, |s| Ok(()))
-    ///                 }
-    ///                 Message::Move { x: x, y: y } => {
-    ///                     s.emit_enum_struct_variant("Move", 1, 2, |s| {
-    ///                         try!(s.emit_enum_struct_variant_field("x", 0, |s| {
-    ///                             s.emit_i32(x)
-    ///                         }));
-    ///                         try!(s.emit_enum_struct_variant_field("y", 1, |s| {
-    ///                             s.emit_i32(y)
-    ///                         }));
-    ///                         Ok(())
-    ///                     })
-    ///                 }
-    ///             }
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn emit_enum_struct_variant<F>(&mut self, v_name: &str,
-                                   v_id: usize,
-                                   len: usize,
-                                   f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a named data item for an enumeration variant.
-    ///
-    /// This should only be called from a function passed to
-    /// `emit_enum_struct_variant`.
-    ///
-    /// * `f_name` is the name of the data item field.
-    /// * `f_idx` is its (zero-based) index.
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the data object.
-    ///
-    /// Note that fields must be emitted in order - starting with index `0` and
-    /// finishing with index `len-1`.
-    fn emit_enum_struct_variant_field<F>(&mut self,
-                                         f_name: &str,
-                                         f_idx: usize,
-                                         f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a struct value.
-    ///
-    /// * `name` is the name of the struct.
-    /// * `len` is the number of members.
-    /// * `f` is a function that calls `emit_struct_field` for each member.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Encodable;
-    /// use rustc_serialize::Encoder;
-    ///
-    /// struct Point {
-    ///     x: i32,
-    ///     y: i32,
-    /// }
-    ///
-    /// impl Encodable for Point {
-    ///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-    ///         s.emit_struct("Point", 2, |s| {
-    ///             try!(s.emit_struct_field("x", 0, |s| {
-    ///                 s.emit_i32(self.x)
-    ///             }));
-    ///             try!(s.emit_struct_field("y", 1, |s| {
-    ///                 s.emit_i32(self.y)
-    ///             }));
-    ///             Ok(())
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn emit_struct<F>(&mut self, name: &str, len: usize, f: F)
-                      -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-    /// Emit a field item for a struct.
-    ///
-    /// This should only be called from a function passed to `emit_struct`.
-    ///
-    /// * `f_name` is the name of the data item field.
-    /// * `f_idx` is its (zero-based) index.
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the data object.
-    ///
-    /// Note that fields must be emitted in order - starting with index `0` and
-    /// finishing with index `len-1`.
-    fn emit_struct_field<F>(&mut self, f_name: &str, f_idx: usize, f: F)
-                            -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a tuple value.
-    ///
-    /// * `len` is the number of items in the tuple.
-    /// * `f` is a function that calls `emit_tuple_arg` for each member.
-    ///
-    /// Note that external `Encodable` implementations should not normally need
-    /// to use this method directly; it is meant for the use of this module's
-    /// own implementation of `Encodable` for tuples.
-    fn emit_tuple<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a data item for a tuple.
-    ///
-    /// This should only be called from a function passed to `emit_tuple`.
-    ///
-    /// * `idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the data object.
-    ///
-    /// Note that tuple items must be emitted in order - starting with index `0`
-    /// and finishing with index `len-1`.
-    fn emit_tuple_arg<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a tuple struct value.
-    ///
-    /// * `name` is the name of the tuple struct.
-    /// * `len` is the number of items in the tuple struct.
-    /// * `f` is a function that calls `emit_tuple_struct_arg` for each member.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Encodable;
-    /// use rustc_serialize::Encoder;
-    ///
-    /// struct Pair(i32,i32);
-    ///
-    /// impl Encodable for Pair {
-    ///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-    ///         let Pair(first,second) = *self;
-    ///         s.emit_tuple_struct("Pair", 2, |s| {
-    ///             try!(s.emit_tuple_arg(0, |s| {
-    ///                 s.emit_i32(first)
-    ///             }));
-    ///             try!(s.emit_tuple_arg(1, |s| {
-    ///                 s.emit_i32(second)
-    ///             }));
-    ///             Ok(())
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn emit_tuple_struct<F>(&mut self, name: &str, len: usize, f: F)
-                            -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a data item for a tuple struct.
-    ///
-    /// This should only be called from a function passed to
-    /// `emit_tuple_struct`.
-    ///
-    /// * `f_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the data object.
-    ///
-    /// Note that tuple items must be emitted in order - starting with index `0`
-    /// and finishing with index `len-1`.
-    fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F)
-                                -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    // Specialized types:
-    /// Emit an optional value.
-    ///
-    /// `f` is a function that will call either `emit_option_none` or
-    /// `emit_option_some` as appropriate.
-    ///
-    /// This method allows encoders to handle `Option<T>` values specially,
-    /// rather than using the generic enum methods, because many encoding
-    /// formats have a built-in "optional" concept.
-    ///
-    /// Note that external `Encodable` implementations should not normally need
-    /// to use this method directly; it is meant for the use of this module's
-    /// own implementation of `Encodable` for `Option<T>`.
-    fn emit_option<F>(&mut self, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit the `None` optional value.
-    ///
-    /// This should only be called from a function passed to `emit_option`.
-    fn emit_option_none(&mut self) -> Result<(), Self::Error>;
-
-    /// Emit the `Some(x)` optional value.
-    ///
-    /// `f` is a function that will call the appropriate emit method to encode
-    /// the data object.
-    ///
-    /// This should only be called from a function passed to `emit_option`.
-    fn emit_option_some<F>(&mut self, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit a sequence of values.
-    ///
-    /// This should be used for both array-like ordered sequences and set-like
-    /// unordered ones.
-    ///
-    /// * `len` is the number of values in the sequence.
-    /// * `f` is a function that will call `emit_seq_elt` for each value in the
-    ///   sequence.
-    fn emit_seq<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit an element in a sequence.
-    ///
-    /// This should only be called from a function passed to `emit_seq`.
-    ///
-    /// * `idx` is the (zero-based) index of the value in the sequence.
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the data object.
-    ///
-    /// Note that sequence elements must be emitted in order - starting with
-    /// index `0` and finishing with index `len-1`.
-    fn emit_seq_elt<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit an associative container (map).
-    ///
-    /// * `len` is the number of entries in the map.
-    /// * `f` is a function that will call `emit_map_elt_key` and
-    ///   `emit_map_elt_val` for each entry in the map.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Encodable;
-    /// use rustc_serialize::Encoder;
-    ///
-    /// struct SimpleMap<K,V> {
-    ///     entries: Vec<(K,V)>,
-    /// }
-    ///
-    /// impl<K:Encodable,V:Encodable> Encodable for SimpleMap<K,V> {
-    ///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-    ///         s.emit_map(self.entries.len(), |s| {
-    ///             for (i, e) in self.entries.iter().enumerate() {
-    ///                 let (ref k, ref v) = *e;
-    ///                 try!(s.emit_map_elt_key(i, |s| k.encode(s)));
-    ///                 try!(s.emit_map_elt_val(i, |s| v.encode(s)));
-    ///             }
-    ///             Ok(())
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn emit_map<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit the key for an entry in a map.
-    ///
-    /// This should only be called from a function passed to `emit_map`.
-    ///
-    /// * `idx` is the (zero-based) index of the entry in the map
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the key.
-    ///
-    /// Note that map entries must be emitted in order - starting with index `0`
-    /// and finishing with index `len-1` - and for each entry, the key should be
-    /// emitted followed immediately by the value.
-    fn emit_map_elt_key<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-
-    /// Emit the value for an entry in a map.
-    ///
-    /// This should only be called from a function passed to `emit_map`.
-    ///
-    /// * `idx` is the (zero-based) index of the entry in the map
-    /// * `f` is a function that will call the appropriate emit method to encode
-    ///   the value.
-    ///
-    /// Note that map entries must be emitted in order - starting with index `0`
-    /// and finishing with index `len-1` - and for each entry, the key should be
-    /// emitted followed immediately by the value.
-    fn emit_map_elt_val<F>(&mut self, idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>;
-}
-
-/// Trait for reading in an encoding for deserialization.
-///
-/// This trait provides methods to decode basic types and generic forms of
-/// collections.  Implementations of `Decodable` use it to perform the actual
-/// decoding of a type.
-///
-/// Note that, as is typical with deserialization, the design of this API
-/// assumes you know in advance the form of the data you are decoding (ie: what
-/// type is encoded).
-///
-/// Decoders can expect to only have a single "root" method call made on this
-/// trait. Non-trivial types will call one of the collection-reading methods,
-/// passing a function that may call other methods on the trait, but once the
-/// collection-reading method has returned, decoding should be complete.
-pub trait Decoder {
-    /// The error type for method results.
-    type Error;
-
-    // Primitive types:
-    /// Read a nil value.
-    fn read_nil(&mut self) -> Result<(), Self::Error>;
-
-    /// Read a usize value.
-    fn read_usize(&mut self) -> Result<usize, Self::Error>;
-
-    /// Read a u64 value.
-    fn read_u64(&mut self) -> Result<u64, Self::Error>;
-
-    /// Read a u32 value.
-    fn read_u32(&mut self) -> Result<u32, Self::Error>;
-
-    /// Read a u16 value.
-    fn read_u16(&mut self) -> Result<u16, Self::Error>;
-
-    /// Read a u8 value.
-    fn read_u8(&mut self) -> Result<u8, Self::Error>;
-
-    /// Read a isize value.
-    fn read_isize(&mut self) -> Result<isize, Self::Error>;
-
-    /// Read a i64 value.
-    fn read_i64(&mut self) -> Result<i64, Self::Error>;
-
-    /// Read a i32 value.
-    fn read_i32(&mut self) -> Result<i32, Self::Error>;
-
-    /// Read a i16 value.
-    fn read_i16(&mut self) -> Result<i16, Self::Error>;
-
-    /// Read a i8 value.
-    fn read_i8(&mut self) -> Result<i8, Self::Error>;
-
-    /// Read a bool value.
-    fn read_bool(&mut self) -> Result<bool, Self::Error>;
-
-    /// Read a f64 value.
-    fn read_f64(&mut self) -> Result<f64, Self::Error>;
-
-    /// Read a f32 value.
-    fn read_f32(&mut self) -> Result<f32, Self::Error>;
-
-    /// Read a char value.
-    fn read_char(&mut self) -> Result<char, Self::Error>;
-
-    /// Read a string value.
-    fn read_str(&mut self) -> Result<String, Self::Error>;
-
-    // Compound types:
-    /// Read an enumeration value.
-    ///
-    /// * `name` indicates the enumeration type name. It may be used to
-    ///   sanity-check the data being read.
-    /// * `f` is a function that will call `read_enum_variant` (or
-    ///   `read_enum_struct_variant`) to read the actual value.
-    fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read an enumeration value.
-    ///
-    /// * `names` is a list of the enumeration variant names.
-    /// * `f` is a function that will call `read_enum_variant_arg` or
-    ///   `read_enum_struct_variant_field` as appropriate to read the
-    ///   associated values. It will be passed the index into `names` for the
-    ///   variant that is encoded.
-    fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F)
-                               -> Result<T, Self::Error>
-        where F: FnMut(&mut Self, usize) -> Result<T, Self::Error>;
-
-    /// Read an unnamed data item for an enumeration variant.
-    ///
-    /// This should only be called from a function passed to `read_enum_variant`
-    /// or `read_enum_struct_variant`, and only when the index provided to that
-    /// function indicates that the variant has associated unnamed data. It
-    /// should be called once for each associated data item.
-    ///
-    /// * `a_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate read method to deocde
-    ///   the data object.
-    ///
-    /// Note that variant data items must be read in order - starting with index
-    /// `0` and finishing with index `len-1`. Implementations may use `a_idx`,
-    /// the call order or both to select the correct data to decode.
-    fn read_enum_variant_arg<T, F>(&mut self, a_idx: usize, f: F)
-                                   -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read an enumeration value.
-    ///
-    /// This is identical to `read_enum_variant`, and is only provided for
-    /// symmetry with the `Encoder` API.
-    fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F)
-                                      -> Result<T, Self::Error>
-        where F: FnMut(&mut Self, usize) -> Result<T, Self::Error>;
-
-    /// Read a named data item for an enumeration variant.
-    ///
-    /// This should only be called from a function passed to `read_enum_variant`
-    /// or `read_enum_struct_variant`, and only when the index provided to that
-    /// function indicates that the variant has associated named data. It should
-    /// be called once for each associated field.
-    ///
-    /// * `f_name` is the name of the field.
-    /// * `f_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate read method to deocde
-    ///   the data object.
-    ///
-    /// Note that fields must be read in order - starting with index `0` and
-    /// finishing with index `len-1`. Implementations may use `f_idx`, `f_name`,
-    /// the call order or any combination to choose the correct data to decode,
-    /// and may (but are not required to) return an error if these are
-    /// inconsistent.
-    fn read_enum_struct_variant_field<T, F>(&mut self,
-                                            f_name: &str,
-                                            f_idx: usize,
-                                            f: F)
-                                            -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read an struct value.
-    ///
-    /// * `s_name` indicates the struct type name. It may be used to
-    ///   sanity-check the data being read.
-    /// * `len` indicates the number of fields in the struct.
-    /// * `f` is a function that will call `read_struct_field` for each field in
-    ///   the struct.
-    fn read_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
-                         -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read a field for a struct value.
-    ///
-    /// This should only be called from a function passed to `read_struct`. It
-    /// should be called once for each associated field.
-    ///
-    /// * `f_name` is the name of the field.
-    /// * `f_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate read method to deocde
-    ///   the data object.
-    ///
-    /// Note that fields must be read in order - starting with index `0` and
-    /// finishing with index `len-1`. Implementations may use `f_idx`, `f_name`,
-    /// the call order or any combination to choose the correct data to decode,
-    /// and may (but are not required to) return an error if these are
-    /// inconsistent.
-    fn read_struct_field<T, F>(&mut self,
-                               f_name: &str,
-                               f_idx: usize,
-                               f: F)
-                               -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read a tuple value.
-    ///
-    /// * `len` is the number of items in the tuple.
-    /// * `f` is a function that will call `read_tuple_arg` for each item in the
-    ///   tuple.
-    ///
-    /// Note that external `Decodable` implementations should not normally need
-    /// to use this method directly; it is meant for the use of this module's
-    /// own implementation of `Decodable` for tuples.
-    fn read_tuple<T, F>(&mut self, len: usize, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read a data item for a tuple.
-    ///
-    /// This should only be called from a function passed to `read_tuple`.
-    ///
-    /// * `a_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate read method to encode
-    ///   the data object.
-    ///
-    /// Note that tuple items must be read in order - starting with index `0`
-    /// and finishing with index `len-1`.
-    fn read_tuple_arg<T, F>(&mut self, a_idx: usize, f: F)
-                            -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read a tuple struct value.
-    ///
-    /// * `s_name` is the name of the tuple struct.
-    /// * `len` is the number of items in the tuple struct.
-    /// * `f` is a function that calls `read_tuple_struct_arg` for each member.
-    fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
-                               -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read a data item for a tuple struct.
-    ///
-    /// This should only be called from a function passed to
-    /// `read_tuple_struct`.
-    ///
-    /// * `a_idx` is the (zero-based) index of the data item.
-    /// * `f` is a function that will call the appropriate read method to encode
-    ///   the data object.
-    ///
-    /// Note that tuple struct items must be read in order - starting with index
-    /// `0` and finishing with index `len-1`.
-    fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F)
-                                   -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    // Specialized types:
-    /// Read an optional value.
-    ///
-    /// `f` is a function that will will be passed be passed `false` if the
-    /// value is unset, and `true` if it is set. If the function is passed
-    /// `true`, it will call the appropriate read methods to read the associated
-    /// data type.
-    ///
-    /// This method allows decoders to handle `Option<T>` values specially,
-    /// rather than using the generic enum methods, because many encoding
-    /// formats have a built-in "optional" concept.
-    ///
-    /// Note that external `Decodable` implementations should not normally need
-    /// to use this method directly; it is meant for the use of this module's
-    /// own implementation of `Decodable` for `Option<T>`.
-    fn read_option<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-        where F: FnMut(&mut Self, bool) -> Result<T, Self::Error>;
-
-    /// Read a sequence of values.
-    ///
-    /// This should be used for both array-like ordered sequences and set-like
-    /// unordered ones.
-    ///
-    /// * `f` is a function that will be passed the length of the sequence, and
-    ///   will call `read_seq_elt` for each value in the sequence.
-    fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>;
-
-    /// Read an element in the sequence.
-    ///
-    /// This should only be called from a function passed to `read_seq`.
-    ///
-    /// * `idx` is the (zero-based) index of the value in the sequence.
-    /// * `f` is a function that will call the appropriate read method to decode
-    ///   the data object.
-    ///
-    /// Note that sequence elements must be read in order - starting with index
-    /// `0` and finishing with index `len-1`.
-    fn read_seq_elt<T, F>(&mut self, idx: usize, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read an associative container (map).
-    ///
-    /// * `f` is a function that will be passed the number of entries in the
-    ///   map, and will call `read_map_elt_key` and `read_map_elt_val` to decode
-    ///   each entry.
-    fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>;
-
-    /// Read the key for an entry in a map.
-    ///
-    /// This should only be called from a function passed to `read_map`.
-    ///
-    /// * `idx` is the (zero-based) index of the entry in the map
-    /// * `f` is a function that will call the appropriate read method to decode
-    ///   the key.
-    ///
-    /// Note that map entries must be read in order - starting with index `0`
-    /// and finishing with index `len-1` - and for each entry, the key should be
-    /// read followed immediately by the value.
-    fn read_map_elt_key<T, F>(&mut self, idx: usize, f: F)
-                              -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    /// Read the value for an entry in a map.
-    ///
-    /// This should only be called from a function passed to `read_map`.
-    ///
-    /// * `idx` is the (zero-based) index of the entry in the map
-    /// * `f` is a function that will call the appropriate read method to decode
-    ///   the value.
-    ///
-    /// Note that map entries must be read in order - starting with index `0`
-    /// and finishing with index `len-1` - and for each entry, the key should be
-    /// read followed immediately by the value.
-    fn read_map_elt_val<T, F>(&mut self, idx: usize, f: F)
-                              -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>;
-
-    // Failure
-    /// Record a decoding error.
-    ///
-    /// This allows `Decodable` implementations to report an error using a
-    /// `Decoder` implementation's error type when inconsistent data is read.
-    /// For example, when reading a fixed-length array and the wrong length is
-    /// given by `read_seq`.
-    fn error(&mut self, err: &str) -> Self::Error;
-}
-
-/// Trait for serializing a type.
-///
-/// This can be implemented for custom data types to allow them to be encoded
-/// with `Encoder` implementations. Most of Rust's built-in or standard data
-/// types (like `i32` and `Vec<T>`) have `Encodable` implementations provided by
-/// this module.
-///
-/// Note that, in general, you should let the compiler implement this for you by
-/// using the `derive(RustcEncodable)` attribute.
-///
-/// # Examples
-///
-/// ```rust
-/// extern crate rustc_serialize;
-///
-/// #[derive(RustcEncodable)]
-/// struct Point {
-///     x: i32,
-///     y: i32,
-/// }
-/// # fn main() {}
-/// ```
-///
-/// This generates code equivalent to:
-///
-/// ```rust
-/// extern crate rustc_serialize;
-/// use rustc_serialize::Encodable;
-/// use rustc_serialize::Encoder;
-///
-/// struct Point {
-///     x: i32,
-///     y: i32,
-/// }
-///
-/// impl Encodable for Point {
-///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-///         s.emit_struct("Point", 2, |s| {
-///             try!(s.emit_struct_field("x", 0, |s| {
-///                 s.emit_i32(self.x)
-///             }));
-///             try!(s.emit_struct_field("y", 1, |s| {
-///                 s.emit_i32(self.y)
-///             }));
-///             Ok(())
-///         })
-///     }
-/// }
-/// # fn main() {}
-/// ```
-pub trait Encodable {
-    /// Serialize a value using an `Encoder`.
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error>;
-}
-
-/// Trait for deserializing a type.
-///
-/// This can be implemented for custom data types to allow them to be decoded
-/// with `Decoder` implementations. Most of Rust's built-in or standard data
-/// types (like `i32` and `Vec<T>`) have `Decodable` implementations provided by
-/// this module.
-///
-/// Note that, in general, you should let the compiler implement this for you by
-/// using the `derive(RustcDecodable)` attribute.
-///
-/// # Examples
-///
-/// ```rust
-/// extern crate rustc_serialize;
-///
-/// #[derive(RustcDecodable)]
-/// struct Point {
-///     x: i32,
-///     y: i32,
-/// }
-/// # fn main() {}
-/// ```
-///
-/// This generates code equivalent to:
-///
-/// ```rust
-/// extern crate rustc_serialize;
-/// use rustc_serialize::Decodable;
-/// use rustc_serialize::Decoder;
-///
-/// struct Point {
-///     x: i32,
-///     y: i32,
-/// }
-///
-/// impl Decodable for Point {
-///     fn decode<D: Decoder>(d: &mut D) -> Result<Point, D::Error> {
-///         d.read_struct("Point", 2, |d| {
-///             let x = try!(d.read_struct_field("x", 0, |d| { d.read_i32() }));
-///             let y = try!(d.read_struct_field("y", 1, |d| { d.read_i32() }));
-///             Ok(Point{ x: x, y: y })
-///         })
-///     }
-/// }
-/// # fn main() {}
-/// ```
-pub trait Decodable: Sized {
-    /// Deserialize a value using a `Decoder`.
-    fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error>;
-}
-
-impl Encodable for usize {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_usize(*self)
-    }
-}
-
-impl Decodable for usize {
-    fn decode<D: Decoder>(d: &mut D) -> Result<usize, D::Error> {
-        d.read_usize()
-    }
-}
-
-impl Encodable for u8 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_u8(*self)
-    }
-}
-
-impl Decodable for u8 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<u8, D::Error> {
-        d.read_u8()
-    }
-}
-
-impl Encodable for u16 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_u16(*self)
-    }
-}
-
-impl Decodable for u16 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<u16, D::Error> {
-        d.read_u16()
-    }
-}
-
-impl Encodable for u32 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_u32(*self)
-    }
-}
-
-impl Decodable for u32 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<u32, D::Error> {
-        d.read_u32()
-    }
-}
-
-impl Encodable for u64 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_u64(*self)
-    }
-}
-
-impl Decodable for u64 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<u64, D::Error> {
-        d.read_u64()
-    }
-}
-
-impl Encodable for isize {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_isize(*self)
-    }
-}
-
-impl Decodable for isize {
-    fn decode<D: Decoder>(d: &mut D) -> Result<isize, D::Error> {
-        d.read_isize()
-    }
-}
-
-impl Encodable for i8 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_i8(*self)
-    }
-}
-
-impl Decodable for i8 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<i8, D::Error> {
-        d.read_i8()
-    }
-}
-
-impl Encodable for i16 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_i16(*self)
-    }
-}
-
-impl Decodable for i16 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<i16, D::Error> {
-        d.read_i16()
-    }
-}
-
-impl Encodable for i32 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_i32(*self)
-    }
-}
-
-impl Decodable for i32 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<i32, D::Error> {
-        d.read_i32()
-    }
-}
-
-impl Encodable for i64 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_i64(*self)
-    }
-}
-
-impl Decodable for i64 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<i64, D::Error> {
-        d.read_i64()
-    }
-}
-
-impl Encodable for str {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_str(self)
-    }
-}
-
-impl Encodable for String {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_str(self)
-    }
-}
-
-impl Decodable for String {
-    fn decode<D: Decoder>(d: &mut D) -> Result<String, D::Error> {
-        d.read_str()
-    }
-}
-
-impl Encodable for f32 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_f32(*self)
-    }
-}
-
-impl Decodable for f32 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<f32, D::Error> {
-        d.read_f32()
-    }
-}
-
-impl Encodable for f64 {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_f64(*self)
-    }
-}
-
-impl Decodable for f64 {
-    fn decode<D: Decoder>(d: &mut D) -> Result<f64, D::Error> {
-        d.read_f64()
-    }
-}
-
-impl Encodable for bool {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_bool(*self)
-    }
-}
-
-impl Decodable for bool {
-    fn decode<D: Decoder>(d: &mut D) -> Result<bool, D::Error> {
-        d.read_bool()
-    }
-}
-
-impl Encodable for char {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_char(*self)
-    }
-}
-
-impl Decodable for char {
-    fn decode<D: Decoder>(d: &mut D) -> Result<char, D::Error> {
-        d.read_char()
-    }
-}
-
-impl Encodable for () {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_nil()
-    }
-}
-
-impl Decodable for () {
-    fn decode<D: Decoder>(d: &mut D) -> Result<(), D::Error> {
-        d.read_nil()
-    }
-}
-
-impl<'a, T: ?Sized + Encodable> Encodable for &'a T {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (**self).encode(s)
-    }
-}
-
-impl<T: ?Sized + Encodable> Encodable for Box<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (**self).encode(s)
-    }
-}
-
-impl< T: Decodable> Decodable for Box<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Box<T>, D::Error> {
-        Ok(Box::new(try!(Decodable::decode(d))))
-    }
-}
-
-impl< T: Decodable> Decodable for Box<[T]> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Box<[T]>, D::Error> {
-        let v: Vec<T> = try!(Decodable::decode(d));
-        Ok(v.into_boxed_slice())
-    }
-}
-
-impl<T:Encodable> Encodable for Rc<T> {
-    #[inline]
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (**self).encode(s)
-    }
-}
-
-impl<T:Decodable> Decodable for Rc<T> {
-    #[inline]
-    fn decode<D: Decoder>(d: &mut D) -> Result<Rc<T>, D::Error> {
-        Ok(Rc::new(try!(Decodable::decode(d))))
-    }
-}
-
-impl<'a, T:Encodable + ToOwned + ?Sized> Encodable for Cow<'a, T> {
-    #[inline]
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (**self).encode(s)
-    }
-}
-
-impl<'a, T: ?Sized> Decodable for Cow<'a, T>
-    where T: ToOwned, T::Owned: Decodable
-{
-    #[inline]
-    fn decode<D: Decoder>(d: &mut D) -> Result<Cow<'static, T>, D::Error> {
-        Ok(Cow::Owned(try!(Decodable::decode(d))))
-    }
-}
-
-impl<T:Encodable> Encodable for [T] {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_seq(self.len(), |s| {
-            for (i, e) in self.iter().enumerate() {
-                try!(s.emit_seq_elt(i, |s| e.encode(s)))
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<T:Encodable> Encodable for Vec<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_seq(self.len(), |s| {
-            for (i, e) in self.iter().enumerate() {
-                try!(s.emit_seq_elt(i, |s| e.encode(s)))
-            }
-            Ok(())
-        })
-    }
-}
-
-impl<T:Decodable> Decodable for Vec<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Vec<T>, D::Error> {
-        d.read_seq(|d, len| {
-            let mut v = Vec::with_capacity(cap_capacity::<T>(len));
-            for i in 0..len {
-                v.push(try!(d.read_seq_elt(i, |d| Decodable::decode(d))));
-            }
-            Ok(v)
-        })
-    }
-}
-
-impl<T:Encodable> Encodable for Option<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_option(|s| {
-            match *self {
-                None => s.emit_option_none(),
-                Some(ref v) => s.emit_option_some(|s| v.encode(s)),
-            }
-        })
-    }
-}
-
-impl<T:Decodable> Decodable for Option<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Option<T>, D::Error> {
-        d.read_option(|d, b| {
-            if b {
-                Ok(Some(try!(Decodable::decode(d))))
-            } else {
-                Ok(None)
-            }
-        })
-    }
-}
-
-impl<T:Encodable, E:Encodable> Encodable for Result<T, E> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_enum("Result", |s| {
-            match *self {
-                Ok(ref v) => {
-                    s.emit_enum_variant("Ok", 0, 1, |s| {
-                        try!(s.emit_enum_variant_arg(0, |s| {
-                            v.encode(s)
-                        }));
-                        Ok(())
-                    })
-                }
-                Err(ref v) => {
-                    s.emit_enum_variant("Err", 1, 1, |s| {
-                        try!(s.emit_enum_variant_arg(0, |s| {
-                            v.encode(s)
-                        }));
-                        Ok(())
-                    })
-                }
-            }
-        })
-    }
-}
-
-impl<T: Decodable, E: Decodable> Decodable for Result<T, E> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Result<T, E>, D::Error> {
-        d.read_enum("Result", |d| {
-            d.read_enum_variant(&["Ok", "Err"], |d, idx| {
-                match idx {
-                    0 => {
-                        d.read_enum_variant_arg(0, |d| {
-                            T::decode(d)
-                        }).map(|v| Ok(v))
-                    }
-                    1 => {
-                        d.read_enum_variant_arg(0, |d| {
-                            E::decode(d)
-                        }).map(|v| Err(v))
-                    }
-                    _ => panic!("Internal error"),
-                }
-            })
-        })
-    }
-}
-
-impl<T> Encodable for PhantomData<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_nil()
-    }
-}
-
-impl<T> Decodable for PhantomData<T> {
-    fn decode<D: Decoder>(_d: &mut D) -> Result<PhantomData<T>, D::Error> {
-        Ok(PhantomData)
-    }
-}
-
-macro_rules! peel {
-    ($name:ident, $($other:ident,)*) => (tuple! { $($other,)* })
-}
-
-/// Evaluates to the number of identifiers passed to it, for example:
-/// `count_idents!(a, b, c) == 3
-macro_rules! count_idents {
-    () => { 0 };
-    ($_i:ident, $($rest:ident,)*) => { 1 + count_idents!($($rest,)*) }
-}
-
-macro_rules! tuple {
-    () => ();
-    ( $($name:ident,)+ ) => (
-        impl<$($name:Decodable),*> Decodable for ($($name,)*) {
-            fn decode<D: Decoder>(d: &mut D) -> Result<($($name,)*), D::Error> {
-                let len: usize = count_idents!($($name,)*);
-                d.read_tuple(len, |d| {
-                    let mut i = 0;
-                    let ret = ($(try!(d.read_tuple_arg({ i+=1; i-1 },
-                                                       |d| -> Result<$name,D::Error> {
-                        Decodable::decode(d)
-                    })),)*);
-                    return Ok(ret);
-                })
-            }
-        }
-        impl<$($name:Encodable),*> Encodable for ($($name,)*) {
-            #[allow(non_snake_case)]
-            fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-                let ($(ref $name,)*) = *self;
-                let mut n = 0;
-                $(let $name = $name; n += 1;)*
-                s.emit_tuple(n, |s| {
-                    let mut i = 0;
-                    $(try!(s.emit_tuple_arg({ i+=1; i-1 }, |s| $name.encode(s)));)*
-                    Ok(())
-                })
-            }
-        }
-        peel! { $($name,)* }
-    )
-}
-
-tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
-
-macro_rules! array {
-    () => ();
-    ($len:expr, $($idx:expr,)*) => {
-        impl<T:Decodable> Decodable for [T; $len] {
-            fn decode<D: Decoder>(d: &mut D) -> Result<[T; $len], D::Error> {
-                d.read_seq(|d, len| {
-                    if len != $len {
-                        return Err(d.error("wrong array length"));
-                    }
-                    Ok([$(
-                        try!(d.read_seq_elt($len - $idx - 1,
-                                            |d| Decodable::decode(d)))
-                    ),*])
-                })
-            }
-        }
-
-        impl<T:Encodable> Encodable for [T; $len] {
-            fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-                s.emit_seq($len, |s| {
-                    for i in 0..$len {
-                        try!(s.emit_seq_elt(i, |s| self[i].encode(s)));
-                    }
-                    Ok(())
-                })
-            }
-        }
-        array! { $($idx,)* }
-    }
-}
-
-array! {
-    32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,
-    15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,
-}
-
-impl Encodable for path::Path {
-    #[cfg(target_os = "redox")]
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        self.as_os_str().to_str().unwrap().encode(e)
-    }
-    #[cfg(unix)]
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        use std::os::unix::prelude::*;
-        self.as_os_str().as_bytes().encode(e)
-    }
-    #[cfg(windows)]
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        use std::os::windows::prelude::*;
-        let v = self.as_os_str().encode_wide().collect::<Vec<_>>();
-        v.encode(e)
-    }
-}
-
-impl Encodable for path::PathBuf {
-    fn encode<S: Encoder>(&self, e: &mut S) -> Result<(), S::Error> {
-        (**self).encode(e)
-    }
-}
-
-impl Decodable for path::PathBuf {
-    #[cfg(target_os = "redox")]
-    fn decode<D: Decoder>(d: &mut D) -> Result<path::PathBuf, D::Error> {
-        let string: String = try!(Decodable::decode(d));
-        let s: OsString = OsString::from(string);
-        let mut p = path::PathBuf::new();
-        p.push(s);
-        Ok(p)
-    }
-    #[cfg(unix)]
-    fn decode<D: Decoder>(d: &mut D) -> Result<path::PathBuf, D::Error> {
-        use std::os::unix::prelude::*;
-        let bytes: Vec<u8> = try!(Decodable::decode(d));
-        let s: OsString = OsStringExt::from_vec(bytes);
-        let mut p = path::PathBuf::new();
-        p.push(s);
-        Ok(p)
-    }
-    #[cfg(windows)]
-    fn decode<D: Decoder>(d: &mut D) -> Result<path::PathBuf, D::Error> {
-        use std::os::windows::prelude::*;
-        let bytes: Vec<u16> = try!(Decodable::decode(d));
-        let s: OsString = OsStringExt::from_wide(&bytes);
-        let mut p = path::PathBuf::new();
-        p.push(s);
-        Ok(p)
-    }
-}
-
-impl<T: Encodable + Copy> Encodable for Cell<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        self.get().encode(s)
-    }
-}
-
-impl<T: Decodable + Copy> Decodable for Cell<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Cell<T>, D::Error> {
-        Ok(Cell::new(try!(Decodable::decode(d))))
-    }
-}
-
-// FIXME: #15036
-// Should use `try_borrow`, returning a
-// `encoder.error("attempting to Encode borrowed RefCell")`
-// from `encode` when `try_borrow` returns `None`.
-
-impl<T: Encodable> Encodable for RefCell<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        self.borrow().encode(s)
-    }
-}
-
-impl<T: Decodable> Decodable for RefCell<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<RefCell<T>, D::Error> {
-        Ok(RefCell::new(try!(Decodable::decode(d))))
-    }
-}
-
-impl<T:Encodable> Encodable for Arc<T> {
-    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (**self).encode(s)
-    }
-}
-
-impl<T:Decodable+Send+Sync> Decodable for Arc<T> {
-    fn decode<D: Decoder>(d: &mut D) -> Result<Arc<T>, D::Error> {
-        Ok(Arc::new(try!(Decodable::decode(d))))
-    }
-}
-
-// ___________________________________________________________________________
-// Helper routines
-
-/// Trait with helper functions for implementing `Encodable`.
-///
-/// This trait is implemented for everything that implements `Encoder`.
-/// `Encodable` implementations can make use of it to make their implementations
-/// easier.
-pub trait EncoderHelpers: Encoder {
-    /// Emit a vector as a sequence.
-    ///
-    /// Storing sequences as vectors is a common pattern. This method makes
-    /// encoding such sequences easier by wrapping the calls to
-    /// `Encoder::emit_seq` and `Encoder::emit_seq_elt`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Encodable;
-    /// use rustc_serialize::Encoder;
-    /// use rustc_serialize::EncoderHelpers;
-    ///
-    /// struct NumberSequence {
-    ///     elements: Vec<i32>,
-    /// }
-    ///
-    /// impl Encodable for NumberSequence {
-    ///     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-    ///         s.emit_struct("NumberSequence", 1, |s| {
-    ///             s.emit_struct_field("elements", 0, |s| {
-    ///                 s.emit_from_vec(&self.elements, |s,e| {
-    ///                     s.emit_i32(*e)
-    ///                 })
-    ///             })
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn emit_from_vec<T, F>(&mut self, v: &[T], f: F)
-                           -> Result<(), <Self as Encoder>::Error>
-        where F: FnMut(&mut Self, &T) -> Result<(), <Self as Encoder>::Error>;
-}
-
-impl<S:Encoder> EncoderHelpers for S {
-    fn emit_from_vec<T, F>(&mut self, v: &[T], mut f: F) -> Result<(), S::Error> where
-        F: FnMut(&mut S, &T) -> Result<(), S::Error>,
-    {
-        self.emit_seq(v.len(), |this| {
-            for (i, e) in v.iter().enumerate() {
-                try!(this.emit_seq_elt(i, |this| {
-                    f(this, e)
-                }));
-            }
-            Ok(())
-        })
-    }
-}
-
-/// Trait with helper functions for implementing `Decodable`.
-///
-/// This trait is implemented for everything that implements `Decoder`.
-/// `Decodable` implementations can make use of it to make their implementations
-/// easier.
-pub trait DecoderHelpers: Decoder {
-    /// Read a sequence into a vector.
-    ///
-    /// Storing sequences as vectors is a common pattern. This method makes
-    /// deserializing such sequences easier by wrapping the calls to
-    /// `Decoder::read_seq` and `Decoder::read_seq_elt`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use rustc_serialize::Decodable;
-    /// use rustc_serialize::Decoder;
-    /// use rustc_serialize::DecoderHelpers;
-    ///
-    /// struct NumberSequence {
-    ///     elements: Vec<i32>,
-    /// }
-    ///
-    /// impl Decodable for NumberSequence {
-    ///     fn decode<D: Decoder>(d: &mut D) -> Result<NumberSequence, D::Error> {
-    ///         d.read_struct("NumberSequence", 2, |d| {
-    ///             Ok(NumberSequence{
-    ///                 elements: try!(d.read_struct_field("elements", 0, |d| {
-    ///                     d.read_to_vec(|d| { d.read_i32() })
-    ///                 }))
-    ///             })
-    ///         })
-    ///     }
-    /// }
-    /// ```
-    fn read_to_vec<T, F>(&mut self, f: F)
-                         -> Result<Vec<T>, <Self as Decoder>::Error> where
-        F: FnMut(&mut Self) -> Result<T, <Self as Decoder>::Error>;
-}
-
-impl<D: Decoder> DecoderHelpers for D {
-    fn read_to_vec<T, F>(&mut self, mut f: F) -> Result<Vec<T>, D::Error> where F:
-        FnMut(&mut D) -> Result<T, D::Error>,
-    {
-        self.read_seq(|this, len| {
-            let mut v = Vec::with_capacity(cap_capacity::<T>(len));
-            for i in 0..len {
-                v.push(try!(this.read_seq_elt(i, |this| f(this))));
-            }
-            Ok(v)
-        })
-    }
-}
-
-#[test]
-#[allow(unused_variables)]
-fn capacity_rules() {
-    use std::usize::MAX;
-    use std::collections::{HashMap, HashSet};
-
-    struct MyDecoder;
-    impl Decoder for MyDecoder {
-        type Error = ();
-
-        // Primitive types:
-        fn read_nil(&mut self) -> Result<(), Self::Error> { Err(()) }
-        fn read_usize(&mut self) -> Result<usize, Self::Error> { Err(()) }
-        fn read_u64(&mut self) -> Result<u64, Self::Error> { Err(()) }
-        fn read_u32(&mut self) -> Result<u32, Self::Error> { Err(()) }
-        fn read_u16(&mut self) -> Result<u16, Self::Error> { Err(()) }
-        fn read_u8(&mut self) -> Result<u8, Self::Error> { Err(()) }
-        fn read_isize(&mut self) -> Result<isize, Self::Error> { Err(()) }
-        fn read_i64(&mut self) -> Result<i64, Self::Error> { Err(()) }
-        fn read_i32(&mut self) -> Result<i32, Self::Error> { Err(()) }
-        fn read_i16(&mut self) -> Result<i16, Self::Error> { Err(()) }
-        fn read_i8(&mut self) -> Result<i8, Self::Error> { Err(()) }
-        fn read_bool(&mut self) -> Result<bool, Self::Error> { Err(()) }
-        fn read_f64(&mut self) -> Result<f64, Self::Error> { Err(()) }
-        fn read_f32(&mut self) -> Result<f32, Self::Error> { Err(()) }
-        fn read_char(&mut self) -> Result<char, Self::Error> { Err(()) }
-        fn read_str(&mut self) -> Result<String, Self::Error> { Err(()) }
-
-        // Compound types:
-        fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F)
-                                   -> Result<T, Self::Error>
-            where F: FnMut(&mut Self, usize) -> Result<T, Self::Error> { Err(()) }
-        fn read_enum_variant_arg<T, F>(&mut self, a_idx: usize, f: F)
-                                       -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F)
-                                          -> Result<T, Self::Error>
-            where F: FnMut(&mut Self, usize) -> Result<T, Self::Error> { Err(()) }
-        fn read_enum_struct_variant_field<T, F>(&mut self,
-                                                f_name: &str,
-                                                f_idx: usize,
-                                                f: F)
-                                                -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
-                             -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-        fn read_struct_field<T, F>(&mut self,
-                                   f_name: &str,
-                                   f_idx: usize,
-                                   f: F)
-                                   -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_tuple<T, F>(&mut self, len: usize, f: F) -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-        fn read_tuple_arg<T, F>(&mut self, a_idx: usize, f: F)
-                                -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_tuple_struct<T, F>(&mut self, s_name: &str, len: usize, f: F)
-                                   -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-        fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F)
-                                       -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        // Specialized types:
-        fn read_option<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-            where F: FnMut(&mut Self, bool) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error> {
-                f(self, MAX)
-            }
-        fn read_seq_elt<T, F>(&mut self, idx: usize, f: F) -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error> {
-            f(self, MAX)
-        }
-        fn read_map_elt_key<T, F>(&mut self, idx: usize, f: F)
-                                  -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-        fn read_map_elt_val<T, F>(&mut self, idx: usize, f: F)
-                                  -> Result<T, Self::Error>
-            where F: FnOnce(&mut Self) -> Result<T, Self::Error> { Err(()) }
-
-        // Failure
-        fn error(&mut self, err: &str) -> Self::Error { () }
-    }
-
-    let mut dummy = MyDecoder;
-    let vec_result: Result<Vec<u8>, ()> = Decodable::decode(&mut dummy);
-    assert!(vec_result.is_err());
-
-    let map_result: Result<HashMap<u8, u8>, ()> = Decodable::decode(&mut dummy);
-    assert!(map_result.is_err());
-
-    let set_result: Result<HashSet<u8>, ()> = Decodable::decode(&mut dummy);
-    assert!(set_result.is_err());
-}
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/.cargo-checksum.json
@@ -0,0 +1,1 @@
+{"files":{"Cargo.toml":"69ba75f76da91885bade39b85c2dd7595cda20cb406b571e17f42ab496139c48","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"6485b8ed310d3f0340bf1ad1f47645069ce4069dcc6bb46c7d5c6faf41de1fdb","README.md":"c4d8690cd2aa2db200ecdf2f2113fc8e3f4ccc88f3dc96da22189f45136932d0","src/de.rs":"42d7aa8cf85baa1b3851180e32af883c11ca2889df6f4eb306670f360af46d3e","src/error.rs":"8ac6d4c861891c133b3359b2a14fccb8a6d463a4b2c13f0d658884c1972186ce","src/iter.rs":"b5c77c5482e45bed1e63bd36a0f991a08f732811546a163228be48303e7f1b4d","src/lib.rs":"0da5b1e1e014de3c00a3396295d288a9911ade5a16e7810cf02be8435707e7a2","src/macros.rs":"16eaee6a82152d1d26c5a62a4435b7c9c47e67313da917e78501cad565ea1e5f","src/map.rs":"44bcb1d95be564da0ff087fa272e12311b7a7dcf05401909f8651ce9b46ef798","src/number.rs":"bf72dc7a93cfa5225309fac9ba5a01ba34ca2177e7c5037760b9aed983c82c5d","src/read.rs":"832bc530dd35ee24df59c1cf648cfbbffc4c2e72e86104b0e186582ae0de545a","src/ser.rs":"1444b537ae69171261be4835a9891574570152518312720786b9f1dd9fb423f4","src/value/de.rs":"b25d9192f179f84c0ecb2226216ff663c39ebdde524179f7118718f3202243cf","src/value/from.rs":"13a6c7b0b327f23c2fd899c8390e8ddfd8907bfcfc362e80834b9ae7ddb698e9","src/value/index.rs":"b9a8cc6f37e2a079a5e4ab1bf25fa9ff076c514870e0756a0c88af3ffa0f51a8","src/value/mod.rs":"8d0ac56fcd12aee1c645afdfe0df62b10527cab21d16284fe9f0bd6768457002","src/value/partial_eq.rs":"5924e245408afc8075e2bb9dda479c938c6c8cdd3c18b54697aa2b33fffda57b","src/value/ser.rs":"4bbc3ad0f646464f1e9b9a2c2e48df799d02ef658eacadc35971b897cfe7cd02"},"package":"84b8035cabe9b35878adec8ac5fe03d5f6bc97ff6edd7ccb96b44c1276ba390e"}
\ No newline at end of file
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/Cargo.toml
@@ -0,0 +1,54 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g. crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+name = "serde_json"
+version = "1.0.22"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
+include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+description = "A JSON serialization file format"
+documentation = "http://docs.serde.rs/serde_json/"
+readme = "README.md"
+keywords = ["json", "serde", "serialization"]
+categories = ["encoding"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/serde-rs/json"
+[dependencies.dtoa]
+version = "0.4"
+
+[dependencies.indexmap]
+version = "1.0"
+optional = true
+
+[dependencies.itoa]
+version = "0.4"
+
+[dependencies.serde]
+version = "1.0.60"
+[dev-dependencies.compiletest_rs]
+version = "0.3"
+
+[dev-dependencies.serde_bytes]
+version = "0.10"
+
+[dev-dependencies.serde_derive]
+version = "1.0"
+
+[features]
+arbitrary_precision = []
+default = []
+preserve_order = ["indexmap"]
+[badges.appveyor]
+repository = "serde-rs/json"
+
+[badges.travis-ci]
+repository = "serde-rs/json"
rename from third_party/rust/rustc-serialize/LICENSE-APACHE
rename to third_party/rust/serde_json/LICENSE-APACHE
rename from third_party/rust/rustc-serialize/LICENSE-MIT
rename to third_party/rust/serde_json/LICENSE-MIT
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/README.md
@@ -0,0 +1,365 @@
+# Serde JSON &emsp; [![Build Status]][travis] [![Latest Version]][crates.io] [![Rustc Version 1.15+]][rustc]
+
+[Build Status]: https://api.travis-ci.org/serde-rs/json.svg?branch=master
+[travis]: https://travis-ci.org/serde-rs/json
+[Latest Version]: https://img.shields.io/crates/v/serde_json.svg
+[crates.io]: https://crates.io/crates/serde\_json
+[Rustc Version 1.15+]: https://img.shields.io/badge/rustc-1.15+-lightgray.svg
+[rustc]: https://blog.rust-lang.org/2017/02/02/Rust-1.15.html
+
+**Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
+
+---
+
+```toml
+[dependencies]
+serde_json = "1.0"
+```
+
+You may be looking for:
+
+- [JSON API documentation](https://docs.serde.rs/serde_json/)
+- [Serde API documentation](https://docs.serde.rs/serde/)
+- [Detailed documentation about Serde](https://serde.rs/)
+- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/codegen.html)
+- [Release notes](https://github.com/serde-rs/json/releases)
+
+JSON is a ubiquitous open-standard format that uses human-readable text to
+transmit data objects consisting of key-value pairs.
+
+```json,ignore
+{
+  "name": "John Doe",
+  "age": 43,
+  "address": {
+    "street": "10 Downing Street",
+    "city": "London"
+  },
+  "phones": [
+    "+44 1234567",
+    "+44 2345678"
+  ]
+}
+```
+
+There are three common ways that you might find yourself needing to work
+with JSON data in Rust.
+
+ - **As text data.** An unprocessed string of JSON data that you receive on
+   an HTTP endpoint, read from a file, or prepare to send to a remote
+   server.
+ - **As an untyped or loosely typed representation.** Maybe you want to
+   check that some JSON data is valid before passing it on, but without
+   knowing the structure of what it contains. Or you want to do very basic
+   manipulations like insert a key in a particular spot.
+ - **As a strongly typed Rust data structure.** When you expect all or most
+   of your data to conform to a particular structure and want to get real
+   work done without JSON's loosey-goosey nature tripping you up.
+
+Serde JSON provides efficient, flexible, safe ways of converting data
+between each of these representations.
+
+## Operating on untyped JSON values
+
+Any valid JSON data can be manipulated in the following recursive enum
+representation. This data structure is [`serde_json::Value`][value].
+
+```rust,ignore
+enum Value {
+    Null,
+    Bool(bool),
+    Number(Number),
+    String(String),
+    Array(Vec<Value>),
+    Object(Map<String, Value>),
+}
+```
+
+A string of JSON data can be parsed into a `serde_json::Value` by the
+[`serde_json::from_str`][from_str] function. There is also
+[`from_slice`][from_slice] for parsing from a byte slice &[u8] and
+[`from_reader`][from_reader] for parsing from any `io::Read` like a File or
+a TCP stream.
+
+<a href="http://play.integer32.com/?gist=a266662bc71712e080efbf25ce30f306" target="_blank">
+<img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
+</a>
+
+```rust
+extern crate serde_json;
+
+use serde_json::{Value, Error};
+
+fn untyped_example() -> Result<(), Error> {
+    // Some JSON input data as a &str. Maybe this comes from the user.
+    let data = r#"{
+                    "name": "John Doe",
+                    "age": 43,
+                    "phones": [
+                      "+44 1234567",
+                      "+44 2345678"
+                    ]
+                  }"#;
+
+    // Parse the string of data into serde_json::Value.
+    let v: Value = serde_json::from_str(data)?;
+
+    // Access parts of the data by indexing with square brackets.
+    println!("Please call {} at the number {}", v["name"], v["phones"][0]);
+
+    Ok(())
+}
+```
+
+The result of square bracket indexing like `v["name"]` is a borrow of the data
+at that index, so the type is `&Value`. A JSON map can be indexed with string
+keys, while a JSON array can be indexed with integer keys. If the type of the
+data is not right for the type with which it is being indexed, or if a map does
+not contain the key being indexed, or if the index into a vector is out of
+bounds, the returned element is `Value::Null`.
+
+When a `Value` is printed, it is printed as a JSON string. So in the code above,
+the output looks like `Please call "John Doe" at the number "+44 1234567"`. The
+quotation marks appear because `v["name"]` is a `&Value` containing a JSON
+string and its JSON representation is `"John Doe"`. Printing as a plain string
+without quotation marks involves converting from a JSON string to a Rust string
+with [`as_str()`] or avoiding the use of `Value` as described in the following
+section.
+
+[`as_str()`]: https://docs.serde.rs/serde_json/enum.Value.html#method.as_str
+
+The `Value` representation is sufficient for very basic tasks but can be tedious
+to work with for anything more significant. Error handling is verbose to
+implement correctly, for example imagine trying to detect the presence of
+unrecognized fields in the input data. The compiler is powerless to help you
+when you make a mistake, for example imagine typoing `v["name"]` as `v["nmae"]`
+in one of the dozens of places it is used in your code.
+
+## Parsing JSON as strongly typed data structures
+
+Serde provides a powerful way of mapping JSON data into Rust data structures
+largely automatically.
+
+<a href="http://play.integer32.com/?gist=cff572b80d3f078c942a2151e6020adc" target="_blank">
+<img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
+</a>
+
+```rust
+extern crate serde;
+extern crate serde_json;
+
+#[macro_use]
+extern crate serde_derive;
+
+use serde_json::Error;
+
+#[derive(Serialize, Deserialize)]
+struct Person {
+    name: String,
+    age: u8,
+    phones: Vec<String>,
+}
+
+fn typed_example() -> Result<(), Error> {
+    // Some JSON input data as a &str. Maybe this comes from the user.
+    let data = r#"{
+                    "name": "John Doe",
+                    "age": 43,
+                    "phones": [
+                      "+44 1234567",
+                      "+44 2345678"
+                    ]
+                  }"#;
+
+    // Parse the string of data into a Person object. This is exactly the
+    // same function as the one that produced serde_json::Value above, but
+    // now we are asking it for a Person as output.
+    let p: Person = serde_json::from_str(data)?;
+
+    // Do things just like with any other Rust data structure.
+    println!("Please call {} at the number {}", p.name, p.phones[0]);
+
+    Ok(())
+}
+```
+
+This is the same `serde_json::from_str` function as before, but this time we
+assign the return value to a variable of type `Person` so Serde will
+automatically interpret the input data as a `Person` and produce informative
+error messages if the layout does not conform to what a `Person` is expected
+to look like.
+
+Any type that implements Serde's `Deserialize` trait can be deserialized
+this way. This includes built-in Rust standard library types like `Vec<T>`
+and `HashMap<K, V>`, as well as any structs or enums annotated with
+`#[derive(Deserialize)]`.
+
+Once we have `p` of type `Person`, our IDE and the Rust compiler can help us
+use it correctly like they do for any other Rust code. The IDE can
+autocomplete field names to prevent typos, which was impossible in the
+`serde_json::Value` representation. And the Rust compiler can check that
+when we write `p.phones[0]`, then `p.phones` is guaranteed to be a
+`Vec<String>` so indexing into it makes sense and produces a `String`.
+
+## Constructing JSON values
+
+Serde JSON provides a [`json!` macro][macro] to build `serde_json::Value`
+objects with very natural JSON syntax. In order to use this macro,
+`serde_json` needs to be imported with the `#[macro_use]` attribute.
+
+<a href="http://play.integer32.com/?gist=c216d6beabd9429a6ac13b8f88938dfe" target="_blank">
+<img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
+</a>
+
+```rust
+#[macro_use]
+extern crate serde_json;
+
+fn main() {
+    // The type of `john` is `serde_json::Value`
+    let john = json!({
+      "name": "John Doe",
+      "age": 43,
+      "phones": [
+        "+44 1234567",
+        "+44 2345678"
+      ]
+    });
+
+    println!("first phone number: {}", john["phones"][0]);
+
+    // Convert to a string of JSON and print it out
+    println!("{}", john.to_string());
+}
+```
+
+The `Value::to_string()` function converts a `serde_json::Value` into a
+`String` of JSON text.
+
+One neat thing about the `json!` macro is that variables and expressions can
+be interpolated directly into the JSON value as you are building it. Serde
+will check at compile time that the value you are interpolating is able to
+be represented as JSON.
+
+<a href="http://play.integer32.com/?gist=aae3af4d274bd249d1c8a947076355f2" target="_blank">
+<img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
+</a>
+
+```rust
+let full_name = "John Doe";
+let age_last_year = 42;
+
+// The type of `john` is `serde_json::Value`
+let john = json!({
+  "name": full_name,
+  "age": age_last_year + 1,
+  "phones": [
+    format!("+44 {}", random_phone())
+  ]
+});
+```
+
+This is amazingly convenient but we have the problem we had before with
+`Value` which is that the IDE and Rust compiler cannot help us if we get it
+wrong. Serde JSON provides a better way of serializing strongly-typed data
+structures into JSON text.
+
+## Creating JSON by serializing data structures
+
+A data structure can be converted to a JSON string by
+[`serde_json::to_string`][to_string]. There is also
+[`serde_json::to_vec`][to_vec] which serializes to a `Vec<u8>` and
+[`serde_json::to_writer`][to_writer] which serializes to any `io::Write`
+such as a File or a TCP stream.
+
+<a href="http://play.integer32.com/?gist=40967ece79921c77fd78ebc8f177c063" target="_blank">
+<img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
+</a>
+
+```rust
+extern crate serde;
+extern crate serde_json;
+
+#[macro_use]
+extern crate serde_derive;
+
+use serde_json::Error;
+
+#[derive(Serialize, Deserialize)]
+struct Address {
+    street: String,
+    city: String,
+}
+
+fn print_an_address() -> Result<(), Error> {
+    // Some data structure.
+    let address = Address {
+        street: "10 Downing Street".to_owned(),
+        city: "London".to_owned(),
+    };
+
+    // Serialize it to a JSON string.
+    let j = serde_json::to_string(&address)?;
+
+    // Print, write to a file, or send to an HTTP server.
+    println!("{}", j);
+
+    Ok(())
+}
+```
+
+Any type that implements Serde's `Serialize` trait can be serialized this
+way. This includes built-in Rust standard library types like `Vec<T>` and
+`HashMap<K, V>`, as well as any structs or enums annotated with
+`#[derive(Serialize)]`.
+
+## Performance
+
+It is fast. You should expect in the ballpark of 500 to 1000 megabytes per
+second deserialization and 600 to 900 megabytes per second serialization,
+depending on the characteristics of your data. This is competitive with the
+fastest C and C++ JSON libraries or even 30% faster for many use cases.
+Benchmarks live in the [serde-rs/json-benchmark] repo.
+
+[serde-rs/json-benchmark]: https://github.com/serde-rs/json-benchmark
+
+## Getting help
+
+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/json/issues/new) as well.
+
+## No-std support
+
+This crate currently requires the Rust standard library. For JSON support in
+Serde without a standard library, please see the [`serde-json-core`] crate.
+
+[`serde-json-core`]: https://japaric.github.io/serde-json-core/serde_json_core/
+
+## License
+
+Serde JSON is licensed under either of
+
+ * 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)
+
+at your option.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in Serde JSON by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
+
+[value]: https://docs.serde.rs/serde_json/value/enum.Value.html
+[from_str]: https://docs.serde.rs/serde_json/de/fn.from_str.html
+[from_slice]: https://docs.serde.rs/serde_json/de/fn.from_slice.html
+[from_reader]: https://docs.serde.rs/serde_json/de/fn.from_reader.html
+[to_string]: https://docs.serde.rs/serde_json/ser/fn.to_string.html
+[to_vec]: https://docs.serde.rs/serde_json/ser/fn.to_vec.html
+[to_writer]: https://docs.serde.rs/serde_json/ser/fn.to_writer.html
+[macro]: https://docs.serde.rs/serde_json/macro.json.html
new file mode 100644
--- /dev/null
+++ b/third_party/rust/serde_json/src/de.rs
@@ -0,0 +1,2265 @@
+// Copyright 2017 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Deserialize JSON data to a Rust data structure.
+
+use std::io;
+use std::marker::PhantomData;
+use std::result;
+use std::str::FromStr;
+use std::{i32, u64};
+
+use serde::de::{self, Expected, Unexpected};
+
+use super::error::{Error, ErrorCode, Result};
+
+use read::{self, Reference};
+
+pub use read::{IoRead, Read, SliceRead, StrRead};
+
+use number::Number;
+#[cfg(feature = "arbitrary_precision")]
+use number::NumberDeserializer;
+
+//////////////////////////////////////////////////////////////////////////////
+
+/// A structure that deserializes JSON into Rust values.
+pub struct Deserializer<R> {
+    read: R,
+    str_buf: Vec<u8>,
+    remaining_depth: u8,
+}
+
+impl<'de, R> Deserializer<R>
+where
+    R: read::Read<'de>,
+{
+    /// Create a JSON deserializer from one of the possible serde_json input
+    /// sources.
+    ///
+    /// Typically it is more convenient to use one of these methods instead:
+    ///
+    ///   - Deserializer::from_str
+    ///   - Deserializer::from_bytes
+    ///   - Deserializer::from_reader
+    pub fn new(read: R) -> Self {
+        Deserializer {
+            read: read,
+            str_buf: Vec::with_capacity(128),
+            remaining_depth: 128,
+        }
+    }
+}
+
+impl<R> Deserializer<read::IoRead<R>>
+where
+    R: io::Read,
+{
+    /// Creates a JSON deserializer from an `io::Read`.
+    pub fn from_reader(reader: R) -> Self {
+        Deserializer::new(read::IoRead::new(reader))
+    }
+}
+
+impl<'a> Deserializer<read::SliceRead<'a>> {
+    /// Creates a JSON deserializer from a `&[u8]`.
+    pub fn from_slice(bytes: &'a [u8]) -> Self {
+        Deserializer::new(read::SliceRead::new(bytes))
+    }
+}
+
+impl<'a> Deserializer<read::StrRead<'a>> {
+    /// Creates a JSON deserializer from a `&str`.
+    pub fn from_str(s: &'a str) -> Self {
+        Deserializer::new(read::StrRead::new(s))
+    }
+}
+
+macro_rules! overflow {
+    ($a:ident * 10 + $b:ident, $c:expr) => {
+        $a >= $c / 10 && ($a > $c / 10 || $b > $c % 10)
+    };
+}
+
+// Not public API. Should be pub(crate).
+#[doc(hidden)]
+pub enum ParserNumber {
+    F64(f64),
+    U64(u64),
+    I64(i64),
+    #[cfg(feature = "arbitrary_precision")]
+    String(String),
+}
+
+impl ParserNumber {
+    fn visit<'de, V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        match self {
+            ParserNumber::F64(x) => visitor.visit_f64(x),
+            ParserNumber::U64(x) => visitor.visit_u64(x),
+            ParserNumber::I64(x) => visitor.visit_i64(x),
+            #[cfg(feature = "arbitrary_precision")]
+            ParserNumber::String(x) => visitor.visit_map(NumberDeserializer { number: x.into() }),
+        }
+    }
+
+    fn invalid_type(self, exp: &Expected) -> Error {
+        match self {
+            ParserNumber::F64(x) => de::Error::invalid_type(Unexpected::Float(x), exp),
+            ParserNumber::U64(x) => de::Error::invalid_type(Unexpected::Unsigned(x), exp),
+            ParserNumber::I64(x) => de::Error::invalid_type(Unexpected::Signed(x), exp),
+            #[cfg(feature = "arbitrary_precision")]
+            ParserNumber::String(_) => de::Error::invalid_type(Unexpected::Other("number"), exp),
+        }
+    }
+}
+
+impl<'de, R: Read<'de>> Deserializer<R> {
+    /// The `Deserializer::end` method should be called after a value has been fully deserialized.
+    /// This allows the `Deserializer` to validate that the input stream is at the end or that it
+    /// only has trailing whitespace.
+    pub fn end(&mut self) -> Result<()> {
+        match try!(self.parse_whitespace()) {
+            Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
+            None => Ok(()),
+        }
+    }
+
+    /// Turn a JSON deserializer into an iterator over values of type T.
+    pub fn into_iter<T>(self) -> StreamDeserializer<'de, R, T>
+    where
+        T: de::Deserialize<'de>,
+    {
+        // This cannot be an implementation of std::iter::IntoIterator because
+        // we need the caller to choose what T is.
+        let offset = self.read.byte_offset();
+        StreamDeserializer {
+            de: self,
+            offset: offset,
+            output: PhantomData,
+            lifetime: PhantomData,
+        }
+    }
+
+    fn peek(&mut self) -> Result<Option<u8>> {
+        self.read.peek().map_err(Error::io)
+    }
+
+    fn peek_or_null(&mut self) -> Result<u8> {
+        Ok(try!(self.peek()).unwrap_or(b'\x00'))
+    }
+
+    fn eat_char(&mut self) {
+        self.read.discard();
+    }
+
+    fn next_char(&mut self) -> Result<Option<u8>> {
+        self.read.next().map_err(Error::io)
+    }
+
+    fn next_char_or_null(&mut self) -> Result<u8> {
+        Ok(try!(self.next_char()).unwrap_or(b'\x00'))
+    }
+
+    /// Error caused by a byte from next_char().
+    #[cold]
+    fn error(&self, reason: ErrorCode) -> Error {
+        let position = self.read.position();
+        Error::syntax(reason, position.line, position.column)
+    }
+
+    /// Error caused by a byte from peek().
+    #[cold]
+    fn peek_error(&self, reason: ErrorCode) -> Error {
+        let position = self.read.peek_position();
+        Error::syntax(reason, position.line, position.column)
+    }
+
+    /// Returns the first non-whitespace byte without consuming it, or `None` if
+    /// EOF is encountered.
+    fn parse_whitespace(&mut self) -> Result<Option<u8>> {
+        loop {
+            match try!(self.peek()) {
+                Some(b' ') | Some(b'\n') | Some(b'\t') | Some(b'\r') => {
+                    self.eat_char();
+                }
+                other => {
+                    return Ok(other);
+                }
+            }
+        }
+    }
+
+    #[cold]
+    fn peek_invalid_type(&mut self, exp: &Expected) -> Error {
+        let err = match self.peek_or_null().unwrap_or(b'\x00') {
+            b'n' => {
+                self.eat_char();
+                if let Err(err) = self.parse_ident(b"ull") {
+                    return err;
+                }
+                de::Error::invalid_type(Unexpected::Unit, exp)
+            }
+            b't' => {
+                self.eat_char();
+                if let Err(err) = self.parse_ident(b"rue") {
+                    return err;
+                }
+                de::Error::invalid_type(Unexpected::Bool(true), exp)
+            }
+            b'f' => {
+                self.eat_char();
+                if let Err(err) = self.parse_ident(b"alse") {
+                    return err;
+                }
+                de::Error::invalid_type(Unexpected::Bool(false), exp)
+            }
+            b'-' => {
+                self.eat_char();
+                match self.parse_any_number(false) {
+                    Ok(n) => n.invalid_type(exp),
+                    Err(err) => return err,
+                }
+            }
+            b'0'...b'9' => match self.parse_any_number(true) {
+                Ok(n) => n.invalid_type(exp),
+                Err(err) => return err,
+            },
+            b'"' => {
+                self.eat_char();
+                self.str_buf.clear();
+                match self.read.parse_str(&mut self.str_buf) {
+                    Ok(s) => de::Error::invalid_type(Unexpected::Str(&s), exp),
+                    Err(err) => return err,
+                }
+            }
+            b'[' => de::Error::invalid_type(Unexpected::Seq, exp),
+            b'{' => de::Error::invalid_type(Unexpected::Map, exp),
+            _ => self.peek_error(ErrorCode::ExpectedSomeValue),
+        };
+
+        self.fix_position(err)
+    }
+
+    fn deserialize_prim_number<V>(&mut self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let peek = match try!(self.parse_whitespace()) {
+            Some(b) => b,
+            None => {
+                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+            }
+        };
+
+        let value = match peek {
+            b'-' => {
+                self.eat_char();
+                try!(self.parse_integer(false)).visit(visitor)
+            }
+            b'0'...b'9' => try!(self.parse_integer(true)).visit(visitor),
+            _ => Err(self.peek_invalid_type(&visitor)),
+        };
+
+        match value {
+            Ok(value) => Ok(value),
+            Err(err) => Err(self.fix_position(err)),
+        }
+    }
+
+    serde_if_integer128! {
+        fn scan_integer128(&mut self, buf: &mut String) -> Result<()> {
+            match try!(self.next_char_or_null()) {
+                b'0' => {
+                    buf.push('0');
+                    // There can be only one leading '0'.
+                    match try!(self.peek_or_null()) {
+                        b'0'...b'9' => {
+                            Err(self.peek_error(ErrorCode::InvalidNumber))
+                        }
+                        _ => Ok(()),
+                    }
+                }
+                c @ b'1'...b'9' => {
+                    buf.push(c as char);
+                    while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+                        self.eat_char();
+                        buf.push(c as char);
+                    }
+                    Ok(())
+                }
+                _ => {
+                    Err(self.error(ErrorCode::InvalidNumber))
+                }
+            }
+        }
+    }
+
+    #[cold]
+    fn fix_position(&self, err: Error) -> Error {
+        err.fix_position(move |code| self.error(code))
+    }
+
+    fn parse_ident(&mut self, ident: &[u8]) -> Result<()> {
+        for expected in ident {
+            match try!(self.next_char()) {
+                None => {
+                    return Err(self.error(ErrorCode::EofWhileParsingValue));
+                }
+                Some(next) => {
+                    if next != *expected {
+                        return Err(self.error(ErrorCode::ExpectedSomeIdent));
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    fn parse_integer(&mut self, positive: bool) -> Result<ParserNumber> {
+        match try!(self.next_char_or_null()) {
+            b'0' => {
+                // There can be only one leading '0'.
+                match try!(self.peek_or_null()) {
+                    b'0'...b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
+                    _ => self.parse_number(positive, 0),
+                }
+            }
+            c @ b'1'...b'9' => {
+                let mut res = (c - b'0') as u64;
+
+                loop {
+                    match try!(self.peek_or_null()) {
+                        c @ b'0'...b'9' => {
+                            self.eat_char();
+                            let digit = (c - b'0') as u64;
+
+                            // We need to be careful with overflow. If we can, try to keep the
+                            // number as a `u64` until we grow too large. At that point, switch to
+                            // parsing the value as a `f64`.
+                            if overflow!(res * 10 + digit, u64::max_value()) {
+                                return Ok(ParserNumber::F64(try!(
+                                    self.parse_long_integer(
+                                        positive,
+                                        res,
+                                        1, // res * 10^1
+                                    )
+                                )));
+                            }
+
+                            res = res * 10 + digit;
+                        }
+                        _ => {
+                            return self.parse_number(positive, res);
+                        }
+                    }
+                }
+            }
+            _ => Err(self.error(ErrorCode::InvalidNumber)),
+        }
+    }
+
+    fn parse_long_integer(
+        &mut self,
+        positive: bool,
+        significand: u64,
+        mut exponent: i32,
+    ) -> Result<f64> {
+        loop {
+            match try!(self.peek_or_null()) {
+                b'0'...b'9' => {
+                    self.eat_char();
+                    // This could overflow... if your integer is gigabytes long.
+                    // Ignore that possibility.
+                    exponent += 1;
+                }
+                b'.' => {
+                    return self.parse_decimal(positive, significand, exponent);
+                }
+                b'e' | b'E' => {
+                    return self.parse_exponent(positive, significand, exponent);
+                }
+                _ => {
+                    return self.f64_from_parts(positive, significand, exponent);
+                }
+            }
+        }
+    }
+
+    fn parse_number(&mut self, positive: bool, significand: u64) -> Result<ParserNumber> {
+        Ok(match try!(self.peek_or_null()) {
+            b'.' => ParserNumber::F64(try!(self.parse_decimal(positive, significand, 0))),
+            b'e' | b'E' => ParserNumber::F64(try!(self.parse_exponent(positive, significand, 0))),
+            _ => {
+                if positive {
+                    ParserNumber::U64(significand)
+                } else {
+                    let neg = (significand as i64).wrapping_neg();
+
+                    // Convert into a float if we underflow.
+                    if neg > 0 {
+                        ParserNumber::F64(-(significand as f64))
+                    } else {
+                        ParserNumber::I64(neg)
+                    }
+                }
+            }
+        })
+    }
+
+    fn parse_decimal(
+        &mut self,
+        positive: bool,
+        mut significand: u64,
+        mut exponent: i32,
+    ) -> Result<f64> {
+        self.eat_char();
+
+        let mut at_least_one_digit = false;
+        while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+            self.eat_char();
+            let digit = (c - b'0') as u64;
+            at_least_one_digit = true;
+
+            if overflow!(significand * 10 + digit, u64::max_value()) {
+                // The next multiply/add would overflow, so just ignore all
+                // further digits.
+                while let b'0'...b'9' = try!(self.peek_or_null()) {
+                    self.eat_char();
+                }
+                break;
+            }
+
+            significand = significand * 10 + digit;
+            exponent -= 1;
+        }
+
+        if !at_least_one_digit {
+            return Err(self.peek_error(ErrorCode::InvalidNumber));
+        }
+
+        match try!(self.peek_or_null()) {
+            b'e' | b'E' => self.parse_exponent(positive, significand, exponent),
+            _ => self.f64_from_parts(positive, significand, exponent),
+        }
+    }
+
+    fn parse_exponent(
+        &mut self,
+        positive: bool,
+        significand: u64,
+        starting_exp: i32,
+    ) -> Result<f64> {
+        self.eat_char();
+
+        let positive_exp = match try!(self.peek_or_null()) {
+            b'+' => {
+                self.eat_char();
+                true
+            }
+            b'-' => {
+                self.eat_char();
+                false
+            }
+            _ => true,
+        };
+
+        // Make sure a digit follows the exponent place.
+        let mut exp = match try!(self.next_char_or_null()) {
+            c @ b'0'...b'9' => (c - b'0') as i32,
+            _ => {
+                return Err(self.error(ErrorCode::InvalidNumber));
+            }
+        };
+
+        while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+            self.eat_char();
+            let digit = (c - b'0') as i32;
+
+            if overflow!(exp * 10 + digit, i32::max_value()) {
+                return self.parse_exponent_overflow(positive, significand, positive_exp);
+            }
+
+            exp = exp * 10 + digit;
+        }
+
+        let final_exp = if positive_exp {
+            starting_exp.saturating_add(exp)
+        } else {
+            starting_exp.saturating_sub(exp)
+        };
+
+        self.f64_from_parts(positive, significand, final_exp)
+    }
+
+    // This cold code should not be inlined into the middle of the hot
+    // exponent-parsing loop above.
+    #[cold]
+    #[inline(never)]
+    fn parse_exponent_overflow(
+        &mut self,
+        positive: bool,
+        significand: u64,
+        positive_exp: bool,
+    ) -> Result<f64> {
+        // Error instead of +/- infinity.
+        if significand != 0 && positive_exp {
+            return Err(self.error(ErrorCode::NumberOutOfRange));
+        }
+
+        while let b'0'...b'9' = try!(self.peek_or_null()) {
+            self.eat_char();
+        }
+        Ok(if positive { 0.0 } else { -0.0 })
+    }
+
+    fn parse_any_signed_number(&mut self) -> Result<ParserNumber> {
+        let peek = match try!(self.peek()) {
+            Some(b) => b,
+            None => {
+                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+            }
+        };
+
+        let value = match peek {
+            b'-' => {
+                self.eat_char();
+                self.parse_any_number(false)
+            }
+            b'0'...b'9' => self.parse_any_number(true),
+            _ => Err(self.peek_error(ErrorCode::InvalidNumber)),
+        };
+
+        let value = match try!(self.peek()) {
+            Some(_) => Err(self.peek_error(ErrorCode::InvalidNumber)),
+            None => value,
+        };
+
+        match value {
+            Ok(value) => Ok(value),
+            // The de::Error impl creates errors with unknown line and column.
+            // Fill in the position here by looking at the current index in the
+            // input. There is no way to tell whether this should call `error`
+            // or `peek_error` so pick the one that seems correct more often.
+            // Worst case, the position is off by one character.
+            Err(err) => Err(self.fix_position(err)),
+        }
+    }
+
+    #[cfg(not(feature = "arbitrary_precision"))]
+    fn parse_any_number(&mut self, positive: bool) -> Result<ParserNumber> {
+        self.parse_integer(positive)
+    }
+
+    #[cfg(feature = "arbitrary_precision")]
+    fn parse_any_number(&mut self, positive: bool) -> Result<ParserNumber> {
+        let mut buf = String::with_capacity(16);
+        if !positive {
+            buf.push('-');
+        }
+        self.scan_integer(&mut buf)?;
+        Ok(ParserNumber::String(buf))
+    }
+
+    #[cfg(feature = "arbitrary_precision")]
+    fn scan_or_null(&mut self, buf: &mut String) -> Result<u8> {
+        match try!(self.next_char()) {
+            Some(b) => {
+                buf.push(b as char);
+                Ok(b)
+            }
+            None => Ok(b'\x00'),
+        }
+    }
+
+    #[cfg(feature = "arbitrary_precision")]
+    fn scan_integer(&mut self, buf: &mut String) -> Result<()> {
+        match try!(self.scan_or_null(buf)) {
+            b'0' => {
+                // There can be only one leading '0'.
+                match try!(self.peek_or_null()) {
+                    b'0'...b'9' => Err(self.peek_error(ErrorCode::InvalidNumber)),
+                    _ => self.scan_number(buf),
+                }
+            }
+            b'1'...b'9' => loop {
+                match try!(self.peek_or_null()) {
+                    c @ b'0'...b'9' => {
+                        self.eat_char();
+                        buf.push(c as char);
+                    }
+                    _ => {
+                        return self.scan_number(buf);
+                    }
+                }
+            },
+            _ => Err(self.error(ErrorCode::InvalidNumber)),
+        }
+    }
+
+    #[cfg(feature = "arbitrary_precision")]
+    fn scan_number(&mut self, buf: &mut String) -> Result<()> {
+        match try!(self.peek_or_null()) {
+            b'.' => self.scan_decimal(buf),
+            b'e' | b'E' => self.scan_exponent(buf),
+            _ => Ok(()),
+        }
+    }
+
+    #[cfg(feature = "arbitrary_precision")]
+    fn scan_decimal(&mut self, buf: &mut String) -> Result<()> {
+        self.eat_char();
+        buf.push('.');
+
+        let mut at_least_one_digit = false;
+        while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+            self.eat_char();
+            buf.push(c as char);
+            at_least_one_digit = true;
+        }
+
+        if !at_least_one_digit {
+            return Err(self.peek_error(ErrorCode::InvalidNumber));
+        }
+
+        match try!(self.peek_or_null()) {
+            b'e' | b'E' => self.scan_exponent(buf),
+            _ => Ok(()),
+        }
+    }
+
+    #[cfg(feature = "arbitrary_precision")]
+    fn scan_exponent(&mut self, buf: &mut String) -> Result<()> {
+        self.eat_char();
+        buf.push('e');
+
+        match try!(self.peek_or_null()) {
+            b'+' => {
+                self.eat_char();
+            }
+            b'-' => {
+                self.eat_char();
+                buf.push('-');
+            }
+            _ => {}
+        }
+
+        // Make sure a digit follows the exponent place.
+        match try!(self.scan_or_null(buf)) {
+            b'0'...b'9' => {}
+            _ => {
+                return Err(self.error(ErrorCode::InvalidNumber));
+            }
+        }
+
+        while let c @ b'0'...b'9' = try!(self.peek_or_null()) {
+            self.eat_char();
+            buf.push(c as char);
+        }
+
+        Ok(())
+    }
+
+    fn f64_from_parts(
+        &mut self,
+        positive: bool,
+        significand: u64,
+        mut exponent: i32,
+    ) -> Result<f64> {
+        let mut f = significand as f64;
+        loop {
+            match POW10.get(exponent.abs() as usize) {
+                Some(&pow) => {
+                    if exponent >= 0 {
+                        f *= pow;
+                        if f.is_infinite() {
+                            return Err(self.error(ErrorCode::NumberOutOfRange));
+                        }
+                    } else {
+                        f /= pow;
+                    }
+                    break;
+                }
+                None => {
+                    if f == 0.0 {
+                        break;
+                    }
+                    if exponent >= 0 {
+                        return Err(self.error(ErrorCode::NumberOutOfRange));
+                    }
+                    f /= 1e308;
+                    exponent += 308;
+                }
+            }
+        }
+        Ok(if positive { f } else { -f })
+    }
+
+    fn parse_object_colon(&mut self) -> Result<()> {
+        match try!(self.parse_whitespace()) {
+            Some(b':') => {
+                self.eat_char();
+                Ok(())
+            }
+            Some(_) => Err(self.peek_error(ErrorCode::ExpectedColon)),
+            None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
+        }
+    }
+
+    fn end_seq(&mut self) -> Result<()> {
+        match try!(self.parse_whitespace()) {
+            Some(b']') => {
+                self.eat_char();
+                Ok(())
+            }
+            Some(b',') => {
+                self.eat_char();
+                match self.parse_whitespace() {
+                    Ok(Some(b']')) => Err(self.peek_error(ErrorCode::TrailingComma)),
+                    _ => Err(self.peek_error(ErrorCode::TrailingCharacters)),
+                }
+            }
+            Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
+            None => Err(self.peek_error(ErrorCode::EofWhileParsingList)),
+        }
+    }
+
+    fn end_map(&mut self) -> Result<()> {
+        match try!(self.parse_whitespace()) {
+            Some(b'}') => {
+                self.eat_char();
+                Ok(())
+            }
+            Some(b',') => Err(self.peek_error(ErrorCode::TrailingComma)),
+            Some(_) => Err(self.peek_error(ErrorCode::TrailingCharacters)),
+            None => Err(self.peek_error(ErrorCode::EofWhileParsingObject)),
+        }
+    }
+
+    fn ignore_value(&mut self) -> Result<()> {
+        let peek = match try!(self.parse_whitespace()) {
+            Some(b) => b,
+            None => {
+                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+            }
+        };
+
+        match peek {
+            b'n' => {
+                self.eat_char();
+                self.parse_ident(b"ull")
+            }
+            b't' => {
+                self.eat_char();
+                self.parse_ident(b"rue")
+            }
+            b'f' => {
+                self.eat_char();
+                self.parse_ident(b"alse")
+            }
+            b'-' => {
+                self.eat_char();
+                self.ignore_integer()
+            }
+            b'0'...b'9' => self.ignore_integer(),
+            b'"' => {
+                self.eat_char();
+                self.read.ignore_str()
+            }
+            b'[' => {
+                self.remaining_depth -= 1;
+                if self.remaining_depth == 0 {
+                    return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+                }
+
+                self.eat_char();
+                let res = self.ignore_seq();
+                self.remaining_depth += 1;
+                res
+            }
+            b'{' => {
+                self.remaining_depth -= 1;
+                if self.remaining_depth == 0 {
+                    return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+                }
+
+                self.eat_char();
+                let res = self.ignore_map();
+                self.remaining_depth += 1;
+                res
+            }
+            _ => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
+        }
+    }
+
+    fn ignore_integer(&mut self) -> Result<()> {
+        match try!(self.next_char_or_null()) {
+            b'0' => {
+                // There can be only one leading '0'.
+                if let b'0'...b'9' = try!(self.peek_or_null()) {
+                    return Err(self.peek_error(ErrorCode::InvalidNumber));
+                }
+            }
+            b'1'...b'9' => while let b'0'...b'9' = try!(self.peek_or_null()) {
+                self.eat_char();
+            },
+            _ => {
+                return Err(self.error(ErrorCode::InvalidNumber));
+            }
+        }
+
+        match try!(self.peek_or_null()) {
+            b'.' => self.ignore_decimal(),
+            b'e' | b'E' => self.ignore_exponent(),
+            _ => Ok(()),
+        }
+    }
+
+    fn ignore_decimal(&mut self) -> Result<()> {
+        self.eat_char();
+
+        let mut at_least_one_digit = false;
+        while let b'0'...b'9' = try!(self.peek_or_null()) {
+            self.eat_char();
+            at_least_one_digit = true;
+        }
+
+        if !at_least_one_digit {
+            return Err(self.peek_error(ErrorCode::InvalidNumber));
+        }
+
+        match try!(self.peek_or_null()) {
+            b'e' | b'E' => self.ignore_exponent(),
+            _ => Ok(()),
+        }
+    }
+
+    fn ignore_exponent(&mut self) -> Result<()> {
+        self.eat_char();
+
+        match try!(self.peek_or_null()) {
+            b'+' | b'-' => self.eat_char(),
+            _ => {}
+        }
+
+        // Make sure a digit follows the exponent place.
+        match try!(self.next_char_or_null()) {
+            b'0'...b'9' => {}
+            _ => {
+                return Err(self.error(ErrorCode::InvalidNumber));
+            }
+        }
+
+        while let b'0'...b'9' = try!(self.peek_or_null()) {
+            self.eat_char();
+        }
+
+        Ok(())
+    }
+
+    fn ignore_seq(&mut self) -> Result<()> {
+        let mut first = true;
+
+        loop {
+            match try!(self.parse_whitespace()) {
+                Some(b']') => {
+                    self.eat_char();
+                    return Ok(());
+                }
+                Some(b',') if !first => {
+                    self.eat_char();
+                }
+                Some(_) => {
+                    if first {
+                        first = false;
+                    } else {
+                        return Err(self.peek_error(ErrorCode::ExpectedListCommaOrEnd));
+                    }
+                }
+                None => {
+                    return Err(self.peek_error(ErrorCode::EofWhileParsingList));
+                }
+            }
+
+            try!(self.ignore_value());
+        }
+    }
+
+    fn ignore_map(&mut self) -> Result<()> {
+        let mut first = true;
+
+        loop {
+            let peek = match try!(self.parse_whitespace()) {
+                Some(b'}') => {
+                    self.eat_char();
+                    return Ok(());
+                }
+                Some(b',') if !first => {
+                    self.eat_char();
+                    try!(self.parse_whitespace())
+                }
+                Some(b) => {
+                    if first {
+                        first = false;
+                        Some(b)
+                    } else {
+                        return Err(self.peek_error(ErrorCode::ExpectedObjectCommaOrEnd));
+                    }
+                }
+                None => {
+                    return Err(self.peek_error(ErrorCode::EofWhileParsingObject));
+                }
+            };
+
+            match peek {
+                Some(b'"') => {
+                    self.eat_char();
+                    try!(self.read.ignore_str());
+                }
+                Some(_) => {
+                    return Err(self.peek_error(ErrorCode::KeyMustBeAString));
+                }
+                None => {
+                    return Err(self.peek_error(ErrorCode::EofWhileParsingObject));
+                }
+            }
+
+            match try!(self.parse_whitespace()) {
+                Some(b':') => {
+                    self.eat_char();
+                    try!(self.ignore_value());
+                }
+                Some(_) => {
+                    return Err(self.peek_error(ErrorCode::ExpectedColon));
+                }
+                None => {
+                    return Err(self.peek_error(ErrorCode::EofWhileParsingObject));
+                }
+            }
+        }
+    }
+}
+
+impl FromStr for Number {
+    type Err = Error;
+
+    fn from_str(s: &str) -> result::Result<Self, Self::Err> {
+        Deserializer::from_str(s)
+            .parse_any_signed_number()
+            .map(Into::into)
+    }
+}
+
+#[cfg_attr(rustfmt, rustfmt_skip)]
+static POW10: [f64; 309] =
+    [1e000, 1e001, 1e002, 1e003, 1e004, 1e005, 1e006, 1e007, 1e008, 1e009,
+     1e010, 1e011, 1e012, 1e013, 1e014, 1e015, 1e016, 1e017, 1e018, 1e019,
+     1e020, 1e021, 1e022, 1e023, 1e024, 1e025, 1e026, 1e027, 1e028, 1e029,
+     1e030, 1e031, 1e032, 1e033, 1e034, 1e035, 1e036, 1e037, 1e038, 1e039,
+     1e040, 1e041, 1e042, 1e043, 1e044, 1e045, 1e046, 1e047, 1e048, 1e049,
+     1e050, 1e051, 1e052, 1e053, 1e054, 1e055, 1e056, 1e057, 1e058, 1e059,
+     1e060, 1e061, 1e062, 1e063, 1e064, 1e065, 1e066, 1e067, 1e068, 1e069,
+     1e070, 1e071, 1e072, 1e073, 1e074, 1e075, 1e076, 1e077, 1e078, 1e079,
+     1e080, 1e081, 1e082, 1e083, 1e084, 1e085, 1e086, 1e087, 1e088, 1e089,
+     1e090, 1e091, 1e092, 1e093, 1e094, 1e095, 1e096, 1e097, 1e098, 1e099,
+     1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109,
+     1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119,
+     1e120, 1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129,
+     1e130, 1e131, 1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139,
+     1e140, 1e141, 1e142, 1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149,
+     1e150, 1e151, 1e152, 1e153, 1e154, 1e155, 1e156, 1e157, 1e158, 1e159,
+     1e160, 1e161, 1e162, 1e163, 1e164, 1e165, 1e166, 1e167, 1e168, 1e169,
+     1e170, 1e171, 1e172, 1e173, 1e174, 1e175, 1e176, 1e177, 1e178, 1e179,
+     1e180, 1e181, 1e182, 1e183, 1e184, 1e185, 1e186, 1e187, 1e188, 1e189,
+     1e190, 1e191, 1e192, 1e193, 1e194, 1e195, 1e196, 1e197, 1e198, 1e199,
+     1e200, 1e201, 1e202, 1e203, 1e204, 1e205, 1e206, 1e207, 1e208, 1e209,
+     1e210, 1e211, 1e212, 1e213, 1e214, 1e215, 1e216, 1e217, 1e218, 1e219,
+     1e220, 1e221, 1e222, 1e223, 1e224, 1e225, 1e226, 1e227, 1e228, 1e229,
+     1e230, 1e231, 1e232, 1e233, 1e234, 1e235, 1e236, 1e237, 1e238, 1e239,
+     1e240, 1e241, 1e242, 1e243, 1e244, 1e245, 1e246, 1e247, 1e248, 1e249,
+     1e250, 1e251, 1e252, 1e253, 1e254, 1e255, 1e256, 1e257, 1e258, 1e259,
+     1e260, 1e261, 1e262, 1e263, 1e264, 1e265, 1e266, 1e267, 1e268, 1e269,
+     1e270, 1e271, 1e272, 1e273, 1e274, 1e275, 1e276, 1e277, 1e278, 1e279,
+     1e280, 1e281, 1e282, 1e283, 1e284, 1e285, 1e286, 1e287, 1e288, 1e289,
+     1e290, 1e291, 1e292, 1e293, 1e294, 1e295, 1e296, 1e297, 1e298, 1e299,
+     1e300, 1e301, 1e302, 1e303, 1e304, 1e305, 1e306, 1e307, 1e308];
+
+macro_rules! deserialize_prim_number {
+    ($method:ident) => {
+        fn $method<V>(self, visitor: V) -> Result<V::Value>
+        where
+            V: de::Visitor<'de>,
+        {
+            self.deserialize_prim_number(visitor)
+        }
+    }
+}
+
+impl<'de, 'a, R: Read<'de>> de::Deserializer<'de> for &'a mut Deserializer<R> {
+    type Error = Error;
+
+    #[inline]
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let peek = match try!(self.parse_whitespace()) {
+            Some(b) => b,
+            None => {
+                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+            }
+        };
+
+        let value = match peek {
+            b'n' => {
+                self.eat_char();
+                try!(self.parse_ident(b"ull"));
+                visitor.visit_unit()
+            }
+            b't' => {
+                self.eat_char();
+                try!(self.parse_ident(b"rue"));
+                visitor.visit_bool(true)
+            }
+            b'f' => {
+                self.eat_char();
+                try!(self.parse_ident(b"alse"));
+                visitor.visit_bool(false)
+            }
+            b'-' => {
+                self.eat_char();
+                try!(self.parse_any_number(false)).visit(visitor)
+            }
+            b'0'...b'9' => try!(self.parse_any_number(true)).visit(visitor),
+            b'"' => {
+                self.eat_char();
+                self.str_buf.clear();
+                match try!(self.read.parse_str(&mut self.str_buf)) {
+                    Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
+                    Reference::Copied(s) => visitor.visit_str(s),
+                }
+            }
+            b'[' => {
+                self.remaining_depth -= 1;
+                if self.remaining_depth == 0 {
+                    return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+                }
+
+                self.eat_char();
+                let ret = visitor.visit_seq(SeqAccess::new(self));
+
+                self.remaining_depth += 1;
+
+                match (ret, self.end_seq()) {
+                    (Ok(ret), Ok(())) => Ok(ret),
+                    (Err(err), _) | (_, Err(err)) => Err(err),
+                }
+            }
+            b'{' => {
+                self.remaining_depth -= 1;
+                if self.remaining_depth == 0 {
+                    return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+                }
+
+                self.eat_char();
+                let ret = visitor.visit_map(MapAccess::new(self));
+
+                self.remaining_depth += 1;
+
+                match (ret, self.end_map()) {
+                    (Ok(ret), Ok(())) => Ok(ret),
+                    (Err(err), _) | (_, Err(err)) => Err(err),
+                }
+            }
+            _ => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
+        };
+
+        match value {
+            Ok(value) => Ok(value),
+            // The de::Error impl creates errors with unknown line and column.
+            // Fill in the position here by looking at the current index in the
+            // input. There is no way to tell whether this should call `error`
+            // or `peek_error` so pick the one that seems correct more often.
+            // Worst case, the position is off by one character.
+            Err(err) => Err(self.fix_position(err)),
+        }
+    }
+
+    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let peek = match try!(self.parse_whitespace()) {
+            Some(b) => b,
+            None => {
+                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+            }
+        };
+
+        let value = match peek {
+            b't' => {
+                self.eat_char();
+                try!(self.parse_ident(b"rue"));
+                visitor.visit_bool(true)
+            }
+            b'f' => {
+                self.eat_char();
+                try!(self.parse_ident(b"alse"));
+                visitor.visit_bool(false)
+            }
+            _ => Err(self.peek_invalid_type(&visitor)),
+        };
+
+        match value {
+            Ok(value) => Ok(value),
+            Err(err) => Err(self.fix_position(err)),
+        }
+    }
+
+    deserialize_prim_number!(deserialize_i8);
+    deserialize_prim_number!(deserialize_i16);
+    deserialize_prim_number!(deserialize_i32);
+    deserialize_prim_number!(deserialize_i64);
+    deserialize_prim_number!(deserialize_u8);
+    deserialize_prim_number!(deserialize_u16);
+    deserialize_prim_number!(deserialize_u32);
+    deserialize_prim_number!(deserialize_u64);
+    deserialize_prim_number!(deserialize_f32);
+    deserialize_prim_number!(deserialize_f64);
+
+    serde_if_integer128! {
+        fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value>
+        where
+            V: de::Visitor<'de>,
+        {
+            let mut buf = String::new();
+
+            match try!(self.parse_whitespace()) {
+                Some(b'-') => {
+                    self.eat_char();
+                    buf.push('-');
+                }
+                Some(_) => {}
+                None => {
+                    return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+                }
+            };
+
+            try!(self.scan_integer128(&mut buf));
+
+            let value = match buf.parse() {
+                Ok(int) => visitor.visit_i128(int),
+                Err(_) => {
+                    return Err(self.error(ErrorCode::NumberOutOfRange));
+                }
+            };
+
+            match value {
+                Ok(value) => Ok(value),
+                Err(err) => Err(self.fix_position(err)),
+            }
+        }
+
+        fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value>
+        where
+            V: de::Visitor<'de>,
+        {
+            match try!(self.parse_whitespace()) {
+                Some(b'-') => {
+                    return Err(self.peek_error(ErrorCode::NumberOutOfRange));
+                }
+                Some(_) => {}
+                None => {
+                    return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+                }
+            }
+
+            let mut buf = String::new();
+            try!(self.scan_integer128(&mut buf));
+
+            let value = match buf.parse() {
+                Ok(int) => visitor.visit_u128(int),
+                Err(_) => {
+                    return Err(self.error(ErrorCode::NumberOutOfRange));
+                }
+            };
+
+            match value {
+                Ok(value) => Ok(value),
+                Err(err) => Err(self.fix_position(err)),
+            }
+        }
+    }
+
+    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        self.deserialize_str(visitor)
+    }
+
+    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let peek = match try!(self.parse_whitespace()) {
+            Some(b) => b,
+            None => {
+                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+            }
+        };
+
+        let value = match peek {
+            b'"' => {
+                self.eat_char();
+                self.str_buf.clear();
+                match try!(self.read.parse_str(&mut self.str_buf)) {
+                    Reference::Borrowed(s) => visitor.visit_borrowed_str(s),
+                    Reference::Copied(s) => visitor.visit_str(s),
+                }
+            }
+            _ => Err(self.peek_invalid_type(&visitor)),
+        };
+
+        match value {
+            Ok(value) => Ok(value),
+            Err(err) => Err(self.fix_position(err)),
+        }
+    }
+
+    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        self.deserialize_str(visitor)
+    }
+
+    /// Parses a JSON string as bytes. Note that this function does not check
+    /// whether the bytes represent a valid UTF-8 string.
+    ///
+    /// The relevant part of the JSON specification is Section 8.2 of [RFC
+    /// 7159]:
+    ///
+    /// > When all the strings represented in a JSON text are composed entirely
+    /// > of Unicode characters (however escaped), then that JSON text is
+    /// > interoperable in the sense that all software implementations that
+    /// > parse it will agree on the contents of names and of string values in
+    /// > objects and arrays.
+    /// >
+    /// > However, the ABNF in this specification allows member names and string
+    /// > values to contain bit sequences that cannot encode Unicode characters;
+    /// > for example, "\uDEAD" (a single unpaired UTF-16 surrogate). Instances
+    /// > of this have been observed, for example, when a library truncates a
+    /// > UTF-16 string without checking whether the truncation split a
+    /// > surrogate pair.  The behavior of software that receives JSON texts
+    /// > containing such values is unpredictable; for example, implementations
+    /// > might return different values for the length of a string value or even
+    /// > suffer fatal runtime exceptions.
+    ///
+    /// [RFC 7159]: https://tools.ietf.org/html/rfc7159
+    ///
+    /// The behavior of serde_json is specified to fail on non-UTF-8 strings
+    /// when deserializing into Rust UTF-8 string types such as String, and
+    /// succeed with non-UTF-8 bytes when deserializing using this method.
+    ///
+    /// Escape sequences are processed as usual, and for `\uXXXX` escapes it is
+    /// still checked if the hex number represents a valid Unicode code point.
+    ///
+    /// # Examples
+    ///
+    /// You can use this to parse JSON strings containing invalid UTF-8 bytes.
+    ///
+    /// ```rust
+    /// extern crate serde_json;
+    /// extern crate serde_bytes;
+    ///
+    /// use serde_bytes::ByteBuf;
+    ///
+    /// fn look_at_bytes() -> Result<(), serde_json::Error> {
+    ///     let json_data = b"\"some bytes: \xe5\x00\xe5\"";
+    ///     let bytes: ByteBuf = serde_json::from_slice(json_data)?;
+    ///
+    ///     assert_eq!(b'\xe5', bytes[12]);
+    ///     assert_eq!(b'\0', bytes[13]);
+    ///     assert_eq!(b'\xe5', bytes[14]);
+    ///
+    ///     Ok(())
+    /// }
+    /// #
+    /// # fn main() {
+    /// #     look_at_bytes().unwrap();
+    /// # }
+    /// ```
+    ///
+    /// Backslash escape sequences like `\n` are still interpreted and required
+    /// to be valid, and `\u` escape sequences are required to represent valid
+    /// Unicode code points.
+    ///
+    /// ```rust
+    /// extern crate serde_json;
+    /// extern crate serde_bytes;
+    ///
+    /// use serde_bytes::ByteBuf;
+    ///
+    /// fn look_at_bytes() {
+    ///     let json_data = b"\"invalid unicode surrogate: \\uD801\"";
+    ///     let parsed: Result<ByteBuf, _> = serde_json::from_slice(json_data);
+    ///
+    ///     assert!(parsed.is_err());
+    ///
+    ///     let expected_msg = "unexpected end of hex escape at line 1 column 35";
+    ///     assert_eq!(expected_msg, parsed.unwrap_err().to_string());
+    /// }
+    /// #
+    /// # fn main() {
+    /// #     look_at_bytes();
+    /// # }
+    /// ```
+    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let peek = match try!(self.parse_whitespace()) {
+            Some(b) => b,
+            None => {
+                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+            }
+        };
+
+        let value = match peek {
+            b'"' => {
+                self.eat_char();
+                self.str_buf.clear();
+                match try!(self.read.parse_str_raw(&mut self.str_buf)) {
+                    Reference::Borrowed(b) => visitor.visit_borrowed_bytes(b),
+                    Reference::Copied(b) => visitor.visit_bytes(b),
+                }
+            }
+            b'[' => self.deserialize_seq(visitor),
+            _ => Err(self.peek_invalid_type(&visitor)),
+        };
+
+        match value {
+            Ok(value) => Ok(value),
+            Err(err) => Err(self.fix_position(err)),
+        }
+    }
+
+    #[inline]
+    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        self.deserialize_bytes(visitor)
+    }
+
+    /// Parses a `null` as a None, and any other values as a `Some(...)`.
+    #[inline]
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        match try!(self.parse_whitespace()) {
+            Some(b'n') => {
+                self.eat_char();
+                try!(self.parse_ident(b"ull"));
+                visitor.visit_none()
+            }
+            _ => visitor.visit_some(self),
+        }
+    }
+
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let peek = match try!(self.parse_whitespace()) {
+            Some(b) => b,
+            None => {
+                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+            }
+        };
+
+        let value = match peek {
+            b'n' => {
+                self.eat_char();
+                try!(self.parse_ident(b"ull"));
+                visitor.visit_unit()
+            }
+            _ => Err(self.peek_invalid_type(&visitor)),
+        };
+
+        match value {
+            Ok(value) => Ok(value),
+            Err(err) => Err(self.fix_position(err)),
+        }
+    }
+
+    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        self.deserialize_unit(visitor)
+    }
+
+    /// Parses a newtype struct as the underlying value.
+    #[inline]
+    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let peek = match try!(self.parse_whitespace()) {
+            Some(b) => b,
+            None => {
+                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+            }
+        };
+
+        let value = match peek {
+            b'[' => {
+                self.remaining_depth -= 1;
+                if self.remaining_depth == 0 {
+                    return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+                }
+
+                self.eat_char();
+                let ret = visitor.visit_seq(SeqAccess::new(self));
+
+                self.remaining_depth += 1;
+
+                match (ret, self.end_seq()) {
+                    (Ok(ret), Ok(())) => Ok(ret),
+                    (Err(err), _) | (_, Err(err)) => Err(err),
+                }
+            }
+            _ => Err(self.peek_invalid_type(&visitor)),
+        };
+
+        match value {
+            Ok(value) => Ok(value),
+            Err(err) => Err(self.fix_position(err)),
+        }
+    }
+
+    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        self.deserialize_seq(visitor)
+    }
+
+    fn deserialize_tuple_struct<V>(
+        self,
+        _name: &'static str,
+        _len: usize,
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        self.deserialize_seq(visitor)
+    }
+
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let peek = match try!(self.parse_whitespace()) {
+            Some(b) => b,
+            None => {
+                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+            }
+        };
+
+        let value = match peek {
+            b'{' => {
+                self.remaining_depth -= 1;
+                if self.remaining_depth == 0 {
+                    return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+                }
+
+                self.eat_char();
+                let ret = visitor.visit_map(MapAccess::new(self));
+
+                self.remaining_depth += 1;
+
+                match (ret, self.end_map()) {
+                    (Ok(ret), Ok(())) => Ok(ret),
+                    (Err(err), _) | (_, Err(err)) => Err(err),
+                }
+            }
+            _ => Err(self.peek_invalid_type(&visitor)),
+        };
+
+        match value {
+            Ok(value) => Ok(value),
+            Err(err) => Err(self.fix_position(err)),
+        }
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        _name: &'static str,
+        _fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        let peek = match try!(self.parse_whitespace()) {
+            Some(b) => b,
+            None => {
+                return Err(self.peek_error(ErrorCode::EofWhileParsingValue));
+            }
+        };
+
+        let value = match peek {
+            b'[' => {
+                self.remaining_depth -= 1;
+                if self.remaining_depth == 0 {
+                    return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+                }
+
+                self.eat_char();
+                let ret = visitor.visit_seq(SeqAccess::new(self));
+
+                self.remaining_depth += 1;
+
+                match (ret, self.end_seq()) {
+                    (Ok(ret), Ok(())) => Ok(ret),
+                    (Err(err), _) | (_, Err(err)) => Err(err),
+                }
+            }
+            b'{' => {
+                self.remaining_depth -= 1;
+                if self.remaining_depth == 0 {
+                    return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+                }
+
+                self.eat_char();
+                let ret = visitor.visit_map(MapAccess::new(self));
+
+                self.remaining_depth += 1;
+
+                match (ret, self.end_map()) {
+                    (Ok(ret), Ok(())) => Ok(ret),
+                    (Err(err), _) | (_, Err(err)) => Err(err),
+                }
+            }
+            _ => Err(self.peek_invalid_type(&visitor)),
+        };
+
+        match value {
+            Ok(value) => Ok(value),
+            Err(err) => Err(self.fix_position(err)),
+        }
+    }
+
+    /// Parses an enum as an object like `{"$KEY":$VALUE}`, where $VALUE is either a straight
+    /// value, a `[..]`, or a `{..}`.
+    #[inline]
+    fn deserialize_enum<V>(
+        self,
+        _name: &str,
+        _variants: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        match try!(self.parse_whitespace()) {
+            Some(b'{') => {
+                self.remaining_depth -= 1;
+                if self.remaining_depth == 0 {
+                    return Err(self.peek_error(ErrorCode::RecursionLimitExceeded));
+                }
+
+                self.eat_char();
+                let value = try!(visitor.visit_enum(VariantAccess::new(self)));
+
+                self.remaining_depth += 1;
+
+                match try!(self.parse_whitespace()) {
+                    Some(b'}') => {
+                        self.eat_char();
+                        Ok(value)
+                    }
+                    Some(_) => Err(self.error(ErrorCode::ExpectedSomeValue)),
+                    None => Err(self.error(ErrorCode::EofWhileParsingObject)),
+                }
+            }
+            Some(b'"') => visitor.visit_enum(UnitVariantAccess::new(self)),
+            Some(_) => Err(self.peek_error(ErrorCode::ExpectedSomeValue)),
+            None => Err(self.peek_error(ErrorCode::EofWhileParsingValue)),
+        }
+    }
+
+    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        self.deserialize_str(visitor)
+    }
+
+    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        try!(self.ignore_value());
+        visitor.visit_unit()
+    }
+}
+
+struct SeqAccess<'a, R: 'a> {
+    de: &'a mut Deserializer<R>,
+    first: bool,
+}
+
+impl<'a, R: 'a> SeqAccess<'a, R> {
+    fn new(de: &'a mut Deserializer<R>) -> Self {
+        SeqAccess {
+            de: de,
+            first: true,
+        }
+    }
+}
+
+impl<'de, 'a, R: Read<'de> + 'a> de::SeqAccess<'de> for SeqAccess<'a, R> {
+    type Error = Error;
+
+    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        let peek = match try!(self.de.parse_whitespace()) {
+            Some(b']') => {
+                return Ok(None);
+            }
+            Some(b',') if !self.first => {
+                self.de.eat_char();
+                try!(self.de.parse_whitespace())
+            }
+            Some(b) => {
+                if self.first {
+                    self.first = false;
+                    Some(b)
+                } else {
+                    return Err(self.de.peek_error(ErrorCode::ExpectedListCommaOrEnd));
+                }
+            }
+            None => {
+                return Err(self.de.peek_error(ErrorCode::EofWhileParsingList));
+            }
+        };
+
+        match peek {
+            Some(b']') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
+            Some(_) => Ok(Some(try!(seed.deserialize(&mut *self.de)))),
+            None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
+        }
+    }
+}
+
+struct MapAccess<'a, R: 'a> {
+    de: &'a mut Deserializer<R>,
+    first: bool,
+}
+
+impl<'a, R: 'a> MapAccess<'a, R> {
+    fn new(de: &'a mut Deserializer<R>) -> Self {
+        MapAccess {
+            de: de,
+            first: true,
+        }
+    }
+}
+
+impl<'de, 'a, R: Read<'de> + 'a> de::MapAccess<'de> for MapAccess<'a, R> {
+    type Error = Error;
+
+    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
+    where
+        K: de::DeserializeSeed<'de>,
+    {
+        let peek = match try!(self.de.parse_whitespace()) {
+            Some(b'}') => {
+                return Ok(None);
+            }
+            Some(b',') if !self.first => {
+                self.de.eat_char();
+                try!(self.de.parse_whitespace())
+            }
+            Some(b) => {
+                if self.first {
+                    self.first = false;
+                    Some(b)
+                } else {
+                    return Err(self.de.peek_error(ErrorCode::ExpectedObjectCommaOrEnd));
+                }
+            }
+            None => {
+                return Err(self.de.peek_error(ErrorCode::EofWhileParsingObject));
+            }
+        };
+
+        match peek {
+            Some(b'"') => seed.deserialize(MapKey { de: &mut *self.de }).map(Some),
+            Some(b'}') => Err(self.de.peek_error(ErrorCode::TrailingComma)),
+            Some(_) => Err(self.de.peek_error(ErrorCode::KeyMustBeAString)),
+            None => Err(self.de.peek_error(ErrorCode::EofWhileParsingValue)),
+        }
+    }
+
+    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
+    where
+        V: de::DeserializeSeed<'de>,
+    {
+        try!(self.de.parse_object_colon());
+
+        seed.deserialize(&mut *self.de)
+    }
+}
+
+struct VariantAccess<'a, R: 'a> {
+    de: &'a mut Deserializer<R>,
+}
+
+impl<'a, R: 'a> VariantAccess<'a, R> {
+    fn new(de: &'a mut Deserializer<R>) -> Self {
+        VariantAccess { de: de }
+    }
+}
+
+impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for VariantAccess<'a, R> {
+    type Error = Error;
+    type Variant = Self;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
+    where
+        V: de::DeserializeSeed<'de>,
+    {
+        let val = try!(seed.deserialize(&mut *self.de));
+        try!(self.de.parse_object_colon());
+        Ok((val, self))
+    }
+}
+
+impl<'de, 'a, R: Read<'de> + 'a> de::VariantAccess<'de> for VariantAccess<'a, R> {
+    type Error = Error;
+
+    fn unit_variant(self) -> Result<()> {
+        de::Deserialize::deserialize(self.de)
+    }
+
+    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        seed.deserialize(self.de)
+    }
+
+    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        de::Deserializer::deserialize_seq(self.de, visitor)
+    }
+
+    fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
+    where
+        V: de::Visitor<'de>,
+    {
+        de::Deserializer::deserialize_struct(self.de, "", fields, visitor)
+    }
+}
+
+struct UnitVariantAccess<'a, R: 'a> {
+    de: &'a mut Deserializer<R>,
+}
+
+impl<'a, R: 'a> UnitVariantAccess<'a, R> {
+    fn new(de: &'a mut Deserializer<R>) -> Self {
+        UnitVariantAccess { de: de }
+    }
+}
+
+impl<'de, 'a, R: Read<'de> + 'a> de::EnumAccess<'de> for UnitVariantAccess<'a, R> {
+    type Error = Error;
+    type Variant = Self;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
+    where
+        V: de::DeserializeSeed<'de>,