[rust] add valico 2.3.1

Change-Id: I0bb5288efef8527abdba5a593934eaef25f9ae4f
diff --git a/rustc_deps/Cargo.lock b/rustc_deps/Cargo.lock
index 461e4bb..7aaf311 100644
--- a/rustc_deps/Cargo.lock
+++ b/rustc_deps/Cargo.lock
@@ -514,6 +514,7 @@
  "unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "utf8parse 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "valico 2.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "vte 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "xi-core-lib 0.2.0",
  "xi-rpc 0.2.0",
@@ -738,6 +739,20 @@
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
+name = "jsonway"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "lazy_static"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
 name = "lazy_static"
 version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1589,6 +1604,30 @@
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
+name = "uuid"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "rand 0.5.5 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "valico"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "jsonway 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)",
+ "phf 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
+ "phf_codegen 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)",
+ "regex 1.0.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde 1.0.80 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
+ "url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "uuid 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
 name = "vec_map"
 version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1723,6 +1762,10 @@
 version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
+[[patch.unused]]
+name = "winapi-build"
+version = "0.3.6"
+
 [metadata]
 "checksum adler32 1.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7e522997b529f05601e05166c07ed17789691f562762c7f3b987263d2dedee5c"
 "checksum aho-corasick 0.6.9 (registry+https://github.com/rust-lang/crates.io-index)" = "1e9a933f4e58658d7b12defcf96dc5c720f20832deebe3e0a19efd3b6aaeeb9e"
@@ -1804,6 +1847,8 @@
 "checksum iovec 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dbe6e417e7d0975db6512b90796e8ce223145ac4e33c377e4a42882a0e88bb08"
 "checksum itertools 0.7.9 (registry+https://github.com/rust-lang/crates.io-index)" = "7cef527957675adbb9ec77a7e3c44c69d729dc0a80e64fe7d380138ef851af1d"
 "checksum itoa 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)" = "1306f3464951f30e30d12373d31c79fbd52d236e5e896fd92f96ec7babbbe60b"
+"checksum jsonway 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "effcb749443c905fbaef49d214f8b1049c240e0adb7af9baa0e201e625e4f9de"
+"checksum lazy_static 0.2.11 (registry+https://github.com/rust-lang/crates.io-index)" = "76f033c7ad61445c5b347c7382dd1237847eb1bce590fe50365dcb33d546be73"
 "checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"
 "checksum libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)" = "76e3a3ef172f1a0b9a9ff0dd1491ae5e6c948b94479a3021819ba7d860c8645d"
 "checksum lock_api 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "62ebf1391f6acad60e5c8b43706dde4582df75c06698ab44511d15016bc2442c"
@@ -1907,6 +1952,8 @@
 "checksum url 1.7.2 (registry+https://github.com/rust-lang/crates.io-index)" = "dd4e7c0d531266369519a4aa4f399d748bd37043b00bde1e4ff1f60a120b355a"
 "checksum utf8-ranges 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "796f7e48bef87609f7ade7e06495a87d5cd06c7866e6a5cbfceffc558a243737"
 "checksum utf8parse 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "8772a4ccbb4e89959023bc5b7cb8623a795caa7092d99f3aa9501b9484d4557d"
+"checksum uuid 0.7.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dab5c5526c5caa3d106653401a267fed923e7046f35895ffcb5ca42db64942e6"
+"checksum valico 2.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "a236e2b29a1d4d3ad6b5c8c69fc2bfbef0fc14a3397d037fbcb10be9f91db258"
 "checksum vec_map 0.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "05c78687fb1a80548ae3250346c3db86a80a7cdd77bda190189f2d0a0987c81a"
 "checksum version_check 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "914b1a6776c4c929a602fafd8bc742e06365d4bcbe48c30f9cca5824f70dc9dd"
 "checksum void 1.0.2 (registry+https://github.com/rust-lang/crates.io-index)" = "6a02e4885ed3bc0f2de90ea6dd45ebcbb66dacffe03547fadbb0eeae2770887d"
diff --git a/rustc_deps/Cargo.toml b/rustc_deps/Cargo.toml
index 6a3260b..e128671 100644
--- a/rustc_deps/Cargo.toml
+++ b/rustc_deps/Cargo.toml
@@ -58,6 +58,7 @@
 unicode-width = "0.1.3"
 utf8parse = "0.1"
 url = "1.7.0"
+valico = "2.3.1"
 vte = "0.3"
 xi-core-lib = { version = "0.2.0", default-features = false } # disable "notify" crate
 xi-rpc = "0.2.0"
@@ -75,4 +76,5 @@
 xi-trace-dump = { path = "../../rust-mirrors/xi-editor/rust/trace-dump" }
 xi-unicode = { path = "../../rust-mirrors/xi-editor/rust/unicode" }
 winapi = { path = "tiny_mirrors/winapi" }
+winapi-build = { path = "tiny_mirrors/winapi-build" }
 winapi-util = { path = "tiny_mirrors/winapi-util" }
diff --git a/rustc_deps/tiny_mirrors/winapi-build/Cargo.toml b/rustc_deps/tiny_mirrors/winapi-build/Cargo.toml
new file mode 100644
index 0000000..bdad8d5
--- /dev/null
+++ b/rustc_deps/tiny_mirrors/winapi-build/Cargo.toml
@@ -0,0 +1,6 @@
+[package]
+name = "winapi-build"
+version = "0.3.6"
+authors = ["Derek Gonyeo <dgonyeo@google.com>"]
+
+[dependencies]
diff --git a/rustc_deps/tiny_mirrors/winapi-build/src/lib.rs b/rustc_deps/tiny_mirrors/winapi-build/src/lib.rs
new file mode 100644
index 0000000..c679081
--- /dev/null
+++ b/rustc_deps/tiny_mirrors/winapi-build/src/lib.rs
@@ -0,0 +1,3 @@
+// Copyright 2018 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
diff --git a/rustc_deps/vendor/jsonway/.cargo-checksum.json b/rustc_deps/vendor/jsonway/.cargo-checksum.json
new file mode 100644
index 0000000..ec6e6be
--- /dev/null
+++ b/rustc_deps/vendor/jsonway/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CONTRIBUTING.md":"be5c52ab7b4f2966fd575ce8ff6b1e520a9f7ef871686d97db64786ca4f018b6","Cargo.toml":"8044a694d2819f2e59b4187376b7c73ab5415aed17efd6318b000a294d5d5be5","LICENSE":"a2291d25c9665f3b8a4e803622947a50a0af558b2a843f3bb53f7699ccb1d99e","Makefile":"1ebf888ff3dac28f7fa23be67985d798f128b6ec36a9d7c8aed4e89e8552671c","README.md":"ec7f314b636cb314ac2e9b4380bfd0400ec5dd010d6ea414964b39db366a0868","src/array_builder.rs":"ceb474e9117ecf197fb4cacfa0e84434e9de70e1fc08e8b5770dfeeeedfdd6c2","src/array_serializer.rs":"64ca156dd31c08c92ae672dd8e705299f176538b7da145d6a98e31fa852c73f7","src/lib.rs":"4076952d9fb0abeef9d781f73a590954869b1d4311d48b04aa371b8cb3e981ad","src/object_builder.rs":"e8702f87d46dfa48db36fbcb7841655b873209ca5571dd2a8504a0100212f5af","src/serializer.rs":"7368940b60a86ef762844e4b0176c6b88e5d560054fc7ec8e4eb9ad3c406ee80","tests/tests.rs":"eed1e8df91460216e260369bd3f34d2cca80f7100db16fb92c061f7f40f7151b"},"package":"effcb749443c905fbaef49d214f8b1049c240e0adb7af9baa0e201e625e4f9de"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/jsonway/CONTRIBUTING.md b/rustc_deps/vendor/jsonway/CONTRIBUTING.md
new file mode 100644
index 0000000..0687452
--- /dev/null
+++ b/rustc_deps/vendor/jsonway/CONTRIBUTING.md
@@ -0,0 +1,72 @@
+# Contributing to JsonWay
+
+You want to contribute? You're awesome! When submitting a Pull Request, please have your commits follow these guidelines:
+
+## Git Commit Guidelines
+
+These guidelines have been copied from the [AngularJS](https://github.com/angular/angular.js/blob/master/CONTRIBUTING.md#-git-commit-guidelines)
+project.
+
+We have very precise rules over how our git commit messages can be formatted.  This leads to **more
+readable messages** that are easy to follow when looking through the **project history**.  But also,
+we use the git commit messages to **generate the change log**.
+
+### Commit Message Format
+Each commit message consists of a **header**, a **body** and a **footer**.  The header has a special
+format that includes a **type**, a **scope** and a **subject**:
+
+``
+<type>(<scope>): <subject>
+<BLANK LINE>
+<body>
+<BLANK LINE>
+<footer>
+``
+
+Any line of the commit message cannot be longer 100 characters! This allows the message to be easier
+to read on github as well as in various git tools.
+
+### Type
+Must be one of the following:
+
+* **feat**: A new feature
+* **fix**: A bug fix
+* **docs**: Documentation only changes
+* **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing
+  semi-colons, etc)
+* **refactor**: A code change that neither fixes a bug or adds a feature
+* **perf**: A code change that improves performance
+* **test**: Adding missing tests
+* **chore**: Changes to the build process or auxiliary tools and libraries such as documentation
+    generation
+
+### Scope
+The scope should refer to a module in rustless that is being touched. Examples:
+
+* object_builder
+* array_builder
+* array_serializer
+* serializer
+* lib
+
+### Subject
+The subject contains succinct description of the change:
+
+* use the imperative, present tense: "change" not "changed" nor "changes"
+* don't capitalize first letter
+* no dot (.) at the end
+
+###Body
+Just as in the **subject**, use the imperative, present tense: "change" not "changed" nor "changes"
+The body should include the motivation for the change and contrast this with previous behavior.
+
+###Footer
+The footer should contain any information about **Breaking Changes** and is also the place to
+reference GitHub issues that this commit **Closes**.
+
+The last line of commits introducing breaking changes should be in the form `BREAKING_CHANGE: <desc>`
+
+
+A detailed explanation can be found in this [document][commit-message-format].
+
+[commit-message-format]: https://docs.google.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y/edit#
diff --git a/rustc_deps/vendor/jsonway/Cargo.toml b/rustc_deps/vendor/jsonway/Cargo.toml
new file mode 100644
index 0000000..42c0f47
--- /dev/null
+++ b/rustc_deps/vendor/jsonway/Cargo.toml
@@ -0,0 +1,29 @@
+# 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 = "jsonway"
+version = "2.0.0"
+authors = ["Stanislav Panferov <fnight.m@gmail.com>"]
+description = "JSON building DSL and configurable serializers for Rust"
+documentation = "http://rustless.org/rustless/doc/jsonway/"
+keywords = ["json", "serializers"]
+license = "MIT"
+repository = "https://github.com/rustless/jsonway"
+
+[[test]]
+name = "tests"
+[dependencies.serde]
+version = "1.0"
+
+[dependencies.serde_json]
+version = "1.0"
diff --git a/rustc_deps/vendor/jsonway/LICENSE b/rustc_deps/vendor/jsonway/LICENSE
new file mode 100644
index 0000000..f0f4394
--- /dev/null
+++ b/rustc_deps/vendor/jsonway/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Stanislav Panferov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/rustc_deps/vendor/jsonway/Makefile b/rustc_deps/vendor/jsonway/Makefile
new file mode 100644
index 0000000..646f4d9
--- /dev/null
+++ b/rustc_deps/vendor/jsonway/Makefile
@@ -0,0 +1,9 @@
+doc:
+	git checkout gh-pages
+	git reset --hard master
+	cargo doc
+	cp -r target/doc doc
+	git add --all
+	git commit -m "doc(*): rebuilding docs `date -u +"%Y-%m-%dT%H:%M:%SZ"`"
+	git push -f origin gh-pages
+	git checkout master
diff --git a/rustc_deps/vendor/jsonway/README.md b/rustc_deps/vendor/jsonway/README.md
new file mode 100644
index 0000000..ca58ccb
--- /dev/null
+++ b/rustc_deps/vendor/jsonway/README.md
@@ -0,0 +1,232 @@
+# JsonWay
+
+[![Build Status](https://travis-ci.org/rustless/jsonway.svg?branch=master)](https://travis-ci.org/rustless/jsonway)
+
+JsonWay gives you a simple DSL for declaring JSON structures.
+This is particularly helpful when the generation process is fraught with conditionals and loops.
+It is inspired by [jbuilder](https://github.com/rails/jbuilder) and has similar functionality.
+
+```toml
+# Cargo.toml
+[dependencies.jsonway]
+git = "https://github.com/rustless/jsonway"
+```
+
+[API docs](http://rustless.org/jsonway/doc/jsonway/)
+
+## Simple example
+
+``` rust
+jsonway::object(|json| {
+    json.set("first_name", "Luke".to_string());
+    json.set("last_name", "Skywalker".to_string());
+
+    json.object("info", |json| {
+        json.set("homeworld", "Tatooine".to_string());
+        json.set("born", "19 BBY".to_string());
+        json.set("died", "Between 45 ABY and 137 ABY".to_string());
+    });
+
+    json.array("masters", |json| {
+        json.push("Obi-Wan Kenobi".to_string());
+        json.push("Yoda".to_string());
+        json.push("Joruus C'baoth (Briefly)".to_string());
+        json.push("Darth Sidious (Briefly)".to_string());
+    });
+});
+
+// {
+//   "first_name": "Luke",
+//   "last_name": "Skywalker",
+//   "info": {
+//     "born": "19 BBY",
+//     "died": "Between 45 ABY and 137 ABY",
+//     "homeworld": "Tatooine"
+//   },
+//   "masters": [
+//     "Obi-Wan Kenobi",
+//     "Yoda",
+//     "Joruus C'baoth (Briefly)",
+//     "Darth Sidious (Briefly)"
+//   ]
+// }
+```
+
+## Build with iterators
+
+~~~rust
+#[derive(Debug)]
+enum Side {
+    Light,
+    Dark
+}
+
+struct Jedi {
+    name: String,
+    side: Side
+}
+
+let jedi = vec![
+    Jedi { name: "Saes Rrogon".to_string(), side: Side::Dark },
+    Jedi { name: "Qui-Gon Jinn".to_string(), side: Side::Light },
+    Jedi { name: "Obi-Wan Kenobi".to_string(), side: Side::Light }
+];
+
+let light_jedi_objects_list = jsonway::array(|json| {
+    // Use `objects` method to make list of objects
+    json.objects(&mut jedi.iter(), |jedi, json| {
+        match jedi.side {
+            Side::Light => {
+                json.set("name".to_string(), jedi.name.to_string());
+                json.set("side".to_string(), format!("{:?}", jedi.side));
+            }
+            Side::Dark => json.skip(),
+        }
+    })
+});
+
+// [
+//   {
+//     "name": "Qui-Gon Jinn",
+//     "side": "Light"
+//   },
+//   {
+//     "name": "Obi-Wan Kenobi",
+//     "side": "Light"
+//   }
+// ]
+
+let light_jedi_tuple_list = jsonway::array(|json| {
+    // Use `arrays` method to make list of lists
+    json.arrays(&mut jedi.iter(), |jedi, json| {
+        match jedi.side {
+            Side::Light => {
+                json.push(jedi.name.to_string());
+                json.push(format!("{:?}", jedi.side));
+            }
+            Side::Dark => json.skip(),
+        }
+    })
+});
+
+// [
+//   [
+//     "Qui-Gon Jinn",
+//     "Light"
+//   ],
+//   [
+//     "Obi-Wan Kenobi",
+//     "Light"
+//   ]
+// ]
+
+~~~
+
+You can explicitly make `JsonWay` object return `null` if you want:
+
+~~~rust
+// ..
+match jedi.side {
+    Side::Light => {
+        json.push(jedi.name.to_string());
+        json.push(format!("{:?}", jedi.side));
+    },
+    Side::Dark => json.null()
+}
+~~~
+
+## Serializers
+
+### Serializier
+
+Provides convention and functionality to create custom JSON presenters for any struct.
+
+```rust
+use jsonway::{ObjectBuilder, Serializer};
+
+struct Jedi {
+    name: String
+}
+
+struct JediSerializer<'a> {
+    jedi: &'a Jedi
+}
+
+impl<'a> Serializer for JediSerializer<'a> {
+    fn root(&self) -> Option<&str> { Some("jedi") }
+    fn build(&self, json: &mut ObjectBuilder) {
+        json.set("name", self.jedi.name.to_string());
+    }
+}
+
+let jedi = Jedi { name: "Saes Rrogon".to_string() };
+let json = JediSerializer{jedi: &jedi}.serialize();
+```
+
+### ObjectSerializer
+
+`ObjectSerializer<T>` is a generic struct for single `object:T` serialization.
+
+```rust
+use jsonway::{ObjectBuilder, ObjectSerializer};
+
+struct Jedi {
+    name: String
+}
+
+struct JediSerializer;
+
+impl ObjectSerializer<Jedi> for JediSerializer {
+    fn root(&self) -> Option<&str> { Some("jedi") }
+    fn build(&self, jedi: &Jedi, json: &mut ObjectBuilder) {
+        json.set("name", jedi.name.to_string());
+    }
+}
+
+let jedi = Jedi { name: "Saes Rrogon".to_string() };
+let json = JediSerializer.serialize(&jedi);
+```
+
+### ObjectScopeSerializer
+
+`ObjectScopeSerializer<T, S>` is a generic struct for `object:T` and `scope:S` serialization.
+
+```rust
+use jsonway::{ObjectBuilder, ObjectScopeSerializer};
+
+struct User {
+    id: uint,
+    is_admin: bool
+}
+
+struct Jedi {
+    name: String,
+    secret: String
+}
+
+struct JediSerializer;
+
+impl ObjectScopeSerializer<Jedi, User> for JediSerializer {
+    fn root(&self) -> Option<&str> { Some("jedi") }
+    fn build(&self, jedi: &Jedi, current_user: &User, json: &mut ObjectBuilder) {
+        json.set("name", jedi.name.to_string());
+
+        if current_user.is_admin {
+            json.set("secret", jedi.secret.to_string());
+        }
+    }
+}
+
+let jedi = Jedi {
+    name: "Palpatine".to_string(),
+    secret: "Dark side".to_string()
+};
+let current_user = User { id: 1, is_admin: true };
+let json = JediSerializer.serialize(&jedi, &current_user);
+```
+
+## ListSerializer
+
+Provides convention and functionality to create custom JSON presenters for the list of resources including `meta` information.
+
+TODO: Example
diff --git a/rustc_deps/vendor/jsonway/src/array_builder.rs b/rustc_deps/vendor/jsonway/src/array_builder.rs
new file mode 100644
index 0000000..a3e80c2
--- /dev/null
+++ b/rustc_deps/vendor/jsonway/src/array_builder.rs
@@ -0,0 +1,152 @@
+use serde_json::{Value, to_value};
+use serde::{Serialize, Serializer};
+
+pub type JsonArray = Vec<Value>;
+
+use object_builder;
+
+pub struct ArrayBuilder {
+    pub array: JsonArray,
+    pub null: bool,
+    pub skip: bool,
+    pub root: Option<String>
+}
+
+/// Use ArrayBuilder to produce JSON arrays
+impl ArrayBuilder {
+
+    pub fn new() -> ArrayBuilder {
+        ArrayBuilder {
+            array: vec![],
+            null: false,
+            skip: false,
+            root: None
+        }
+    }
+
+    /// Initialize builder with initial value.
+    pub fn from_json(array: Value) -> Option<ArrayBuilder> {
+        match array {
+            Value::Array(array) => Some(ArrayBuilder {
+                array: array,
+                null: false,
+                skip: false,
+                root: None
+            }),
+            _ => None
+        }
+    }
+
+    /// Create new ArrayBuilder, pass it to closure as mutable ref and return.
+    pub fn build<F>(builder: F) -> ArrayBuilder where F: FnOnce(&mut ArrayBuilder) {
+        let mut bldr = ArrayBuilder::new();
+        builder(&mut bldr);
+
+        bldr
+    }
+
+    /// Push JSON value to array.
+    pub fn push_json(&mut self, value: Value) {
+        self.array.push(value);
+    }
+
+    /// Create new array and push it.
+    pub fn array<F>(&mut self, builder: F) where F: FnOnce(&mut ArrayBuilder) {
+        self.push(ArrayBuilder::build(builder).unwrap());
+    }
+
+    /// Create new object and push it
+    pub fn object<F>(&mut self, builder: F) where F: FnOnce(&mut object_builder::ObjectBuilder) {
+        self.push(object_builder::ObjectBuilder::build(builder).unwrap());
+    }
+
+    /// It you call `null`, this array will be converted to null when converting
+    /// to raw JSON value.
+    pub fn null(&mut self) {
+        self.null = true;
+    }
+
+    /// It you call `skip`, this array will be skipped.
+    pub fn skip(&mut self) {
+        self.skip = true;
+    }
+
+    // Set custom root for result Value object
+    pub fn root(&mut self, root: &str) {
+        self.root = Some(root.to_string());
+    }
+
+    pub fn has_root(&mut self) -> bool {
+        self.root.is_some()
+    }
+
+    /// Move out internal JSON value.
+    pub fn unwrap(self) -> Value {
+        if self.root.is_some() {
+            let mut obj = ::serde_json::Map::new();
+            let root = self.root.as_ref().unwrap().to_string();
+            let self_json = self.unwrap_internal();
+            obj.insert(root, self_json);
+            Value::Object(obj)
+        } else {
+            self.unwrap_internal()
+        }
+    }
+
+    /// Move out internal JSON value.
+    #[inline]
+    fn unwrap_internal(self) -> Value {
+        if self.null {
+            Value::Null
+        } else {
+            Value::Array(self.array)
+        }
+    }
+}
+
+impl ArrayBuilder {
+    /// Push to array something that can be converted to JSON.
+    pub fn push<T: Serialize>(&mut self, value: T) {
+        self.push_json(to_value(&value).unwrap());
+    }
+}
+
+impl ArrayBuilder {
+
+    /// Fill this array by objects builded from iterator.
+    pub fn objects<A, T: Iterator<Item=A>, F>(&mut self, iter: T, func: F) where F: Fn(A, &mut object_builder::ObjectBuilder) {
+        for a in iter {
+            let mut bldr = object_builder::ObjectBuilder::new();
+            func(a, &mut bldr);
+            if !bldr.skip {
+                self.push(bldr.unwrap())
+            }
+        }
+    }
+
+    // Fill this array by arrays builded from iterator.
+    pub fn arrays<A, T: Iterator<Item=A>, F>(&mut self, iter: T, func: F) where F: Fn(A, &mut ArrayBuilder) {
+        for a in iter {
+            let mut bldr = ArrayBuilder::new();
+            func(a, &mut bldr);
+            if !bldr.skip {
+                self.push(bldr.unwrap())
+            }
+        }
+    }
+
+    /// Fill this array by JSON values builded from iterator.
+    pub fn map<A, T: Iterator<Item=A>, F>(&mut self, iter: T, func: F) where F: Fn(A) -> Value {
+        for a in iter {
+            self.push(func(a))
+        }
+    }
+}
+
+impl Serialize for ArrayBuilder {
+    /// Copy self to new JSON instance.
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+        let json_object = if self.null { Value::Null } else { to_value(&self.array).unwrap() };
+        json_object.serialize(serializer)
+    }
+}
diff --git a/rustc_deps/vendor/jsonway/src/array_serializer.rs b/rustc_deps/vendor/jsonway/src/array_serializer.rs
new file mode 100644
index 0000000..145f51d
--- /dev/null
+++ b/rustc_deps/vendor/jsonway/src/array_serializer.rs
@@ -0,0 +1,44 @@
+use serde_json::Value;
+
+use object_builder;
+use array_builder;
+
+pub trait ArraySerializer {
+    fn build(&self, &mut array_builder::ArrayBuilder);
+
+    #[inline]
+    fn root(&self) -> Option<&str> {
+        None
+    }
+
+    #[inline]
+    fn meta(&self) -> Option<object_builder::ObjectBuilder> {
+        None
+    }
+
+    fn serialize(&mut self, include_root: bool) -> Value {
+        let mut bldr = array_builder::ArrayBuilder::new();
+
+        let root = self.root();
+        if include_root && root.is_some() {
+            bldr.root(root.unwrap())
+        }
+
+        self.build(&mut bldr);
+
+        match self.meta() {
+            Some(meta) => {
+                let mut meta_bldr = if bldr.has_root() {
+                    object_builder::ObjectBuilder::from_json(bldr.unwrap()).unwrap()
+                } else {
+                    let mut meta_bldr = object_builder::ObjectBuilder::new();
+                    meta_bldr.set("data", bldr.unwrap());
+                    meta_bldr
+                };
+                meta_bldr.set_json("meta", meta.unwrap());
+                meta_bldr.unwrap()
+            }
+            None => bldr.unwrap(),
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/jsonway/src/lib.rs b/rustc_deps/vendor/jsonway/src/lib.rs
new file mode 100644
index 0000000..25f3215
--- /dev/null
+++ b/rustc_deps/vendor/jsonway/src/lib.rs
@@ -0,0 +1,52 @@
+#![crate_type = "rlib"]
+#![deny(warnings)]
+#![deny(bad_style)]
+
+extern crate serde;
+extern crate serde_json;
+
+pub use object_builder::ObjectBuilder;
+pub use array_builder::ArrayBuilder;
+pub use serializer::{Serializer, ObjectSerializer, ObjectScopeSerializer};
+pub use array_serializer::ArraySerializer;
+
+pub mod array_builder;
+pub mod object_builder;
+pub mod serializer;
+pub mod array_serializer;
+
+/// ```rust
+/// let json = jsonway::object(|json| {
+///     json.set("first_name", "Luke");
+///     json.set("last_name", "Skywalker");
+///
+///     json.object("info", |json| {
+///         json.set("homeworld", "Tatooine");
+///         json.set("born", "19 BBY");
+///         json.set("died", "Between 45 ABY and 137 ABY");
+///     });
+///
+///     json.array("masters", |json| {
+///         json.push("Obi-Wan Kenobi");
+///         json.push("Yoda");
+///         json.push("Joruus C'baoth (Briefly)");
+///         json.push("Darth Sidious (Briefly)");
+///     });
+/// }).unwrap();
+///
+/// assert_eq!(json.get("first_name").unwrap().as_str().unwrap(), "Luke");
+/// assert_eq!(json.get("last_name").unwrap().as_str().unwrap(), "Skywalker");
+///
+/// assert!(json.get("info").unwrap().is_object());
+/// assert!(json.get("masters").unwrap().is_array());
+/// ```
+
+/// Create and return new ListBuilder
+pub fn array<F>(builder: F) -> ArrayBuilder where F: FnOnce(&mut ArrayBuilder) {
+    ArrayBuilder::build(builder)
+}
+
+/// Create and return new ObjectBuilder
+pub fn object<F>(builder: F) -> ObjectBuilder where F: FnOnce(&mut ObjectBuilder) {
+    ObjectBuilder::build(builder)
+}
diff --git a/rustc_deps/vendor/jsonway/src/object_builder.rs b/rustc_deps/vendor/jsonway/src/object_builder.rs
new file mode 100644
index 0000000..15404a8
--- /dev/null
+++ b/rustc_deps/vendor/jsonway/src/object_builder.rs
@@ -0,0 +1,125 @@
+use serde_json::{Value, to_value};
+use serde::{Serialize, Serializer};
+
+pub type Object = ::serde_json::Map<String, Value>;
+use array_builder;
+
+pub struct ObjectBuilder {
+    pub object: Object,
+    pub null: bool,
+    pub skip: bool,
+    pub root: Option<String>
+}
+
+/// ObjectBuilder is used to produce JSON objects
+impl ObjectBuilder {
+    pub fn new() -> ObjectBuilder {
+        ObjectBuilder {
+            object: ::serde_json::Map::new(),
+            null: false,
+            skip: false,
+            root: None
+        }
+    }
+
+    /// Initialize builder with initial value.
+    pub fn from_json(object: Value) -> Option<ObjectBuilder> {
+        match object {
+            Value::Object(object) => Some(ObjectBuilder {
+                object: object,
+                null: false,
+                skip: false,
+                root: None
+            }),
+            _ => None
+        }
+    }
+
+    /// Create new builder, pass it to closure as mutable ref and return.
+    pub fn build<F>(builder: F) -> ObjectBuilder where F: FnOnce(&mut ObjectBuilder) {
+        let mut bldr = ObjectBuilder::new();
+        builder(&mut bldr);
+
+        bldr
+    }
+
+    /// It you call `null`, this object will be converted to null.
+    pub fn null(&mut self) {
+        self.null = true;
+    }
+
+    /// It you call `skip`, this object will be skipped.
+    pub fn skip(&mut self) {
+        self.skip = true;
+    }
+
+    // Set custom root for result Value object
+    pub fn root(&mut self, root: &str) {
+        self.root = Some(root.to_string());
+    }
+
+    pub fn has_root(&mut self) -> bool {
+        self.root.is_some()
+    }
+
+    /// Move out internal JSON value.
+    pub fn unwrap(self) -> Value {
+        if self.root.is_some() {
+            let mut obj = ::serde_json::Map::new();
+            let root = self.root.as_ref().unwrap().to_string();
+            let self_json = self.unwrap_internal();
+            obj.insert(root, self_json);
+            Value::Object(obj)
+        } else {
+            self.unwrap_internal()
+        }
+    }
+
+    #[inline]
+    fn unwrap_internal(self) -> Value {
+        if self.null {
+            Value::Null
+        } else {
+            Value::Object(self.object)
+        }
+    }
+}
+
+impl ObjectBuilder {
+    /// Set object's `name` field with something that can be
+    /// converted to Value value.
+    pub fn set<V: Serialize, N: Into<String>>(&mut self, name: N, value: V) {
+        self.set_json(name, to_value(&value).unwrap());
+    }
+
+    /// Stub for future use
+    pub fn call<V: Serialize, N: Into<String>>(&mut self, name: N, value: V) {
+        self.set(name, value);
+    }
+}
+
+impl ObjectBuilder {
+    /// Set object's `name` field with raw Value value.
+    pub fn set_json<N: Into<String>>(&mut self, name: N, value: Value) {
+        self.object.insert(name.into(), value);
+    }
+
+    /// Build new array and set object's `name` field with it.
+    pub fn array<N: Into<String>, F>(&mut self, name: N, builder: F) where F: FnOnce(&mut array_builder::ArrayBuilder) {
+        self.set(name.into(), array_builder::ArrayBuilder::build(builder).unwrap());
+    }
+
+    /// Build new object and set object's `name` field with it.
+    pub fn object<N: Into<String>, F>(&mut self, name: N, builder: F) where F: FnOnce(&mut ObjectBuilder) {
+        self.set(name.into(), ObjectBuilder::build(builder).unwrap());
+    }
+}
+
+impl Serialize for ObjectBuilder {
+    /// Copy self to new JSON instance.
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+        let json_object = if self.null { Value::Null } else { to_value(&self.object).unwrap() };
+        json_object.serialize(serializer)
+    }
+}
+
diff --git a/rustc_deps/vendor/jsonway/src/serializer.rs b/rustc_deps/vendor/jsonway/src/serializer.rs
new file mode 100644
index 0000000..e8d0b42
--- /dev/null
+++ b/rustc_deps/vendor/jsonway/src/serializer.rs
@@ -0,0 +1,170 @@
+use serde_json::{Value};
+use object_builder;
+
+/// Provides functionality to create custom JSON presenters for your structs.
+///
+/// ## Example
+///
+/// ```
+/// use jsonway::{self, Serializer};
+///
+/// struct Jedi {
+///     name: String
+/// }
+///
+/// struct JediSerializer<'a> {
+///     jedi: &'a Jedi
+/// }
+///
+/// impl<'a> jsonway::Serializer for JediSerializer<'a> {
+///     fn root(&self) -> Option<&str> { Some("jedi") }
+///     fn build(&self, json: &mut jsonway::ObjectBuilder) {
+///         json.set("name", &self.jedi.name);
+///     }
+/// }
+///
+/// let jedi = Jedi { name: "Saes Rrogon".to_string() };
+/// let json = JediSerializer{jedi: &jedi}.serialize(true);
+///
+/// assert_eq!(
+///     json.pointer("/jedi/name").unwrap().as_str().unwrap(),
+///     "Saes Rrogon"
+/// );
+/// ```
+pub trait Serializer {
+
+    fn build(&self, &mut object_builder::ObjectBuilder);
+
+    #[inline]
+    fn root(&self) -> Option<&str> {
+        None
+    }
+
+    fn serialize(&mut self, include_root: bool) -> Value {
+        let mut bldr = object_builder::ObjectBuilder::new();
+        let root = self.root();
+        if include_root && root.is_some() {
+            bldr.root(root.unwrap())
+        }
+        self.build(&mut bldr);
+
+        bldr.unwrap()
+    }
+}
+
+/// Provides functionality to create custom JSON presenters for your structs.
+///
+/// ## Example
+///
+/// ```
+/// use jsonway::{self, ObjectSerializer};
+///
+/// struct Jedi {
+///     name: String
+/// }
+///
+/// struct JediSerializer;
+///
+/// impl jsonway::ObjectSerializer<Jedi> for JediSerializer {
+///     fn root(&self) -> Option<&str> { Some("jedi") }
+///     fn build(&self, jedi: &Jedi, json: &mut jsonway::ObjectBuilder) {
+///         json.set("name", &jedi.name);
+///     }
+/// }
+///
+/// let jedi = Jedi { name: "Saes Rrogon".to_string() };
+/// let json = JediSerializer.serialize(&jedi, true);
+///
+/// assert_eq!(
+///     json.pointer("/jedi/name").unwrap().as_str().unwrap(),
+///     "Saes Rrogon"
+/// );
+/// ```
+pub trait ObjectSerializer<T> {
+
+    fn build(&self, &T, &mut object_builder::ObjectBuilder);
+
+    #[inline]
+    fn root(&self) -> Option<&str> {
+        None
+    }
+
+    fn serialize(&mut self, obj: &T, include_root: bool) -> Value {
+        let mut bldr = object_builder::ObjectBuilder::new();
+        let root = self.root();
+        if include_root && root.is_some() {
+            bldr.root(root.unwrap())
+        }
+        self.build(obj, &mut bldr);
+        bldr.unwrap()
+    }
+}
+
+/// Provides functionality to create custom JSON presenters for your structs.
+///
+/// ## Example
+///
+/// ```rust
+/// use jsonway::{self, ObjectScopeSerializer};
+///
+/// struct User {
+///     id: u64,
+///     is_admin: bool
+/// }
+///
+/// struct Jedi {
+///     name: String,
+///     secret: String
+/// }
+///
+/// struct JediSerializer;
+///
+/// impl jsonway::ObjectScopeSerializer<Jedi, User> for JediSerializer {
+///     fn root(&self) -> Option<&str> { Some("jedi") }
+///     fn build(&self, jedi: &Jedi, current_user: &User, json: &mut jsonway::ObjectBuilder) {
+///         json.set("name", jedi.name.to_string());
+///
+///         if current_user.is_admin {
+///             json.set("secret", jedi.secret.to_string());
+///         }
+///     }
+/// }
+///
+/// let jedi = Jedi {
+///     name: "Palpatine".to_string(),
+///     secret: "Dark side".to_string()
+/// };
+///
+/// let current_user = User { id: 1, is_admin: true };
+/// let json = JediSerializer.serialize(&jedi, &current_user, true);
+///
+/// assert_eq!(
+///     json.pointer("/jedi/name").unwrap().as_str().unwrap(),
+///     "Palpatine"
+/// );
+///
+/// assert_eq!(
+///     json.pointer("/jedi/secret").unwrap().as_str().unwrap(),
+///     "Dark side"
+/// );
+///
+/// ```
+pub trait ObjectScopeSerializer<T, S> {
+
+    fn build(&self, &T, &S, &mut object_builder::ObjectBuilder);
+
+    #[inline]
+    fn root(&self) -> Option<&str> {
+        None
+    }
+
+    fn serialize(&mut self, obj: &T, scope: &S, include_root: bool) -> Value {
+        let mut bldr = object_builder::ObjectBuilder::new();
+        let root = self.root();
+        if include_root && root.is_some() {
+            bldr.root(root.unwrap())
+        }
+        self.build(obj, scope, &mut bldr);
+        bldr.unwrap()
+    }
+}
diff --git a/rustc_deps/vendor/jsonway/tests/tests.rs b/rustc_deps/vendor/jsonway/tests/tests.rs
new file mode 100644
index 0000000..f9c8abd
--- /dev/null
+++ b/rustc_deps/vendor/jsonway/tests/tests.rs
@@ -0,0 +1,61 @@
+extern crate jsonway;
+
+#[derive(Debug)]
+enum Side {
+    Light,
+    Dark
+}
+
+struct Jedi {
+    name: String,
+    side: Side
+}
+
+fn jedi_array() -> Vec<Jedi> {
+    vec![
+        Jedi { name: "Saes Rrogon".to_string(), side: Side::Dark },
+        Jedi { name: "Qui-Gon Jinn".to_string(), side: Side::Light },
+        Jedi { name: "Obi-Wan Kenobi".to_string(), side: Side::Light }
+    ]
+}
+
+#[test]
+fn simple_array_of_objects() {
+    let jedi_array = jedi_array();
+
+    let json = jsonway::array(|json| {
+        json.objects(jedi_array.iter(), |jedi, json| {
+            match jedi.side {
+                Side::Light => {
+                    json.set("name".to_string(), jedi.name.to_string());
+                    json.set("side".to_string(), format!("{:?}", jedi.side));
+                },
+                Side::Dark => json.skip()
+            }
+        })
+    }).unwrap();
+
+    let array = json.as_array().unwrap();
+
+    assert_eq!(array.len(), 2);
+}
+
+#[test]
+fn simple_array_of_arrays() {
+    let jedi_array = jedi_array();
+
+    let json = jsonway::array(|json| {
+        json.objects(jedi_array.iter(), |jedi, json| {
+            match jedi.side {
+                Side::Light => {
+                    json.set("name".to_string(), jedi.name.to_string());
+                    json.set("side".to_string(), format!("{:?}", jedi.side));
+                },
+                Side::Dark => json.skip()
+            }
+        })
+    }).unwrap();
+
+    let array = json.as_array().unwrap();
+    assert_eq!(array.len(), 2);
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/.cargo-checksum.json b/rustc_deps/vendor/lazy_static-0.2.11/.cargo-checksum.json
new file mode 100644
index 0000000..ab6a46c
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"b598bd90e0cda5d1d3cec4042310a9e74afbe398a76af48e0d43ea5d3c51f137","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"0621878e61f0d0fda054bcbe02df75192c28bde1ecc8289cbd86aeba2dd72720","README.md":"c305f498e6d89730d84eaf92e980ba001e259dd40fcb40855947baece2af0895","appveyor.yml":"68c8ff7090ffdfa42b3d65b841d5de67d47a2206e02bf97aaca34b4500ae4bf1","src/core_lazy.rs":"2cea85ad0c2c4f88a5a927815a59270411daa4075510fad0faf671d5f5130fed","src/lazy.rs":"52912a897e8fcc95672e3b3068be82d56548f422edcb60e6ce9570779acb5bc0","src/lib.rs":"facd354cb716ee6941bf9bc8d34c27a2ecd752746c4d5164dbec8cedd80df605","src/nightly_lazy.rs":"34080822b27f3968c872867131448df76acc5aeff259852ff86f6e73b5a913b6","tests/compile-fail/README.md":"296216a459b7bf9947ba540c94b71a48ec90c2632ef5f05248a01dc8611ae149","tests/compile-fail/incorrect_visibility_restriction.rs":"557c94f781d6a2fb6c4be32a2ea252752195ff7b7c889581d95c39f2ce45e7d3","tests/compile-fail/static_is_private.rs":"f778f0759529b2dc8360f9abad1e09ea6662493493d707b3fba6cb1cb3d94af2","tests/compile-fail/static_is_sized.rs":"3b6d632f764ccee5fbd413324d7daeb2ab52dec0c99ea1db11a7eb2bbcad37cb","tests/compile-fail/static_never_used.rs":"5139e2459b4c68b0ed3f5a04452f60895b076acb1b5f344fb6b8ccbd50283a2d","tests/compile_tests.rs":"5710b2c0edc7623b895d67c26180a6c1d4022c154ecd616fab449afc9ba95109","tests/no_std.rs":"2a5236bd3892a253855b4dc192f63138239165fa23b9c3421a9faa5482c780aa","tests/test.rs":"12b100f4790037ca049692d896114d6361373c5321c29e0032c290ee39f1042c"},"package":"76f033c7ad61445c5b347c7382dd1237847eb1bce590fe50365dcb33d546be73"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/Cargo.toml b/rustc_deps/vendor/lazy_static-0.2.11/Cargo.toml
new file mode 100644
index 0000000..c25a8a1
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/Cargo.toml
@@ -0,0 +1,43 @@
+# 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 = "lazy_static"
+version = "0.2.11"
+authors = ["Marvin Löbel <loebel.marvin@gmail.com>"]
+description = "A macro for declaring lazily evaluated statics in Rust."
+documentation = "https://docs.rs/lazy_static"
+readme = "README.md"
+keywords = ["macro", "lazy", "static"]
+categories = ["no-std", "rust-patterns", "memory-management"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/rust-lang-nursery/lazy-static.rs"
+[dependencies.compiletest_rs]
+version = "0.3"
+optional = true
+
+[dependencies.spin]
+version = "0.4.6"
+optional = true
+
+[features]
+compiletest = ["compiletest_rs"]
+nightly = []
+spin_no_std = ["nightly", "spin"]
+[badges.appveyor]
+repository = "rust-lang-nursery/lazy-static.rs"
+
+[badges.maintenance]
+status = "passively-maintained"
+
+[badges.travis-ci]
+repository = "rust-lang-nursery/lazy-static.rs"
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/LICENSE-APACHE b/rustc_deps/vendor/lazy_static-0.2.11/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/LICENSE-MIT b/rustc_deps/vendor/lazy_static-0.2.11/LICENSE-MIT
new file mode 100644
index 0000000..25597d5
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2010 The Rust Project Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/README.md b/rustc_deps/vendor/lazy_static-0.2.11/README.md
new file mode 100644
index 0000000..ad5380e
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/README.md
@@ -0,0 +1,69 @@
+lazy-static.rs
+==============
+
+A macro for declaring lazily evaluated statics in Rust.
+
+Using this macro, it is possible to have `static`s that require code to be
+executed at runtime in order to be initialized.
+This includes anything requiring heap allocations, like vectors or hash maps,
+as well as anything that requires non-const function calls to be computed.
+
+[![Travis-CI Status](https://travis-ci.org/rust-lang-nursery/lazy-static.rs.svg?branch=master)](https://travis-ci.org/rust-lang-nursery/lazy-static.rs)
+
+# Getting Started
+
+[lazy-static.rs is available on crates.io](https://crates.io/crates/lazy_static).
+It is recommended to look there for the newest released version, as well as links to the newest builds of the docs.
+
+At the point of the last update of this README, the latest published version could be used like this:
+
+Add the following dependency to your Cargo manifest...
+
+```toml
+[dependencies]
+lazy_static = "0.2"
+```
+
+...and see the [docs](https://docs.rs/lazy_static) for how to use it.
+
+# Example
+
+```rust
+#[macro_use]
+extern crate lazy_static;
+
+use std::collections::HashMap;
+
+lazy_static! {
+    static ref HASHMAP: HashMap<u32, &'static str> = {
+        let mut m = HashMap::new();
+        m.insert(0, "foo");
+        m.insert(1, "bar");
+        m.insert(2, "baz");
+        m
+    };
+}
+
+fn main() {
+    // First access to `HASHMAP` initializes it
+    println!("The entry for `0` is \"{}\".", HASHMAP.get(&0).unwrap());
+
+    // Any further access to `HASHMAP` just returns the computed value
+    println!("The entry for `1` is \"{}\".", HASHMAP.get(&1).unwrap());
+}
+```
+
+## License
+
+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 the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any
+additional terms or conditions.
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/appveyor.yml b/rustc_deps/vendor/lazy_static-0.2.11/appveyor.yml
new file mode 100644
index 0000000..82a726c
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/appveyor.yml
@@ -0,0 +1,59 @@
+environment:
+  global:
+    PROJECT_NAME: lazy_static
+    # When this was added there were revocation check failures when using the
+    # libcurl backend as libcurl checks by default, but rustup doesn't provide the
+    # switch to turn this off. Switch to Hyper which looks to not check for
+    # revocation by default like libcurl does.
+    RUSTUP_USE_REQWEST: 1
+    CARGO_HTTP_CHECK_REVOKE: false
+  matrix:
+    # Stable channel
+    - TARGET: i686-pc-windows-gnu
+      CHANNEL: stable
+    - TARGET: i686-pc-windows-msvc
+      CHANNEL: stable
+    - TARGET: x86_64-pc-windows-gnu
+      CHANNEL: stable
+    - TARGET: x86_64-pc-windows-msvc
+      CHANNEL: stable
+    # Beta channel
+    - TARGET: i686-pc-windows-gnu
+      CHANNEL: beta
+    - TARGET: i686-pc-windows-msvc
+      CHANNEL: beta
+    - TARGET: x86_64-pc-windows-gnu
+      CHANNEL: beta
+    - TARGET: x86_64-pc-windows-msvc
+      CHANNEL: beta
+    # Nightly channel
+    - TARGET: i686-pc-windows-gnu
+      CHANNEL: nightly
+    - TARGET: i686-pc-windows-msvc
+      CHANNEL: nightly
+    - TARGET: x86_64-pc-windows-gnu
+      CHANNEL: nightly
+    - TARGET: x86_64-pc-windows-msvc
+      CHANNEL: nightly
+
+# Install Rust and Cargo
+# (Based on from https://github.com/rust-lang/libc/blob/master/appveyor.yml)
+install:
+  - appveyor-retry appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
+  - rustup-init.exe -y --default-toolchain %CHANNEL% --default-host %TARGET%
+  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
+  - if "%TARGET%" == "i686-pc-windows-gnu" set PATH=%PATH%;C:\msys64\mingw32\bin
+  - if "%TARGET%" == "x86_64-pc-windows-gnu" set PATH=%PATH%;C:\msys64\mingw64\bin
+  - rustc -V
+  - cargo -V
+
+build: false
+
+test_script:
+  - cargo build --verbose
+  - cargo test
+  - if [%CHANNEL%]==[nightly] (
+      cargo clean &&
+      cargo build --verbose --features "compiletest" &&
+      cargo test --features "compiletest"
+    )
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/src/core_lazy.rs b/rustc_deps/vendor/lazy_static-0.2.11/src/core_lazy.rs
new file mode 100644
index 0000000..90c7aaa
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/src/core_lazy.rs
@@ -0,0 +1,33 @@
+// Copyright 2016 lazy-static.rs Developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://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.
+
+extern crate spin;
+
+use self::spin::Once;
+
+pub struct Lazy<T: Sync>(Once<T>);
+
+impl<T: Sync> Lazy<T> {
+    #[inline(always)]
+    pub const fn new() -> Self {
+        Lazy(Once::new())
+    }
+
+    #[inline(always)]
+    pub fn get<F>(&'static self, builder: F) -> &T
+        where F: FnOnce() -> T
+    {
+        self.0.call_once(builder)
+    }
+}
+
+#[macro_export]
+macro_rules! __lazy_static_create {
+    ($NAME:ident, $T:ty) => {
+        static $NAME: $crate::lazy::Lazy<$T> = $crate::lazy::Lazy::new();
+    }
+}
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/src/lazy.rs b/rustc_deps/vendor/lazy_static-0.2.11/src/lazy.rs
new file mode 100644
index 0000000..aab1e05
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/src/lazy.rs
@@ -0,0 +1,39 @@
+// Copyright 2016 lazy-static.rs Developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://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.
+
+extern crate std;
+
+use self::std::prelude::v1::*;
+use self::std::sync::Once;
+pub use self::std::sync::ONCE_INIT;
+
+pub struct Lazy<T: Sync>(pub *const T, pub Once);
+
+impl<T: Sync> Lazy<T> {
+    #[inline(always)]
+    pub fn get<F>(&'static mut self, f: F) -> &T
+        where F: FnOnce() -> T
+    {
+        unsafe {
+            let r = &mut self.0;
+            self.1.call_once(|| {
+                *r = Box::into_raw(Box::new(f()));
+            });
+
+            &*self.0
+        }
+    }
+}
+
+unsafe impl<T: Sync> Sync for Lazy<T> {}
+
+#[macro_export]
+macro_rules! __lazy_static_create {
+    ($NAME:ident, $T:ty) => {
+        static mut $NAME: $crate::lazy::Lazy<$T> = $crate::lazy::Lazy(0 as *const $T, $crate::lazy::ONCE_INIT);
+    }
+}
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/src/lib.rs b/rustc_deps/vendor/lazy_static-0.2.11/src/lib.rs
new file mode 100644
index 0000000..bb15478
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/src/lib.rs
@@ -0,0 +1,212 @@
+// Copyright 2016 lazy-static.rs Developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://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.
+
+/*!
+A macro for declaring lazily evaluated statics.
+
+Using this macro, it is possible to have `static`s that require code to be
+executed at runtime in order to be initialized.
+This includes anything requiring heap allocations, like vectors or hash maps,
+as well as anything that requires function calls to be computed.
+
+# Syntax
+
+```ignore
+lazy_static! {
+    [pub] static ref NAME_1: TYPE_1 = EXPR_1;
+    [pub] static ref NAME_2: TYPE_2 = EXPR_2;
+    ...
+    [pub] static ref NAME_N: TYPE_N = EXPR_N;
+}
+```
+
+Attributes (including doc comments) are supported as well:
+
+```rust
+# #[macro_use]
+# extern crate lazy_static;
+# fn main() {
+lazy_static! {
+    /// This is an example for using doc comment attributes
+    static ref EXAMPLE: u8 = 42;
+}
+# }
+```
+
+# Semantics
+
+For a given `static ref NAME: TYPE = EXPR;`, the macro generates a unique type that
+implements `Deref<TYPE>` and stores it in a static with name `NAME`. (Attributes end up
+attaching to this type.)
+
+On first deref, `EXPR` gets evaluated and stored internally, such that all further derefs
+can return a reference to the same object. Note that this can lead to deadlocks
+if you have multiple lazy statics that depend on each other in their initialization.
+
+Apart from the lazy initialization, the resulting "static ref" variables
+have generally the same properties as regular "static" variables:
+
+- Any type in them needs to fulfill the `Sync` trait.
+- If the type has a destructor, then it will not run when the process exits.
+
+# Example
+
+Using the macro:
+
+```rust
+#[macro_use]
+extern crate lazy_static;
+
+use std::collections::HashMap;
+
+lazy_static! {
+    static ref HASHMAP: HashMap<u32, &'static str> = {
+        let mut m = HashMap::new();
+        m.insert(0, "foo");
+        m.insert(1, "bar");
+        m.insert(2, "baz");
+        m
+    };
+    static ref COUNT: usize = HASHMAP.len();
+    static ref NUMBER: u32 = times_two(21);
+}
+
+fn times_two(n: u32) -> u32 { n * 2 }
+
+fn main() {
+    println!("The map has {} entries.", *COUNT);
+    println!("The entry for `0` is \"{}\".", HASHMAP.get(&0).unwrap());
+    println!("A expensive calculation on a static results in: {}.", *NUMBER);
+}
+```
+
+# Implementation details
+
+The `Deref` implementation uses a hidden static variable that is guarded by a atomic check on each access. On stable Rust, the macro may need to allocate each static on the heap.
+
+*/
+
+#![cfg_attr(feature="spin_no_std", feature(const_fn))]
+#![cfg_attr(feature="nightly", feature(unreachable))]
+
+#![doc(html_root_url = "https://docs.rs/lazy_static/0.2.11")]
+#![no_std]
+
+#[cfg(not(feature="nightly"))]
+#[doc(hidden)]
+pub mod lazy;
+
+#[cfg(all(feature="nightly", not(feature="spin_no_std")))]
+#[path="nightly_lazy.rs"]
+#[doc(hidden)]
+pub mod lazy;
+
+#[cfg(all(feature="nightly", feature="spin_no_std"))]
+#[path="core_lazy.rs"]
+#[doc(hidden)]
+pub mod lazy;
+
+#[doc(hidden)]
+pub use core::ops::Deref as __Deref;
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! __lazy_static_internal {
+    // optional visibility restrictions are wrapped in `()` to allow for
+    // explicitly passing otherwise implicit information about private items
+    ($(#[$attr:meta])* ($($vis:tt)*) static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
+        __lazy_static_internal!(@MAKE TY, $(#[$attr])*, ($($vis)*), $N);
+        __lazy_static_internal!(@TAIL, $N : $T = $e);
+        lazy_static!($($t)*);
+    };
+    (@TAIL, $N:ident : $T:ty = $e:expr) => {
+        impl $crate::__Deref for $N {
+            type Target = $T;
+            #[allow(unsafe_code)]
+            fn deref(&self) -> &$T {
+                unsafe {
+                    #[inline(always)]
+                    fn __static_ref_initialize() -> $T { $e }
+
+                    #[inline(always)]
+                    unsafe fn __stability() -> &'static $T {
+                        __lazy_static_create!(LAZY, $T);
+                        LAZY.get(__static_ref_initialize)
+                    }
+                    __stability()
+                }
+            }
+        }
+        impl $crate::LazyStatic for $N {
+            fn initialize(lazy: &Self) {
+                let _ = &**lazy;
+            }
+        }
+    };
+    // `vis` is wrapped in `()` to prevent parsing ambiguity
+    (@MAKE TY, $(#[$attr:meta])*, ($($vis:tt)*), $N:ident) => {
+        #[allow(missing_copy_implementations)]
+        #[allow(non_camel_case_types)]
+        #[allow(dead_code)]
+        $(#[$attr])*
+        $($vis)* struct $N {__private_field: ()}
+        #[doc(hidden)]
+        $($vis)* static $N: $N = $N {__private_field: ()};
+    };
+    () => ()
+}
+
+#[macro_export]
+macro_rules! lazy_static {
+    ($(#[$attr:meta])* static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
+        // use `()` to explicitly forward the information about private items
+        __lazy_static_internal!($(#[$attr])* () static ref $N : $T = $e; $($t)*);
+    };
+    ($(#[$attr:meta])* pub static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
+        __lazy_static_internal!($(#[$attr])* (pub) static ref $N : $T = $e; $($t)*);
+    };
+    ($(#[$attr:meta])* pub ($($vis:tt)+) static ref $N:ident : $T:ty = $e:expr; $($t:tt)*) => {
+        __lazy_static_internal!($(#[$attr])* (pub ($($vis)+)) static ref $N : $T = $e; $($t)*);
+    };
+    () => ()
+}
+
+/// Support trait for enabling a few common operation on lazy static values.
+///
+/// This is implemented by each defined lazy static, and
+/// used by the free functions in this crate.
+pub trait LazyStatic {
+    #[doc(hidden)]
+    fn initialize(lazy: &Self);
+}
+
+/// Takes a shared reference to a lazy static and initializes
+/// it if it has not been already.
+///
+/// This can be used to control the initialization point of a lazy static.
+///
+/// Example:
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate lazy_static;
+///
+/// lazy_static! {
+///     static ref BUFFER: Vec<u8> = (0..65537).collect();
+/// }
+///
+/// fn main() {
+///     lazy_static::initialize(&BUFFER);
+///
+///     // ...
+///     work_with_initialized_data(&BUFFER);
+/// }
+/// # fn work_with_initialized_data(_: &[u8]) {}
+/// ```
+pub fn initialize<T: LazyStatic>(lazy: &T) {
+    LazyStatic::initialize(lazy);
+}
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/src/nightly_lazy.rs b/rustc_deps/vendor/lazy_static-0.2.11/src/nightly_lazy.rs
new file mode 100644
index 0000000..0ad0f66
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/src/nightly_lazy.rs
@@ -0,0 +1,43 @@
+// Copyright 2016 lazy-static.rs Developers
+//
+// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
+// http://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.
+
+extern crate std;
+
+use self::std::prelude::v1::*;
+use self::std::sync::Once;
+pub use self::std::sync::ONCE_INIT;
+
+pub struct Lazy<T: Sync>(pub Option<T>, pub Once);
+
+impl<T: Sync> Lazy<T> {
+    #[inline(always)]
+    pub fn get<F>(&'static mut self, f: F) -> &T
+        where F: FnOnce() -> T
+    {
+        {
+            let r = &mut self.0;
+            self.1.call_once(|| {
+                *r = Some(f());
+            });
+        }
+        unsafe {
+            match self.0 {
+                Some(ref x) => x,
+                None => std::mem::unreachable(),
+            }
+        }
+    }
+}
+
+unsafe impl<T: Sync> Sync for Lazy<T> {}
+
+#[macro_export]
+macro_rules! __lazy_static_create {
+    ($NAME:ident, $T:ty) => {
+        static mut $NAME: $crate::lazy::Lazy<$T> = $crate::lazy::Lazy(None, $crate::lazy::ONCE_INIT);
+    }
+}
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/README.md b/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/README.md
new file mode 100644
index 0000000..7f80d11
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/README.md
@@ -0,0 +1,22 @@
+This directory contains snippets of code that should yield a
+warning/note/help/error at compilation. Syntax of annotations is described in
+[rust documentation](https://github.com/rust-lang/rust/blob/master/src/test/COMPILER_TESTS.md).
+For more information check out [`compiletest` crate](https://github.com/laumann/compiletest-rs).
+
+To run compile tests issue `cargo +nightly --test --features compiletest`.
+
+## Notes on working with `compiletest` crate
+
+* Currently code that is inside macro should not be annotated, as `compiletest`
+    crate cannot deal with the fact that macro invocations effectively changes
+    line numbering. To prevent this add a `// error-pattern:<your error message here>`
+    on the top of the file and make sure that you set `deny` lint level
+    if you want to test compiler message different than error.
+* `compiletest` crate by default sets `allow(dead_code)` lint level so make sure
+    that you change it to something suiting your needs even if the warning is
+    issued prior to any macro invocation.
+* If you get a message `error: 0 unexpected errors found, 1 expected errors not found`
+  despite the fact that some error was bound to occur don't worry - it's a known
+  issue in the `compiletest` crate and your error was probably not registered -
+  make sure that your annotations are correct and that you are setting correct
+  lint levels.
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/incorrect_visibility_restriction.rs b/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/incorrect_visibility_restriction.rs
new file mode 100644
index 0000000..e2e5238
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/incorrect_visibility_restriction.rs
@@ -0,0 +1,10 @@
+// incorrect visibility restriction
+#[macro_use]
+extern crate lazy_static;
+
+lazy_static! {
+    pub(nonsense) static ref WRONG: () = ();
+    //~^ ERROR incorrect visibility restriction
+}
+
+fn main() { }
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/static_is_private.rs b/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/static_is_private.rs
new file mode 100644
index 0000000..a88c1c6
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/static_is_private.rs
@@ -0,0 +1,14 @@
+#[macro_use]
+extern crate lazy_static;
+
+mod outer {
+    pub mod inner {
+        lazy_static! {
+            pub(in outer) static ref FOO: () = ();
+        }
+    }
+}
+
+fn main() {
+    assert_eq!(*outer::inner::FOO, ()); //~ ERROR static `FOO` is private
+}
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/static_is_sized.rs b/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/static_is_sized.rs
new file mode 100644
index 0000000..3681ad7
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/static_is_sized.rs
@@ -0,0 +1,11 @@
+// error-pattern:the trait bound `str: std::marker::Sized` is not satisfied
+#[macro_use]
+extern crate lazy_static;
+
+lazy_static! {
+    pub static ref FOO: str = panic!();
+}
+
+
+fn main() {
+}
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/static_never_used.rs b/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/static_never_used.rs
new file mode 100644
index 0000000..a611778
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/tests/compile-fail/static_never_used.rs
@@ -0,0 +1,10 @@
+// error-pattern:static item is never used: `UNUSED`
+#![deny(dead_code)]
+#[macro_use]
+extern crate lazy_static;
+
+lazy_static! {
+    static ref UNUSED: () = ();
+}
+
+fn main() { }
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/tests/compile_tests.rs b/rustc_deps/vendor/lazy_static-0.2.11/tests/compile_tests.rs
new file mode 100644
index 0000000..3e347d5
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/tests/compile_tests.rs
@@ -0,0 +1,18 @@
+#![cfg(feature="compiletest")]
+extern crate compiletest_rs as compiletest;
+
+fn run_mode(mode: &'static str) {
+    let mut config = compiletest::Config::default();
+    config.mode = mode.parse().expect("Invalid mode");
+    config.src_base = ["tests", mode].iter().collect();
+    config.target_rustcflags = Some("-L target/debug/ -L target/debug/deps/".to_owned());
+
+    config.verbose = true;
+
+    compiletest::run_tests(&config);
+}
+
+#[test]
+fn compile_test() {
+    run_mode("compile-fail");
+}
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/tests/no_std.rs b/rustc_deps/vendor/lazy_static-0.2.11/tests/no_std.rs
new file mode 100644
index 0000000..b460e79
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/tests/no_std.rs
@@ -0,0 +1,21 @@
+#![cfg(feature="spin_no_std")]
+#![feature(const_fn)]
+
+#![no_std]
+
+#[macro_use]
+extern crate lazy_static;
+
+lazy_static! {
+    /// Documentation!
+    pub static ref NUMBER: u32 = times_two(3);
+}
+
+fn times_two(n: u32) -> u32 {
+    n * 2
+}
+
+#[test]
+fn test_basic() {
+    assert_eq!(*NUMBER, 6);
+}
diff --git a/rustc_deps/vendor/lazy_static-0.2.11/tests/test.rs b/rustc_deps/vendor/lazy_static-0.2.11/tests/test.rs
new file mode 100644
index 0000000..fbf225d
--- /dev/null
+++ b/rustc_deps/vendor/lazy_static-0.2.11/tests/test.rs
@@ -0,0 +1,164 @@
+#![cfg_attr(feature="nightly", feature(const_fn))]
+
+#[macro_use]
+extern crate lazy_static;
+use std::collections::HashMap;
+
+lazy_static! {
+    /// Documentation!
+    pub static ref NUMBER: u32 = times_two(3);
+
+    static ref ARRAY_BOXES: [Box<u32>; 3] = [Box::new(1), Box::new(2), Box::new(3)];
+
+    /// More documentation!
+    #[allow(unused_variables)]
+    #[derive(Copy, Clone, Debug)]
+    pub static ref STRING: String = "hello".to_string();
+
+    static ref HASHMAP: HashMap<u32, &'static str> = {
+        let mut m = HashMap::new();
+        m.insert(0, "abc");
+        m.insert(1, "def");
+        m.insert(2, "ghi");
+        m
+    };
+
+    // This should not compile if the unsafe is removed.
+    static ref UNSAFE: u32 = unsafe {
+        std::mem::transmute::<i32, u32>(-1)
+    };
+}
+
+lazy_static! {
+    static ref S1: &'static str = "a";
+    static ref S2: &'static str = "b";
+}
+lazy_static! {
+    static ref S3: String = [*S1, *S2].join("");
+}
+
+#[test]
+fn s3() {
+    assert_eq!(&*S3, "ab");
+}
+
+fn times_two(n: u32) -> u32 {
+    n * 2
+}
+
+#[test]
+fn test_basic() {
+    assert_eq!(&**STRING, "hello");
+    assert_eq!(*NUMBER, 6);
+    assert!(HASHMAP.get(&1).is_some());
+    assert!(HASHMAP.get(&3).is_none());
+    assert_eq!(&*ARRAY_BOXES, &[Box::new(1), Box::new(2), Box::new(3)]);
+    assert_eq!(*UNSAFE, std::u32::MAX);
+}
+
+#[test]
+fn test_repeat() {
+    assert_eq!(*NUMBER, 6);
+    assert_eq!(*NUMBER, 6);
+    assert_eq!(*NUMBER, 6);
+}
+
+#[test]
+fn test_meta() {
+    // this would not compile if STRING were not marked #[derive(Copy, Clone)]
+    let copy_of_string = STRING;
+    // just to make sure it was copied
+    assert!(&STRING as *const _ != &copy_of_string as *const _);
+
+    // this would not compile if STRING were not marked #[derive(Debug)]
+    assert_eq!(format!("{:?}", STRING), "STRING { __private_field: () }".to_string());
+}
+
+mod visibility {
+    lazy_static! {
+        pub static ref FOO: Box<u32> = Box::new(0);
+        static ref BAR: Box<u32> = Box::new(98);
+    }
+
+    pub mod inner {
+        lazy_static! {
+            pub(in visibility) static ref BAZ: Box<u32> = Box::new(42);
+            pub(crate) static ref BAG: Box<u32> = Box::new(37);
+        }
+    }
+
+    #[test]
+    fn sub_test() {
+        assert_eq!(**FOO, 0);
+        assert_eq!(**BAR, 98);
+        assert_eq!(**inner::BAZ, 42);
+        assert_eq!(**inner::BAG, 37);
+    }
+}
+
+#[test]
+fn test_visibility() {
+    assert_eq!(*visibility::FOO, Box::new(0));
+    assert_eq!(*visibility::inner::BAG, Box::new(37));
+}
+
+// This should not cause a warning about a missing Copy implementation
+lazy_static! {
+    pub static ref VAR: i32 = { 0 };
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+struct X;
+struct Once(X);
+const ONCE_INIT: Once = Once(X);
+static DATA: X = X;
+static ONCE: X = X;
+fn require_sync() -> X { X }
+fn transmute() -> X { X }
+fn __static_ref_initialize() -> X { X }
+fn test(_: Vec<X>) -> X { X }
+
+// All these names should not be shadowed
+lazy_static! {
+    static ref ITEM_NAME_TEST: X = {
+        test(vec![X, Once(X).0, ONCE_INIT.0, DATA, ONCE,
+                  require_sync(), transmute(),
+                  // Except this, which will sadly be shadowed by internals:
+                  // __static_ref_initialize()
+                  ])
+    };
+}
+
+#[test]
+fn item_name_shadowing() {
+    assert_eq!(*ITEM_NAME_TEST, X);
+}
+
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::ATOMIC_BOOL_INIT;
+use std::sync::atomic::Ordering::SeqCst;
+
+static PRE_INIT_FLAG: AtomicBool = ATOMIC_BOOL_INIT;
+
+lazy_static! {
+    static ref PRE_INIT: () = {
+        PRE_INIT_FLAG.store(true, SeqCst);
+        ()
+    };
+}
+
+#[test]
+fn pre_init() {
+    assert_eq!(PRE_INIT_FLAG.load(SeqCst), false);
+    lazy_static::initialize(&PRE_INIT);
+    assert_eq!(PRE_INIT_FLAG.load(SeqCst), true);
+}
+
+lazy_static! {
+    static ref LIFETIME_NAME: for<'a> fn(&'a u8) = { fn f(_: &u8) {} f };
+}
+
+#[test]
+fn lifetime_name() {
+    let _ = LIFETIME_NAME;
+}
diff --git a/rustc_deps/vendor/uuid/.cargo-checksum.json b/rustc_deps/vendor/uuid/.cargo-checksum.json
new file mode 100644
index 0000000..0561a28
--- /dev/null
+++ b/rustc_deps/vendor/uuid/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CODEOWNERS":"65d3fcb4156a2d5bce80d382a34044753e384d7f1eb71cdc646de400a0b969c8","CODE_OF_CONDUCT.md":"7d9c9062ee835c2dfd348cfddb938c563f3a7b1140dd090444a03ea1d73626b1","CONTRIBUTING.md":"cb8fa34c1d15542a318a7cbe3cd41d364f6100d49043825413f3ebb4c7471c99","COPYRIGHT":"b4b2c0de2a05de3372d5c828128413ce82bb7dba2272487b7729f09cc3d3519d","Cargo.toml":"71a942d30769089e36cbe32fade63a078961f3cab23d41ab87f5c8e8efcd9348","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"436bc5a105d8e57dcd8778730f3754f7bf39c14d2f530e4cde4bd2d17a83ec3d","README.md":"01e0a86cc2b9f29fbef04623e3f8e8ca46252fd8d5360b83780fa816f6012011","benches/format_str.rs":"2bcff80d8ab03c83ccc61c756f75a0c7aead821f68b29eeaf38f4ba6344bfc6e","benches/invalid_parse_str.rs":"7f44d2ebec6ee1368d179f12dd09a288d589b252434082b2de134a658b460812","benches/mod.rs":"4733d7aa62dafe3e85ab90dca518b57f350a5538ea5643c5313e63939e884a45","benches/serde_support.rs":"afc719718c9a5d705b60bc9cd39720b921d9ee63ccf11c4b2900f02beea70c1b","benches/slog_support/mod.rs":"1be626f0a6921f4e6bd333ce7ab4a6c4da1fb6f3ae1c503672b4ba168a70c01d","benches/slog_support/parse_str.rs":"9c63ee7047ac8b9d08f02b7081020dd7300f84f302068927c859bbe26cea66a3","benches/valid_parse_str.rs":"7db47c7d25b20c8da03f25107fbea2b5c97fc814ff226e8489eda374f477eeac","src/adapter/core_support/mod.rs":"65bebe5034e450782ec9b0942bd4d758795ee315095fcc3f54412630a987f938","src/adapter/mod.rs":"8f3acffda66148a7095286309f32b823c66826bfe35742fbc63bf1a1e07365a5","src/core_support.rs":"f5c83e3e16a32ae93c76e0e1699f3a07872788e782ce5ee4c2f8229a06a871c8","src/lib.rs":"1d0492819a93dc386e90659a21f6231a01dd172552a1221a298c089db7c671b1","src/parser/core_support.rs":"a8621aa837da2f4cd82f86539c2f3f153c52fcea21c223aa098e5873cbf36d0f","src/parser/mod.rs":"51526e211c95730c830512007da23dfc9f88d1feccc9ddf881c541c1d5e01e2a","src/parser/std_support.rs":"4398d708bd42e8d3cb31eed8ada92615fb1cbfc70bfb3c7cbe952f47c7fe1183","src/prelude.rs":"89553bb9a75e3801698f57fcc099235e5213452738cace4ab190d9444a1adfa4","src/serde_support.rs":"fdc5be309b9fc062832f3a2b114d7a06e8c8357f6569796ed1fc7848a5ebc155","src/slog_support.rs":"370f891a73f99436baecd21f5f2b7d7c89842336aad99167b07ca3f03c48a70c","src/std_support.rs":"50d2bdaaae64e4d22d9180404ac8600944683dcdc51d7de6587a6fdb29193a70","src/test_util.rs":"1dfc1ab68bb403dd6d696fafeb7c00be59c37b51155703f3033ebf1062dd629f","src/u128_support.rs":"97ca20af9117e44bad72f987488efb0173699a22e0c646b268e0fe3dd90355a7","src/v1.rs":"82654b0cadfa56fd0140d78db5ab2d9869ea3d8eaaede0b975d42904317e9da4","src/v3.rs":"d25899b070bd791bc2b784d828399f5bce25f77300765dfd96e76583f31047f3","src/v4.rs":"0cc02041d1215826e9fa2493fb4d97b1d15bc4925450db22eba86123680586ef","src/v5.rs":"11aeea13d38c5e3c5d7cc8bf571ac1ce57a0d46f363b90a991ed43dc1cc9caaa"},"package":"dab5c5526c5caa3d106653401a267fed923e7046f35895ffcb5ca42db64942e6"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/uuid/CODEOWNERS b/rustc_deps/vendor/uuid/CODEOWNERS
new file mode 100644
index 0000000..f20b688
--- /dev/null
+++ b/rustc_deps/vendor/uuid/CODEOWNERS
@@ -0,0 +1,16 @@
+# CI
+.travis.yml     @kinggoesgaming @KodrAus @Dylan-DPC @radix
+appveyor.yml    @kinggoesgaming @KodrAus @Dylan-DPC @radix
+
+# Cargo.toml
+Cargo.toml      @kinggoesgaming @KodrAus @Dylan-DPC @radix
+
+# Rust
+*.rs            @kinggoesgaming @KodrAus @Dylan-DPC @radix
+
+# CODEOWNERS
+CODEOWNERS      @kinggoesgaming @KodrAus @Dylan-DPC @radix
+
+#>> Critical
+# bors.toml file
+bors.toml       @kinggoesgaming @KodrAus @Dylan-DPC @radix
diff --git a/rustc_deps/vendor/uuid/CODE_OF_CONDUCT.md b/rustc_deps/vendor/uuid/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..7f5c4fe
--- /dev/null
+++ b/rustc_deps/vendor/uuid/CODE_OF_CONDUCT.md
@@ -0,0 +1,77 @@
+# Contributor Covenant Code of Conduct
+
+The latest version of the CODE OF CONDUCT can be found [here].
+
+[here]: https://github.com/uuid-rs/conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+education, socio-economic status, nationality, personal appearance, race,
+religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at report@uuid-rs.groups.io. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html
+
+[homepage]: https://www.contributor-covenant.org
\ No newline at end of file
diff --git a/rustc_deps/vendor/uuid/CONTRIBUTING.md b/rustc_deps/vendor/uuid/CONTRIBUTING.md
new file mode 100644
index 0000000..1d085ca
--- /dev/null
+++ b/rustc_deps/vendor/uuid/CONTRIBUTING.md
@@ -0,0 +1,149 @@
+Contributing to Uuid
+---
+[Contributing to Uuid]: #contributing-to-uuid
+
+Thank you for your interest in contributing to the Uuid Project!
+
+* [Feature Requests](#feature-requests)
+* [Bug Reports](#bug-reports)
+* [Pull Requests](#pull-requests)
+* [Writing Documentation](#writing-documentation)
+* [Issue Triage](#issue-triage)
+* [Out-of-tree Contributions](#out-of-tree-contributions)
+* [Helpful Links](#helpful-links)
+
+For any questions, please make a post on [users.rust-lang.org][u-r-l-o], post
+on [uuid-rs mailing list] or join our [gitter] channel.
+
+> All contributors need to follow our [Code of Conduct].
+
+[Code of Conduct]: CODE_OF_CONDUCT.md
+
+# Feature Requests
+[Feature Requests]: #feature-requests
+
+The `uuid` crate is still in flux. All features desired may not be present. As
+such you are welcome to request for new features. Keep in mind that `uuid` is
+a general purpose library. We want to provide features that most users would
+find useful. As such not every feature may be accepted.
+
+If you have the chance, please [search existing issues], as there is a chance
+that someone has already requested your feature.
+
+File your feature request with a descriptive title, as this helps others find
+your request.
+
+You can request your feature by following [this link][Feature Request Link] and
+filling it in. 
+
+> We welcome pull requests for your own feature requests, provided they have
+been discussed.
+
+[Feature Request Link]: https://github.com/uuid-rs/uuid/issues/new?template=Feature_request.md
+
+# Bug Reports
+[Bug Reports]: #bug-reports
+
+While no one likes bugs, they are an unfortunate reality in software. Remember
+we can't fix bugs we don't know about, so don't be shy about reporting.
+
+If you have the chance, please [search existing issues], as there is a chance
+that someone has already reported your error. This isn't strictly needed, as
+sometimes you might not what exactly you are looking for.
+
+File your issue with a descriptive title, as this helps others find your issue.
+
+Reporting a bug is as easy as following [this link][Bug Report Link] and
+filling it in.
+
+Sometimes a backtrace may be needed. In that case, set `RUST_BACKTRACE`
+environment variable to `1`. For example:
+
+```bash
+$ RUST_BACKTRACE=1 cargo build
+```
+
+> We welcome pull requests for your own bug reports, provided they have been
+discussed.
+
+[Bug Report Link]: https://github.com/uuid-rs/uuid/issues/new?template=Bug_report.md
+
+# Pull Requests
+[Pull Requests]: #pull-requests
+
+Pull requests(PRs) are the primary mechanism we use to change Uuid. GitHub itself
+has some [great documentation] on using the Pull Request feature. We use the
+"fork and pull" model described [here][fnp], where contributors push changes to
+their personal fork and create pull requests to bring those changes into the
+source repository.
+
+Unless the changes are fairly minor (like documentation changes or tiny
+patches), we require PRs to relevant issues.
+
+Please open PRs against branch:
+* `master` when making non-breaking changes 
+* `breaking` when your changes alter the public API in a breaking manner
+
+If the pull request is still a work in progress, prepend`[WIP] ` in your 
+title. `WIP bot` will make sure that the PR doesn't accidentally get merged.
+
+> Uuid Project has a minimum rust version policy. Currently `uuid` should 
+compile with atleast `1.18.0`, and is enforced on our CI builds.
+
+When you feel that the PR is ready, please ping one of the maintainers so
+they can review your changes.
+
+[great documentation]: https://help.github.com/articles/about-pull-requests/
+[fnp]: https://help.github.com/articles/about-collaborative-development-models/
+
+# Writing Documentation
+[Writing Documentation]: #writing-documentation
+
+Documentation is an important part of Uuid. Lackluster or incorrect
+documentation can cause headaches for the users of `uuid`. Therefore,
+improvements to documentation are always welcome.
+
+We follow the documentation style guidelines as given by [RFC 1574].
+
+[RFC 1574]: https://github.com/rust-lang/rfcs/blob/master/text/1574-more-api-documentation-conventions.md#appendix-a-full-conventions-text
+
+# Issue Triage
+[Issue Triage]: #issue-triage
+
+Sometimes, an issue might stay open even after the relevant bug has been fixed.
+Other times, the bug report may become invalid. Or we may just forget about the
+bug.
+
+You can help to go through old bug reports and check if they are still valid.
+You can follow [this link][lrus] to look for issues like this.
+
+[lrus]: https://github.com/uuid-rs/uuid/issues?q=is%3Aissue+is%3Aopen+sort%3Aupdated-asc
+
+# Out-of-tree Contributions
+[Out-of-tree Contributions]: #out-of-tree-contributions
+
+You can contribute to Uuid in other ways:
+
+* Answer questions on [users.rust-lang.org][u-r-l-o], [uuid-rs mailing list] and/or
+[gitter] channel.
+* Find the [crates depending on `uuid`][dependent] and sending PRs to them,
+helping them keep their version of `uuid` up-to-date.
+
+[dependent]: https://crates.io/crates/uuid/reverse_dependencies
+
+# Helpful Links
+[Helpful Links]: #helpful-links
+
+For people new to Uuid, and just starting to contribute, or even for more
+seasoned developers, some useful places to look for information are:
+
+* The Wikipedia entry on [Universally Unique Identifier][wiki-uuid].
+* [RFC 4122] which gives the specification of Uuids.
+
+[wiki-uuid]: https://en.wikipedia.org/wiki/Universally_unique_identifier
+[RFC 4122]: https://www.ietf.org/rfc/rfc4122.txt
+
+[u-r-l-o]: https://users.rust-lang.org
+[uuid-rs mailing list]: https://uuid-rs.groups.io
+[gitter]: https://gitter.im/uuid-rs/Lobby
+[search existing issues]: https://github.com/uuid-rs/uuid/search?q=&type=Issues&utf8=%E2%9C%93
diff --git a/rustc_deps/vendor/uuid/COPYRIGHT b/rustc_deps/vendor/uuid/COPYRIGHT
new file mode 100644
index 0000000..925929c
--- /dev/null
+++ b/rustc_deps/vendor/uuid/COPYRIGHT
@@ -0,0 +1,8 @@
+The Uuid Project is copyright 2013-2014, The Rust Project Developers and
+copyright 2018, The Uuid 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. All files in the project
+carrying such notice may not be copied, modified, or distributed except
+according to those terms.
diff --git a/rustc_deps/vendor/uuid/Cargo.toml b/rustc_deps/vendor/uuid/Cargo.toml
new file mode 100644
index 0000000..aa95e11
--- /dev/null
+++ b/rustc_deps/vendor/uuid/Cargo.toml
@@ -0,0 +1,73 @@
+# 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 = "uuid"
+version = "0.7.1"
+authors = ["Ashley Mannix<ashleymannix@live.com.au>", "Christopher Armstrong", "Dylan DPC<dylan.dpc@gmail.com>", "Hunar Roop Kahlon<hunar.roop@gmail.com>"]
+exclude = [".github/**", ".travis.yml", "appveyor.yml", "bors.toml"]
+description = "A library to generate and parse UUIDs."
+homepage = "https://github.com/uuid-rs/uuid"
+documentation = "https://docs.rs/uuid"
+readme = "README.md"
+license = "Apache-2.0 OR MIT"
+repository = "https://github.com/uuid-rs/uuid"
+[package.metadata.docs.rs]
+all-features = true
+
+[package.metadata.playground]
+features = ["serde", "u128", "v1", "v3", "v4", "v5"]
+[dependencies.byteorder]
+version = "1"
+features = ["i128"]
+optional = true
+default-features = false
+
+[dependencies.md5]
+version = "0.3"
+optional = true
+
+[dependencies.rand]
+version = "0.5"
+optional = true
+
+[dependencies.serde]
+version = "1.0.56"
+optional = true
+default-features = false
+
+[dependencies.sha1]
+version = "0.6"
+optional = true
+
+[dependencies.slog]
+version = "2"
+optional = true
+[dev-dependencies.bincode]
+version = "1.0"
+
+[dev-dependencies.serde_json]
+version = "1.0"
+
+[dev-dependencies.serde_test]
+version = "1.0.56"
+
+[features]
+const_fn = ["nightly"]
+default = ["std"]
+nightly = []
+std = []
+u128 = ["byteorder"]
+v1 = []
+v3 = ["md5", "rand"]
+v4 = ["rand"]
+v5 = ["sha1", "rand"]
diff --git a/rustc_deps/vendor/uuid/LICENSE-APACHE b/rustc_deps/vendor/uuid/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/rustc_deps/vendor/uuid/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/rustc_deps/vendor/uuid/LICENSE-MIT b/rustc_deps/vendor/uuid/LICENSE-MIT
new file mode 100644
index 0000000..99a3078
--- /dev/null
+++ b/rustc_deps/vendor/uuid/LICENSE-MIT
@@ -0,0 +1,26 @@
+Copyright (c) 2014 The Rust Project Developers
+Copyright (c) 2018 Ashley Mannix, Christopher Armstrong, Dylan DPC, Hunar Roop Kahlon
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/rustc_deps/vendor/uuid/README.md b/rustc_deps/vendor/uuid/README.md
new file mode 100644
index 0000000..e5ff5c9
--- /dev/null
+++ b/rustc_deps/vendor/uuid/README.md
@@ -0,0 +1,109 @@
+uuid
+====
+
+[![Build Status](https://travis-ci.org/uuid-rs/uuid.svg?branch=master)](https://travis-ci.org/uuid-rs/uuid) 
+[![Appveyor Status](https://ci.appveyor.com/api/projects/status/github/uuid-rs/uuid?branch=master&svg=true)](https://ci.appveyor.com/project/KodrAus/uuid) 
+[![Latest Version](https://img.shields.io/crates/v/uuid.svg)](https://crates.io/crates/uuid) 
+[![Join the chat at https://gitter.im/uuid-rs/Lobby](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/uuid-rs/Lobby?utm_source=badge&utm_medium=badge&utm_content=badge)
+![Minimum rustc version](https://img.shields.io/badge/rustc-1.22.0+-yellow.svg)
+
+A Rust library to generate and parse UUIDs.
+
+Provides support for Universally Unique Identifiers (UUIDs). A UUID is a unique
+128-bit number, stored as 16 octets. UUIDs are used to assign unique identifiers
+to entities without requiring a central allocating authority.
+
+They are particularly useful in distributed systems, though can be used in
+disparate areas, such as databases and network protocols. Typically a UUID is
+displayed in a readable string form as a sequence of hexadecimal digits,
+separated into groups by hyphens.
+
+The uniqueness property is not strictly guaranteed, however for all practical
+purposes, it can be assumed that an unintentional collision would be extremely
+unlikely.
+
+[Documentation](https://docs.rs/uuid)
+
+## Usage
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+uuid = "0.7"
+```
+
+and this to your crate root:
+
+```rust
+extern crate uuid;
+```
+
+## Examples
+
+To parse a simple UUID, then print the version and urn string format:
+
+```rust
+extern crate uuid;
+use uuid::Uuid;
+
+fn main() {
+    let my_uuid = Uuid::parse_str("936DA01F9ABD4d9d80C702AF85C822A8").unwrap();
+    println!("Parsed a version {} UUID.", my_uuid.get_version_num());
+    println!("{}", my_uuid);
+}
+```
+
+The library supports 5 versions of UUID:
+
+Name     | Version
+---------|----------
+Mac      | Version 1: MAC address
+Dce      | Version 2: DCE Security
+Md5      | Version 3: MD5 hash
+Random   | Version 4: Random
+Sha1     | Version 5: SHA-1 hash
+
+To create a new random (V4) UUID and print it out in hexadecimal form, first
+you'll need to change how you depend on `uuid`:
+
+```toml
+[dependencies]
+uuid = { version = "0.7", features = ["v4"] }
+```
+
+Next, you'll write:
+
+```rust
+extern crate uuid;
+use uuid::Uuid;
+
+fn main() {
+    let my_uuid = Uuid::new_v4();
+    println!("{}", my_uuid);
+}
+```
+
+To create a new sha1-hash based (V5) UUID and print it out in hexadecimal form,
+you'll also need to change how you depend on `uuid`:
+
+```toml
+[dependencies]
+uuid = { version = "0.7", features = ["v5"] }
+```
+
+Next, you'll write:
+
+```rust
+extern crate uuid;
+use uuid::Uuid;
+
+fn main() {
+    let my_uuid = Uuid::new_v5(&Uuid::NAMESPACE_DNS, "foo".as_bytes());
+    println!("{}", my_uuid);
+}
+```
+
+## References
+
+[Wikipedia: Universally Unique Identifier](https://en.wikipedia.org/wiki/Universally_unique_identifier)
diff --git a/rustc_deps/vendor/uuid/benches/format_str.rs b/rustc_deps/vendor/uuid/benches/format_str.rs
new file mode 100755
index 0000000..0d06c90
--- /dev/null
+++ b/rustc_deps/vendor/uuid/benches/format_str.rs
@@ -0,0 +1,67 @@
+#![feature(test)]
+extern crate test;
+extern crate uuid;
+
+use std::io::Write;
+use test::Bencher;
+use uuid::prelude::*;
+
+#[bench]
+fn bench_hyphen(b: &mut Bencher) {
+    let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap();
+    b.iter(|| {
+        let mut buffer = [0_u8; 36];
+        write!(&mut buffer as &mut [_], "{:x}", uuid.to_hyphenated()).unwrap();
+        test::black_box(buffer);
+    });
+}
+
+#[bench]
+fn bench_simple(b: &mut Bencher) {
+    let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap();
+    b.iter(|| {
+        let mut buffer = [0_u8; 32];
+        write!(&mut buffer as &mut [_], "{:x}", uuid.to_simple()).unwrap();
+        test::black_box(buffer);
+    })
+}
+
+#[bench]
+fn bench_urn(b: &mut Bencher) {
+    let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap();
+    b.iter(|| {
+        let mut buffer = [0_u8; 36 + 9];
+        write!(&mut buffer as &mut [_], "{:x}", uuid.to_urn()).unwrap();
+        test::black_box(buffer);
+    })
+}
+
+#[bench]
+fn bench_encode_hyphen(b: &mut Bencher) {
+    let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap();
+    b.iter(|| {
+        let mut buffer = [0_u8; 36];
+        // uuid.to_hyphenated().encode_lower(&mut buffer);
+        test::black_box(buffer);
+    });
+}
+
+#[bench]
+fn bench_encode_simple(b: &mut Bencher) {
+    let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap();
+    b.iter(|| {
+        let mut buffer = [0_u8; 32];
+        // uuid.to_simple().encode_lower(&mut buffer);
+        test::black_box(buffer);
+    })
+}
+
+#[bench]
+fn bench_encode_urn(b: &mut Bencher) {
+    let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap();
+    b.iter(|| {
+        let mut buffer = [0_u8; 36 + 9];
+        // uuid.to_urn().encode_lower(&mut buffer);
+        test::black_box(buffer);
+    })
+}
diff --git a/rustc_deps/vendor/uuid/benches/invalid_parse_str.rs b/rustc_deps/vendor/uuid/benches/invalid_parse_str.rs
new file mode 100644
index 0000000..4363f70
--- /dev/null
+++ b/rustc_deps/vendor/uuid/benches/invalid_parse_str.rs
@@ -0,0 +1,64 @@
+#![feature(test)]
+#[cfg(feature = "slog")]
+#[macro_use]
+extern crate slog;
+extern crate test;
+extern crate uuid;
+
+#[cfg(feature = "slog")]
+use slog::Drain;
+use test::Bencher;
+use uuid::prelude::*;
+
+#[bench]
+fn bench_parse_invalid_strings(b: &mut Bencher) {
+    b.iter(|| {
+        let _ = Uuid::parse_str("");
+        let _ = Uuid::parse_str("!");
+        let _ = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E45");
+        let _ = Uuid::parse_str("F9168C5E-CEB2-4faa-BBF-329BF39FA1E4");
+        let _ = Uuid::parse_str("F9168C5E-CEB2-4faa-BGBF-329BF39FA1E4");
+        let _ = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BFF329BF39FA1E4");
+        let _ = Uuid::parse_str("F9168C5E-CEB2-4faa");
+        let _ = Uuid::parse_str("F9168C5E-CEB2-4faaXB6BFF329BF39FA1E4");
+        let _ = Uuid::parse_str("F9168C5E-CEB-24fa-eB6BFF32-BF39FA1E4");
+        let _ = Uuid::parse_str("01020304-1112-2122-3132-41424344");
+        let _ = Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c88");
+        let _ = Uuid::parse_str("67e5504410b1426f9247bb680e5fe0cg8");
+        let _ = Uuid::parse_str("67e5504410b1426%9247bb680e5fe0c8");
+
+        // Test error reporting
+        let _ = Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c");
+        let _ = Uuid::parse_str("67e550X410b1426f9247bb680e5fe0cd");
+        let _ = Uuid::parse_str("67e550-4105b1426f9247bb680e5fe0c");
+        let _ = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF1-02BF39FA1E4");
+    });
+}
+
+#[bench]
+fn bench_parse_invalid_len(b: &mut Bencher) {
+    b.iter(|| {
+        let _ = Uuid::parse_str("F9168C5E-CEB2-4faa-BBF-329BF39FA1E4");
+    })
+}
+
+#[bench]
+fn bench_parse_invalid_character(b: &mut Bencher) {
+    b.iter(|| {
+        let _ = Uuid::parse_str("F9168C5E-CEB2-4faa-BGBF-329BF39FA1E4");
+    })
+}
+
+#[bench]
+fn bench_parse_invalid_group_len(b: &mut Bencher) {
+    b.iter(|| {
+        let _ = Uuid::parse_str("01020304-1112-2122-3132-41424344");
+    });
+}
+
+#[bench]
+fn bench_parse_invalid_groups(b: &mut Bencher) {
+    b.iter(|| {
+        let _ = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BFF329BF39FA1E4");
+    });
+}
diff --git a/rustc_deps/vendor/uuid/benches/mod.rs b/rustc_deps/vendor/uuid/benches/mod.rs
new file mode 100644
index 0000000..e3df218
--- /dev/null
+++ b/rustc_deps/vendor/uuid/benches/mod.rs
@@ -0,0 +1,8 @@
+#![feature(test)]
+#[cfg(feature = "slog")]
+#[macro_use]
+extern crate slog;
+extern crate test;
+extern crate uuid;
+
+pub mod slog_support;
diff --git a/rustc_deps/vendor/uuid/benches/serde_support.rs b/rustc_deps/vendor/uuid/benches/serde_support.rs
new file mode 100755
index 0000000..0daab5e
--- /dev/null
+++ b/rustc_deps/vendor/uuid/benches/serde_support.rs
@@ -0,0 +1,49 @@
+#![cfg(feature = "serde")]
+#![feature(test)]
+
+extern crate bincode;
+extern crate serde_json;
+extern crate test;
+extern crate uuid;
+
+use test::Bencher;
+use uuid::prelude::*;
+
+#[bench]
+fn bench_json_encode(b: &mut Bencher) {
+    let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap();
+    let mut buffer = [0_u8; 38];
+    b.iter(|| {
+        serde_json::to_writer(&mut buffer as &mut [u8], &uuid).unwrap();
+        test::black_box(buffer);
+    });
+    b.bytes = buffer.len() as u64;
+}
+
+#[bench]
+fn bench_json_decode(b: &mut Bencher) {
+    let s = "\"F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4\"";
+    b.iter(|| serde_json::from_str::<Uuid>(s).unwrap());
+    b.bytes = s.len() as u64;
+}
+
+#[bench]
+fn bench_bincode_encode(b: &mut Bencher) {
+    let uuid = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").unwrap();
+    let mut buffer = [0_u8; 24];
+    b.iter(|| {
+        bincode::serialize_into(&mut buffer as &mut [u8], &uuid).unwrap();
+        test::black_box(buffer);
+    });
+    b.bytes = buffer.len() as u64;
+}
+
+#[bench]
+fn bench_bincode_decode(b: &mut Bencher) {
+    let bytes = [
+        16, 0, 0, 0, 0, 0, 0, 0, 249, 22, 140, 94, 206, 178, 79, 170, 182, 191,
+        50, 155, 243, 159, 161, 228,
+    ];
+    b.iter(|| bincode::deserialize::<Uuid>(&bytes).unwrap());
+    b.bytes = bytes.len() as u64;
+}
diff --git a/rustc_deps/vendor/uuid/benches/slog_support/mod.rs b/rustc_deps/vendor/uuid/benches/slog_support/mod.rs
new file mode 100644
index 0000000..bc564fc
--- /dev/null
+++ b/rustc_deps/vendor/uuid/benches/slog_support/mod.rs
@@ -0,0 +1,7 @@
+#[cfg(feature = "slog")]
+// #[macro_use]
+// extern crate slog;
+// extern crate test;
+extern crate uuid;
+
+pub mod parse_str;
diff --git a/rustc_deps/vendor/uuid/benches/slog_support/parse_str.rs b/rustc_deps/vendor/uuid/benches/slog_support/parse_str.rs
new file mode 100644
index 0000000..fe77898
--- /dev/null
+++ b/rustc_deps/vendor/uuid/benches/slog_support/parse_str.rs
@@ -0,0 +1,15 @@
+use test::Bencher;
+use uuid::prelude::*;
+
+#[bench]
+#[cfg(feature = "slog")]
+pub fn bench_log_discard_kv(b: &mut Bencher) {
+    let u1 = Uuid::parse_str("F9168C5E-CEB2-4FAB-B6BF-329BF39FA1E4").unwrap();
+    let root = ::slog::Logger::root(::slog::Drain::fuse(::slog::Discard), o!());
+    // let root = ::slog::Logger::root(::slog::Discard.fuse(), o!());
+
+    b.iter(|| {
+        #[cfg(feature = "slog")]
+        crit!(root, "test"; "u1" => u1);
+    });
+}
diff --git a/rustc_deps/vendor/uuid/benches/valid_parse_str.rs b/rustc_deps/vendor/uuid/benches/valid_parse_str.rs
new file mode 100644
index 0000000..78a3279
--- /dev/null
+++ b/rustc_deps/vendor/uuid/benches/valid_parse_str.rs
@@ -0,0 +1,44 @@
+#![feature(test)]
+#[cfg(feature = "slog")]
+#[macro_use]
+extern crate slog;
+extern crate test;
+extern crate uuid;
+
+#[cfg(feature = "slog")]
+use slog::Drain;
+use test::Bencher;
+use uuid::prelude::*;
+
+#[bench]
+fn bench_parse_valid_strings(b: &mut Bencher) {
+    b.iter(|| {
+        // Valid
+        let _ = Uuid::parse_str("00000000000000000000000000000000");
+        let _ = Uuid::parse_str("67e55044-10b1-426f-9247-bb680e5fe0c8");
+        let _ = Uuid::parse_str("67e55044-10b1-426f-9247-bb680e5fe0c8");
+        let _ = Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4");
+        let _ = Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c8");
+        let _ = Uuid::parse_str("01020304-1112-2122-3132-414243444546");
+        let _ =
+            Uuid::parse_str("urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8");
+
+        // Nil
+        let _ = Uuid::parse_str("00000000000000000000000000000000");
+        let _ = Uuid::parse_str("00000000-0000-0000-0000-000000000000");
+    });
+}
+
+#[bench]
+fn bench_valid_hyphenated(b: &mut Bencher) {
+    b.iter(|| {
+        let _ = Uuid::parse_str("67e55044-10b1-426f-9247-bb680e5fe0c8");
+    });
+}
+
+#[bench]
+fn bench_valid_short(b: &mut Bencher) {
+    b.iter(|| {
+        let _ = Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c8");
+    });
+}
diff --git a/rustc_deps/vendor/uuid/src/adapter/core_support/mod.rs b/rustc_deps/vendor/uuid/src/adapter/core_support/mod.rs
new file mode 100644
index 0000000..2ffaee9
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/adapter/core_support/mod.rs
@@ -0,0 +1,175 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// 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.
+
+use core::fmt;
+use prelude::*;
+
+impl fmt::Display for super::Hyphenated {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(self, f)
+    }
+}
+
+impl<'a> fmt::Display for super::HyphenatedRef<'a> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(self, f)
+    }
+}
+
+impl fmt::Display for super::Simple {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(self, f)
+    }
+}
+
+impl<'a> fmt::Display for super::SimpleRef<'a> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(self, f)
+    }
+}
+
+impl fmt::Display for super::Urn {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(self, f)
+    }
+}
+
+impl<'a> fmt::Display for super::UrnRef<'a> {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(self, f)
+    }
+}
+
+impl fmt::LowerHex for super::Hyphenated {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(self.encode_lower(&mut [0; Self::LENGTH]))
+    }
+}
+
+impl<'a> fmt::LowerHex for super::HyphenatedRef<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // TODO: Self doesn't work https://github.com/rust-lang/rust/issues/52808
+        f.write_str(self.encode_lower(&mut [0; super::HyphenatedRef::LENGTH]))
+    }
+}
+
+impl fmt::LowerHex for super::Simple {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(self.encode_lower(&mut [0; Self::LENGTH]))
+    }
+}
+
+impl<'a> fmt::LowerHex for super::SimpleRef<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // TODO: Self doesn't work https://github.com/rust-lang/rust/issues/52808
+        f.write_str(self.encode_lower(&mut [0; super::SimpleRef::LENGTH]))
+    }
+}
+
+impl fmt::LowerHex for super::Urn {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(self.encode_lower(&mut [0; Self::LENGTH]))
+    }
+}
+
+impl<'a> fmt::LowerHex for super::UrnRef<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // TODO: Self doesn't work https://github.com/rust-lang/rust/issues/52808
+        f.write_str(self.encode_lower(&mut [0; super::UrnRef::LENGTH]))
+    }
+}
+
+impl fmt::UpperHex for super::Hyphenated {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(self.encode_upper(&mut [0; Self::LENGTH]))
+    }
+}
+
+impl<'a> fmt::UpperHex for super::HyphenatedRef<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // TODO: Self doesn't work https://github.com/rust-lang/rust/issues/52808
+        f.write_str(self.encode_upper(&mut [0; super::HyphenatedRef::LENGTH]))
+    }
+}
+
+impl fmt::UpperHex for super::Simple {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(self.encode_upper(&mut [0; Self::LENGTH]))
+    }
+}
+
+impl<'a> fmt::UpperHex for super::SimpleRef<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // TODO: Self doesn't work https://github.com/rust-lang/rust/issues/52808
+        f.write_str(self.encode_upper(&mut [0; super::SimpleRef::LENGTH]))
+    }
+}
+
+impl fmt::UpperHex for super::Urn {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(self.encode_upper(&mut [0; Self::LENGTH]))
+    }
+}
+
+impl<'a> fmt::UpperHex for super::UrnRef<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        // TODO: Self doesn't work https://github.com/rust-lang/rust/issues/52808
+        f.write_str(self.encode_upper(&mut [0; super::UrnRef::LENGTH]))
+    }
+}
+
+impl From<Uuid> for super::Hyphenated {
+    #[inline]
+    fn from(f: Uuid) -> Self {
+        super::Hyphenated::from_uuid(f)
+    }
+}
+
+impl<'a> From<&'a Uuid> for super::HyphenatedRef<'a> {
+    #[inline]
+    fn from(f: &'a Uuid) -> Self {
+        super::HyphenatedRef::from_uuid_ref(f)
+    }
+}
+
+impl From<Uuid> for super::Simple {
+    #[inline]
+    fn from(f: Uuid) -> Self {
+        super::Simple::from_uuid(f)
+    }
+}
+
+impl<'a> From<&'a Uuid> for super::SimpleRef<'a> {
+    #[inline]
+    fn from(f: &'a Uuid) -> Self {
+        super::SimpleRef::from_uuid_ref(f)
+    }
+}
+
+impl From<Uuid> for super::Urn {
+    #[inline]
+    fn from(f: Uuid) -> Self {
+        super::Urn::from_uuid(f)
+    }
+}
+
+impl<'a> From<&'a Uuid> for super::UrnRef<'a> {
+    #[inline]
+    fn from(f: &'a Uuid) -> Self {
+        super::UrnRef::from_uuid_ref(f)
+    }
+}
diff --git a/rustc_deps/vendor/uuid/src/adapter/mod.rs b/rustc_deps/vendor/uuid/src/adapter/mod.rs
new file mode 100644
index 0000000..e35c37d
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/adapter/mod.rs
@@ -0,0 +1,1088 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// 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.
+
+//! Adapters for various formats for [`Uuid`]s
+//!
+//! [`Uuid`]: ../struct.Uuid.html
+
+use core::str;
+use prelude::*;
+
+mod core_support;
+
+/// An adaptor for formatting an [`Uuid`] as a hyphenated string.
+///
+/// Takes an owned instance of the [`Uuid`].
+///
+/// [`Uuid`]: ../struct.Uuid.html
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct Hyphenated(Uuid);
+
+/// An adaptor for formatting an [`Uuid`] as a hyphenated string.
+///
+/// Takes a reference of the [`Uuid`].
+///
+/// [`Uuid`]: ../struct.Uuid.html
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct HyphenatedRef<'a>(&'a Uuid);
+
+/// An adaptor for formatting an [`Uuid`] as a simple string.
+///
+/// Takes an owned instance of the [`Uuid`].
+///
+/// [`Uuid`]: ../struct.Uuid.html
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct Simple(Uuid);
+
+/// An adaptor for formatting an [`Uuid`] as a simple string.
+///
+/// Takes a reference of the [`Uuid`].
+///
+/// [`Uuid`]: ../struct.Uuid.html
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct SimpleRef<'a>(&'a Uuid);
+
+/// An adaptor for formatting an [`Uuid`] as a URN string.
+///
+/// Takes an owned instance of the [`Uuid`].
+///
+/// [`Uuid`]: ../struct.Uuid.html
+#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct Urn(Uuid);
+
+/// An adaptor for formatting an [`Uuid`] as a URN string.
+///
+/// Takes a reference of the [`Uuid`].
+///
+/// [`Uuid`]: ../struct.Uuid.html
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct UrnRef<'a>(&'a Uuid);
+
+impl Uuid {
+    /// Creates a [`Hyphenated`] instance from a [`Uuid`].
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`Hyphenated`]: adapter/struct.Hyphenated.html
+    #[cfg(not(feature = "const_fn"))]
+    #[inline]
+    pub fn to_hyphenated(self) -> Hyphenated {
+        Hyphenated::from_uuid(self)
+    }
+
+    /// Creates a [`Hyphenated`] instance from a [`Uuid`].
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`Hyphenated`]: adapter/struct.Hyphenated.html
+    #[cfg(feature = "const_fn")]
+    #[inline]
+    pub const fn to_hyphenated(self) -> Hyphenated {
+        Hyphenated::from_uuid(self)
+    }
+
+    /// Creates a [`HyphenatedRef`] instance from a [`Uuid`] reference.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`HyphenatedRef`]: adapter/struct.HyphenatedRef.html
+    #[cfg(not(feature = "const_fn"))]
+    #[inline]
+    pub fn to_hyphenated_ref(&self) -> HyphenatedRef {
+        HyphenatedRef::from_uuid_ref(self)
+    }
+
+    /// Creates a [`HyphenatedRef`] instance from a [`Uuid`] reference.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`HyphenatedRef`]: adapter/struct.HyphenatedRef.html
+    #[cfg(feature = "const_fn")]
+    #[inline]
+    pub const fn to_hyphenated_ref(&self) -> HyphenatedRef {
+        HyphenatedRef::from_uuid_ref(self)
+    }
+
+    /// Creates a [`Simple`] instance from a [`Uuid`].
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`Simple`]: adapter/struct.Simple.html
+    #[cfg(not(feature = "const_fn"))]
+    #[inline]
+    pub fn to_simple(self) -> Simple {
+        Simple::from_uuid(self)
+    }
+
+    /// Creates a [`Simple`] instance from a [`Uuid`].
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`Simple`]: adapter/struct.Simple.html
+    #[cfg(feature = "const_fn")]
+    #[inline]
+    pub const fn to_simple(self) -> Simple {
+        Simple::from_uuid(self)
+    }
+
+    /// Creates a [`SimpleRef`] instance from a [`Uuid`] reference.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`SimpleRef`]: adapter/struct.SimpleRef.html
+    #[cfg(not(feature = "const_fn"))]
+    #[inline]
+    pub fn to_simple_ref(&self) -> SimpleRef {
+        SimpleRef::from_uuid_ref(self)
+    }
+
+    /// Creates a [`SimpleRef`] instance from a [`Uuid`] reference.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`SimpleRef`]: adapter/struct.SimpleRef.html
+    #[cfg(feature = "const_fn")]
+    #[inline]
+    pub const fn to_simple_ref(&self) -> SimpleRef {
+        SimpleRef::from_uuid_ref(self)
+    }
+
+    /// Creates a [`Urn`] instance from a [`Uuid`].
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`Urn`]: adapter/struct.Urn.html
+    #[cfg(not(feature = "const_fn"))]
+    #[inline]
+    pub fn to_urn(self) -> Urn {
+        Urn::from_uuid(self)
+    }
+
+    /// Creates a [`Urn`] instance from a [`Uuid`].
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`Urn`]: adapter/struct.Urn.html
+    #[cfg(feature = "const_fn")]
+    #[inline]
+    pub const fn to_urn(self) -> Urn {
+        Urn::from_uuid(self)
+    }
+
+    /// Creates a [`UrnRef`] instance from a [`Uuid`] reference.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`UrnRef`]: adapter/struct.UrnRef.html
+    #[cfg(not(feature = "const_fn"))]
+    #[inline]
+    pub fn to_urn_ref(&self) -> UrnRef {
+        UrnRef::from_uuid_ref(self)
+    }
+
+    /// Creates a [`UrnRef`] instance from a [`Uuid`] reference.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`UrnRef`]: adapter/struct.UrnRef.html
+    #[cfg(feature = "const_fn")]
+    #[inline]
+    pub const fn to_urn_ref(&self) -> UrnRef {
+        UrnRef::from_uuid_ref(self)
+    }
+}
+
+const UPPER: [u8; 16] = [
+    b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'A', b'B',
+    b'C', b'D', b'E', b'F',
+];
+const LOWER: [u8; 16] = [
+    b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'a', b'b',
+    b'c', b'd', b'e', b'f',
+];
+/// The segments of a UUID's [u8; 16] corresponding to each group.
+const BYTE_POSITIONS: [usize; 6] = [0, 4, 6, 8, 10, 16];
+/// The locations that hyphens are written into the buffer, after each
+/// group.
+const HYPHEN_POSITIONS: [usize; 4] = [8, 13, 18, 23];
+
+/// Encodes the `uuid` possibly with hyphens, and possibly in upper
+/// case, to full_buffer[start..] and returns the str sliced from
+/// full_buffer[..start + encoded_length].
+///
+/// The `start` parameter allows writing a prefix (such as
+/// "urn:uuid:") to the buffer that's included in the final encoded
+/// UUID.
+fn encode<'a>(
+    full_buffer: &'a mut [u8],
+    start: usize,
+    uuid: &Uuid,
+    hyphens: bool,
+    upper: bool,
+) -> &'a mut str {
+    let len = if hyphens { 36 } else { 32 };
+
+    {
+        let buffer = &mut full_buffer[start..start + len];
+        let bytes = uuid.as_bytes();
+
+        let hex = if upper { &UPPER } else { &LOWER };
+
+        for group in 0..5 {
+            // If we're writing hyphens, we need to shift the output
+            // location along by how many of them have been written
+            // before this point. That's exactly the (0-indexed) group
+            // number.
+            let hyphens_before = if hyphens { group } else { 0 };
+
+            for idx in BYTE_POSITIONS[group]..BYTE_POSITIONS[group + 1] {
+                let b = bytes[idx];
+                let out_idx = hyphens_before + 2 * idx;
+
+                buffer[out_idx + 0] = hex[(b >> 4) as usize];
+                buffer[out_idx + 1] = hex[(b & 0b1111) as usize];
+            }
+
+            if group != 4 && hyphens {
+                buffer[HYPHEN_POSITIONS[group]] = b'-';
+            }
+        }
+    }
+
+    str::from_utf8_mut(&mut full_buffer[..start + len])
+        .expect("found non-ASCII output characters while encoding a UUID")
+}
+
+impl Hyphenated {
+    /// The length of a hyphenated [`Uuid`] string.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    pub const LENGTH: usize = 36;
+
+    /// Creates a [`Hyphenated`] from a [`Uuid`].
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`Hyphenated`]: struct.Hyphenated.html
+    #[cfg(not(feature = "const_fn"))]
+    pub fn from_uuid(uuid: Uuid) -> Self {
+        Hyphenated(uuid)
+    }
+
+    /// Creates a [`Hyphenated`] from a [`Uuid`].
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`Hyphenated`]: struct.Hyphenated.html
+    #[cfg(feature = "const_fn")]
+    pub const fn from_uuid(uuid: Uuid) -> Self {
+        Hyphenated(uuid)
+    }
+
+    // Writes the [`Uuid`] as a lower-case hyphenated string to
+    // `buffer`, and returns the subslice of the buffer that contains the
+    // encoded UUID.
+    //
+    // This is slightly more efficient than using the formatting
+    // infrastructure as it avoids virtual calls, and may avoid
+    // double buffering.
+    //
+    // [`Uuid`]: ../struct.Uuid.html
+    //
+    // # Panics
+    //
+    // Panics if the buffer is not large enough: it must have length at least
+    // [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
+    // sufficiently-large temporary buffer.
+    //
+    // [`LENGTH`]: #associatedconstant.LENGTH
+    // [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
+    //
+    // # Examples
+    //
+    // ```rust
+    // use uuid::Uuid;
+    //
+    // let uuid = Uuid::parse_str("936DA01f9abd4d9d80c702af85c822a8").unwrap();
+    //
+    // // the encoded portion is returned
+    // assert_eq!(
+    //     uuid.to_hyphenated()
+    //         .encode_lower(&mut Uuid::encode_buffer()),
+    //     "936da01f-9abd-4d9d-80c7-02af85c822a8"
+    // );
+    //
+    // // the buffer is mutated directly, and trailing contents remains
+    // let mut buf = [b'!'; 40];
+    // uuid.to_hyphenated().encode_lower(&mut buf);
+    // assert_eq!(
+    //     &buf as &[_],
+    //     b"936da01f-9abd-4d9d-80c7-02af85c822a8!!!!" as &[_]
+    // );
+    // ```
+    // */
+    pub(crate) fn encode_lower<'buf>(
+        &self,
+        buffer: &'buf mut [u8],
+    ) -> &'buf mut str {
+        encode(buffer, 0, &self.0, true, false)
+    }
+
+    // Writes the [`Uuid`] as an upper-case hyphenated string to
+    // `buffer`, and returns the subslice of the buffer that contains the
+    // encoded UUID.
+    //
+    // This is slightly more efficient than using the formatting
+    // infrastructure as it avoids virtual calls, and may avoid
+    // double buffering.
+    //
+    // [`Uuid`]: ../struct.Uuid.html
+    //
+    // # Panics
+    //
+    // Panics if the buffer is not large enough: it must have length at least
+    // [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
+    // sufficiently-large temporary buffer.
+    //
+    // [`LENGTH`]: #associatedconstant.LENGTH
+    // [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
+    //
+    // # Examples
+    //
+    // ```rust
+    // use uuid::Uuid;
+    //
+    // let uuid = Uuid::parse_str("936da01f9abd4d9d80c702af85c822a8").unwrap();
+    //
+    // // the encoded portion is returned
+    // assert_eq!(
+    //     uuid.to_hyphenated()
+    //         .encode_upper(&mut Uuid::encode_buffer()),
+    //     "936DA01F-9ABD-4D9D-80C7-02AF85C822A8"
+    // );
+    //
+    // // the buffer is mutated directly, and trailing contents remains
+    // let mut buf = [b'!'; 40];
+    // uuid.to_hyphenated().encode_upper(&mut buf);
+    // assert_eq!(
+    //     &buf as &[_],
+    //     b"936DA01F-9ABD-4D9D-80C7-02AF85C822A8!!!!" as &[_]
+    // );
+    // ```
+    // */
+    pub(crate) fn encode_upper<'buf>(
+        &self,
+        buffer: &'buf mut [u8],
+    ) -> &'buf mut str {
+        encode(buffer, 0, &self.0, true, true)
+    }
+}
+
+impl<'a> HyphenatedRef<'a> {
+    /// The length of a hyphenated [`Uuid`] string.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    pub const LENGTH: usize = 36;
+
+    /// Creates a [`HyphenatedRef`] from a [`Uuid`] reference.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`HyphenatedRef`]: struct.HyphenatedRef.html
+    #[cfg(not(feature = "const_fn"))]
+    pub fn from_uuid_ref(uuid: &'a Uuid) -> Self {
+        HyphenatedRef(uuid)
+    }
+
+    /// Creates a [`HyphenatedRef`] from a [`Uuid`] reference.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`HyphenatedRef`]: struct.HyphenatedRef.html
+    #[cfg(feature = "const_fn")]
+    pub const fn from_uuid_ref(uuid: &'a Uuid) -> Self {
+        HyphenatedRef(uuid)
+    }
+
+    // Writes the [`Uuid`] as a lower-case hyphenated string to
+    // `buffer`, and returns the subslice of the buffer that contains the
+    // encoded UUID.
+    //
+    // This is slightly more efficient than using the formatting
+    // infrastructure as it avoids virtual calls, and may avoid
+    // double buffering.
+    //
+    // [`Uuid`]: ../struct.Uuid.html
+    //
+    // # Panics
+    //
+    // Panics if the buffer is not large enough: it must have length at least
+    // [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
+    // sufficiently-large temporary buffer.
+    //
+    // [`LENGTH`]: #associatedconstant.LENGTH
+    // [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
+    //
+    // # Examples
+    //
+    // ```rust
+    // use uuid::Uuid;
+    //
+    // let uuid = Uuid::parse_str("936DA01f9abd4d9d80c702af85c822a8").unwrap();
+    //
+    // // the encoded portion is returned
+    // assert_eq!(
+    //     uuid.to_hyphenated()
+    //         .encode_lower(&mut Uuid::encode_buffer()),
+    //     "936da01f-9abd-4d9d-80c7-02af85c822a8"
+    // );
+    //
+    // // the buffer is mutated directly, and trailing contents remains
+    // let mut buf = [b'!'; 40];
+    // uuid.to_hyphenated().encode_lower(&mut buf);
+    // assert_eq!(
+    //     uuid.to_hyphenated().encode_lower(&mut buf),
+    //     "936da01f-9abd-4d9d-80c7-02af85c822a8"
+    // );
+    // assert_eq!(
+    //     &buf as &[_],
+    //     b"936da01f-9abd-4d9d-80c7-02af85c822a8!!!!" as &[_]
+    // );
+    // ```
+    // */
+    pub(crate) fn encode_lower<'buf>(
+        &self,
+        buffer: &'buf mut [u8],
+    ) -> &'buf mut str {
+        encode(buffer, 0, self.0, true, false)
+    }
+
+    // Writes the [`Uuid`] as an upper-case hyphenated string to
+    // `buffer`, and returns the subslice of the buffer that contains the
+    // encoded UUID.
+    //
+    // This is slightly more efficient than using the formatting
+    // infrastructure as it avoids virtual calls, and may avoid
+    // double buffering.
+    //
+    // [`Uuid`]: ../struct.Uuid.html
+    //
+    // # Panics
+    //
+    // Panics if the buffer is not large enough: it must have length at least
+    // [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
+    // sufficiently-large temporary buffer.
+    //
+    // [`LENGTH`]: #associatedconstant.LENGTH
+    // [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
+    //
+    // # Examples
+    //
+    // ```rust
+    // use uuid::Uuid;
+    //
+    // let uuid = Uuid::parse_str("936da01f9abd4d9d80c702af85c822a8").unwrap();
+    //
+    // // the encoded portion is returned
+    // assert_eq!(
+    //     uuid.to_hyphenated()
+    //         .encode_upper(&mut Uuid::encode_buffer()),
+    //     "936DA01F-9ABD-4D9D-80C7-02AF85C822A8"
+    // );
+    //
+    // // the buffer is mutated directly, and trailing contents remains
+    // let mut buf = [b'!'; 40];
+    // assert_eq!(
+    //     uuid.to_hyphenated().encode_upper(&mut buf),
+    //     "936DA01F-9ABD-4D9D-80C7-02AF85C822A8"
+    // );
+    // assert_eq!(
+    //     &buf as &[_],
+    //     b"936DA01F-9ABD-4D9D-80C7-02AF85C822A8!!!!" as &[_]
+    // );
+    // ```
+    // */
+    pub(crate) fn encode_upper<'buf>(
+        &self,
+        buffer: &'buf mut [u8],
+    ) -> &'buf mut str {
+        encode(buffer, 0, self.0, true, true)
+    }
+}
+
+impl Simple {
+    /// The length of a simple [`Uuid`] string.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    pub const LENGTH: usize = 32;
+
+    /// Creates a [`Simple`] from a [`Uuid`].
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`Simple`]: struct.Simple.html
+    #[cfg(not(feature = "const_fn"))]
+    pub fn from_uuid(uuid: Uuid) -> Self {
+        Simple(uuid)
+    }
+
+    /// Creates a [`Simple`] from a [`Uuid`].
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`Simple`]: struct.Simple.html
+    #[cfg(feature = "const_fn")]
+    pub const fn from_uuid(uuid: Uuid) -> Self {
+        Simple(uuid)
+    }
+
+    // Writes the [`Uuid`] as a lower-case simple string to `buffer`,
+    // and returns the subslice of the buffer that contains the encoded UUID.
+    //
+    // This is slightly more efficient than using the formatting
+    // infrastructure as it avoids virtual calls, and may avoid
+    // double buffering.
+    //
+    // [`Uuid`]: ../struct.Uuid.html
+    //
+    // # Panics
+    //
+    // Panics if the buffer is not large enough: it must have length at least
+    // [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
+    // sufficiently-large temporary buffer.
+    //
+    // [`LENGTH`]: #associatedconstant.LENGTH
+    // [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
+    //
+    // # Examples
+    //
+    // ```rust
+    // use uuid::Uuid;
+    //
+    // let uuid = Uuid::parse_str("936DA01f9abd4d9d80c702af85c822a8").unwrap();
+    //
+    // // the encoded portion is returned
+    // assert_eq!(
+    //     uuid.to_simple().encode_lower(&mut Uuid::encode_buffer()),
+    //     "936da01f9abd4d9d80c702af85c822a8"
+    // );
+    //
+    // // the buffer is mutated directly, and trailing contents remains
+    // let mut buf = [b'!'; 36];
+    // assert_eq!(
+    //     uuid.to_simple().encode_lower(&mut buf),
+    //     "936da01f9abd4d9d80c702af85c822a8"
+    // );
+    // assert_eq!(
+    //     &buf as &[_],
+    //     b"936da01f9abd4d9d80c702af85c822a8!!!!" as &[_]
+    // );
+    // ```
+    // */
+    pub(crate) fn encode_lower<'buf>(
+        &self,
+        buffer: &'buf mut [u8],
+    ) -> &'buf mut str {
+        encode(buffer, 0, &self.0, false, false)
+    }
+
+    // Writes the [`Uuid`] as an upper-case simple string to `buffer`,
+    // and returns the subslice of the buffer that contains the encoded UUID.
+    //
+    // [`Uuid`]: ../struct.Uuid.html
+    //
+    // # Panics
+    //
+    // Panics if the buffer is not large enough: it must have length at least
+    // [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
+    // sufficiently-large temporary buffer.
+    //
+    // [`LENGTH`]: #associatedconstant.LENGTH
+    // [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
+    //
+    // # Examples
+    //
+    // ```rust
+    // use uuid::Uuid;
+    //
+    // let uuid = Uuid::parse_str("936da01f9abd4d9d80c702af85c822a8").unwrap();
+    //
+    // // the encoded portion is returned
+    // assert_eq!(
+    //     uuid.to_simple().encode_upper(&mut Uuid::encode_buffer()),
+    //     "936DA01F9ABD4D9D80C702AF85C822A8"
+    // );
+    //
+    // // the buffer is mutated directly, and trailing contents remains
+    // let mut buf = [b'!'; 36];
+    // assert_eq!(
+    //     uuid.to_simple().encode_upper(&mut buf),
+    //     "936DA01F9ABD4D9D80C702AF85C822A8"
+    // );
+    // assert_eq!(
+    //     &buf as &[_],
+    //     b"936DA01F9ABD4D9D80C702AF85C822A8!!!!" as &[_]
+    // );
+    // ```
+    // */
+    pub(crate) fn encode_upper<'buf>(
+        &self,
+        buffer: &'buf mut [u8],
+    ) -> &'buf mut str {
+        encode(buffer, 0, &self.0, false, true)
+    }
+}
+
+impl<'a> SimpleRef<'a> {
+    /// The length of a simple [`Uuid`] string.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    pub const LENGTH: usize = 32;
+
+    /// Creates a [`SimpleRef`] from a [`Uuid`] reference.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`SimpleRef`]: struct.SimpleRef.html
+    #[cfg(not(feature = "const_fn"))]
+    pub fn from_uuid_ref(uuid: &'a Uuid) -> Self {
+        SimpleRef(uuid)
+    }
+
+    /// Creates a [`SimpleRef`] from a [`Uuid`] reference.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`SimpleRef`]: struct.SimpleRef.html
+    #[cfg(feature = "const_fn")]
+    pub const fn from_uuid_ref(uuid: &'a Uuid) -> Self {
+        SimpleRef(uuid)
+    }
+
+    // Writes the [`Uuid`] as a lower-case simple string to `buffer`,
+    // and returns the subslice of the buffer that contains the encoded UUID.
+    //
+    // This is slightly more efficient than using the formatting
+    // infrastructure as it avoids virtual calls, and may avoid
+    // double buffering.
+    //
+    // [`Uuid`]: ../struct.Uuid.html
+    //
+    // # Panics
+    //
+    // Panics if the buffer is not large enough: it must have length at least
+    // [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
+    // sufficiently-large temporary buffer.
+    //
+    // [`LENGTH`]: #associatedconstant.LENGTH
+    // [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
+    //
+    // # Examples
+    //
+    // ```rust
+    // use uuid::Uuid;
+    //
+    // let uuid = Uuid::parse_str("936DA01f9abd4d9d80c702af85c822a8").unwrap();
+    //
+    // // the encoded portion is returned
+    // assert_eq!(
+    //     uuid.to_simple().encode_lower(&mut Uuid::encode_buffer()),
+    //     "936da01f9abd4d9d80c702af85c822a8"
+    // );
+    //
+    // // the buffer is mutated directly, and trailing contents remains
+    // let mut buf = [b'!'; 36];
+    // assert_eq!(
+    //     uuid.to_simple().encode_lower(&mut buf),
+    //     "936da01f9abd4d9d80c702af85c822a8"
+    // );
+    // assert_eq!(
+    //     &buf as &[_],
+    //     b"936da01f9abd4d9d80c702af85c822a8!!!!" as &[_]
+    // );
+    // ```
+    // */
+    pub(crate) fn encode_lower<'buf>(
+        &self,
+        buffer: &'buf mut [u8],
+    ) -> &'buf mut str {
+        encode(buffer, 0, self.0, false, false)
+    }
+
+    // Writes the [`Uuid`] as an upper-case simple string to `buffer`,
+    // and returns the subslice of the buffer that contains the encoded UUID.
+    //
+    // [`Uuid`]: ../struct.Uuid.html
+    //
+    // # Panics
+    //
+    // Panics if the buffer is not large enough: it must have length at least
+    // [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
+    // sufficiently-large temporary buffer.
+    //
+    // [`LENGTH`]: #associatedconstant.LENGTH
+    // [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
+    //
+    // # Examples
+    //
+    // ```rust
+    // use uuid::Uuid;
+    //
+    // let uuid = Uuid::parse_str("936da01f9abd4d9d80c702af85c822a8").unwrap();
+    //
+    // // the encoded portion is returned
+    // assert_eq!(
+    //     uuid.to_simple().encode_upper(&mut Uuid::encode_buffer()),
+    //     "936DA01F9ABD4D9D80C702AF85C822A8"
+    // );
+    //
+    // // the buffer is mutated directly, and trailing contents remains
+    // let mut buf = [b'!'; 36];
+    // assert_eq!(
+    //     uuid.to_simple().encode_upper(&mut buf),
+    //     "936DA01F9ABD4D9D80C702AF85C822A8"
+    // );
+    // assert_eq!(
+    //     &buf as &[_],
+    //     b"936DA01F9ABD4D9D80C702AF85C822A8!!!!" as &[_]
+    // );
+    // ```
+    // */
+    pub(crate) fn encode_upper<'buf>(
+        &self,
+        buffer: &'buf mut [u8],
+    ) -> &'buf mut str {
+        encode(buffer, 0, self.0, false, true)
+    }
+}
+
+impl Urn {
+    /// The length of a URN [`Uuid`] string.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    pub const LENGTH: usize = 45;
+
+    /// Creates a [`Urn`] from a [`Uuid`].
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`Urn`]: struct.Urn.html
+    #[cfg(not(feature = "const_fn"))]
+    pub fn from_uuid(uuid: Uuid) -> Self {
+        Urn(uuid)
+    }
+
+    /// Creates a [`Urn`] from a [`Uuid`].
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`Urn`]: struct.Urn.html
+    #[cfg(feature = "const_fn")]
+    pub const fn from_uuid(uuid: Uuid) -> Self {
+        Urn(uuid)
+    }
+
+    // Writes the [`Uuid`] as a lower-case URN string to
+    // `buffer`, and returns the subslice of the buffer that contains the
+    // encoded UUID.
+    //
+    // This is slightly more efficient than using the formatting
+    // infrastructure as it avoids virtual calls, and may avoid
+    // double buffering.
+    //
+    // [`Uuid`]: ../struct.Uuid.html
+    //
+    // # Panics
+    //
+    // Panics if the buffer is not large enough: it must have length at least
+    // [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
+    // sufficiently-large temporary buffer.
+    //
+    // [`LENGTH`]: #associatedconstant.LENGTH
+    // [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
+    //
+    // # Examples
+    //
+    // ```rust
+    // use uuid::Uuid;
+    //
+    // let uuid = Uuid::parse_str("936DA01f9abd4d9d80c702af85c822a8").unwrap();
+    //
+    // // the encoded portion is returned
+    // assert_eq!(
+    //     uuid.to_urn().encode_lower(&mut Uuid::encode_buffer()),
+    //     "urn:uuid:936da01f-9abd-4d9d-80c7-02af85c822a8"
+    // );
+    //
+    // // the buffer is mutated directly, and trailing contents remains
+    // let mut buf = [b'!'; 49];
+    // uuid.to_urn().encode_lower(&mut buf);
+    // assert_eq!(
+    //     uuid.to_urn().encode_lower(&mut buf),
+    //     "urn:uuid:936da01f-9abd-4d9d-80c7-02af85c822a8"
+    // );
+    // assert_eq!(
+    //     &buf as &[_],
+    //     b"urn:uuid:936da01f-9abd-4d9d-80c7-02af85c822a8!!!!" as &[_]
+    // );
+    // ```
+    // */
+    pub(crate) fn encode_lower<'buf>(
+        &self,
+        buffer: &'buf mut [u8],
+    ) -> &'buf mut str {
+        buffer[..9].copy_from_slice(b"urn:uuid:");
+        encode(buffer, 9, &self.0, true, false)
+    }
+
+    // Writes the [`Uuid`] as an upper-case URN string to
+    // `buffer`, and returns the subslice of the buffer that contains the
+    // encoded UUID.
+    //
+    // This is slightly more efficient than using the formatting
+    // infrastructure as it avoids virtual calls, and may avoid
+    // double buffering.
+    //
+    // [`Uuid`]: ../struct.Uuid.html
+    //
+    // # Panics
+    //
+    // Panics if the buffer is not large enough: it must have length at least
+    // [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
+    // sufficiently-large temporary buffer.
+    //
+    // [`LENGTH`]: #associatedconstant.LENGTH
+    // [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
+    //
+    // # Examples
+    //
+    // ```rust
+    // use uuid::Uuid;
+    //
+    // let uuid = Uuid::parse_str("936da01f9abd4d9d80c702af85c822a8").unwrap();
+    //
+    // // the encoded portion is returned
+    // assert_eq!(
+    //     uuid.to_urn().encode_upper(&mut Uuid::encode_buffer()),
+    //     "urn:uuid:936DA01F-9ABD-4D9D-80C7-02AF85C822A8"
+    // );
+    //
+    // // the buffer is mutated directly, and trailing contents remains
+    // let mut buf = [b'!'; 49];
+    // assert_eq!(
+    //     uuid.to_urn().encode_upper(&mut buf),
+    //     "urn:uuid:936DA01F-9ABD-4D9D-80C7-02AF85C822A8"
+    // );
+    // assert_eq!(
+    //     &buf as &[_],
+    //     b"urn:uuid:936DA01F-9ABD-4D9D-80C7-02AF85C822A8!!!!" as &[_]
+    // );
+    // ```
+    // */
+    pub(crate) fn encode_upper<'buf>(
+        &self,
+        buffer: &'buf mut [u8],
+    ) -> &'buf mut str {
+        buffer[..9].copy_from_slice(b"urn:uuid:");
+        encode(buffer, 9, &self.0, true, true)
+    }
+}
+
+impl<'a> UrnRef<'a> {
+    /// The length of a URN [`Uuid`] string.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    pub const LENGTH: usize = 45;
+
+    /// Creates a [`UrnRef`] from a [`Uuid`] reference.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`UrnRef`]: struct.UrnRef.html
+    #[cfg(not(feature = "const_fn"))]
+    pub fn from_uuid_ref(uuid: &'a Uuid) -> Self {
+        UrnRef(uuid)
+    }
+
+    /// Creates a [`UrnRef`] from a [`Uuid`] reference.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`UrnRef`]: struct.UrnRef.html
+    #[cfg(feature = "const_fn")]
+    pub const fn from_uuid_ref(uuid: &'a Uuid) -> Self {
+        UrnRef(&uuid)
+    }
+
+    // Writes the [`Uuid`] as a lower-case URN string to
+    // `buffer`, and returns the subslice of the buffer that contains the
+    // encoded UUID.
+    //
+    // This is slightly more efficient than using the formatting
+    // infrastructure as it avoids virtual calls, and may avoid
+    // double buffering.
+    //
+    // [`Uuid`]: ../struct.Uuid.html
+    //
+    // # Panics
+    //
+    // Panics if the buffer is not large enough: it must have length at least
+    // [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
+    // sufficiently-large temporary buffer.
+    //
+    // [`LENGTH`]: #associatedconstant.LENGTH
+    // [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
+    //
+    // # Examples
+    //
+    // ```rust
+    // use uuid::Uuid;
+    //
+    // let uuid = Uuid::parse_str("936DA01f9abd4d9d80c702af85c822a8").unwrap();
+    //
+    // // the encoded portion is returned
+    // assert_eq!(
+    //     uuid.to_urn().encode_lower(&mut Uuid::encode_buffer()),
+    //     "urn:uuid:936da01f-9abd-4d9d-80c7-02af85c822a8"
+    // );
+    //
+    // // the buffer is mutated directly, and trailing contents remains
+    // let mut buf = [b'!'; 49];
+    // uuid.to_urn().encode_lower(&mut buf);
+    // assert_eq!(
+    //     uuid.to_urn().encode_lower(&mut buf),
+    //     "urn:uuid:936da01f-9abd-4d9d-80c7-02af85c822a8"
+    // );
+    // assert_eq!(
+    //     &buf as &[_],
+    //     b"urn:uuid:936da01f-9abd-4d9d-80c7-02af85c822a8!!!!" as &[_]
+    // );
+    // ```
+    // */
+    pub(crate) fn encode_lower<'buf>(
+        &self,
+        buffer: &'buf mut [u8],
+    ) -> &'buf mut str {
+        buffer[..9].copy_from_slice(b"urn:uuid:");
+        encode(buffer, 9, self.0, true, false)
+    }
+
+    // Writes the [`Uuid`] as an upper-case URN string to
+    // `buffer`, and returns the subslice of the buffer that contains the
+    // encoded UUID.
+    //
+    // This is slightly more efficient than using the formatting
+    // infrastructure as it avoids virtual calls, and may avoid
+    // double buffering.
+    //
+    // [`Uuid`]: ../struct.Uuid.html
+    //
+    // # Panics
+    //
+    // Panics if the buffer is not large enough: it must have length at least
+    // [`LENGTH`]. [`Uuid::encode_buffer`] can be used to get a
+    // sufficiently-large temporary buffer.
+    //
+    // [`LENGTH`]: #associatedconstant.LENGTH
+    // [`Uuid::encode_buffer`]: ../struct.Uuid.html#method.encode_buffer
+    //
+    // # Examples
+    //
+    // ```rust
+    // use uuid::Uuid;
+    //
+    // let uuid = Uuid::parse_str("936da01f9abd4d9d80c702af85c822a8").unwrap();
+    //
+    // // the encoded portion is returned
+    // assert_eq!(
+    //     uuid.to_urn().encode_upper(&mut Uuid::encode_buffer()),
+    //     "urn:uuid:936DA01F-9ABD-4D9D-80C7-02AF85C822A8"
+    // );
+    //
+    // // the buffer is mutated directly, and trailing contents remains
+    // let mut buf = [b'!'; 49];
+    // assert_eq!(
+    //     uuid.to_urn().encode_upper(&mut buf),
+    //     "urn:uuid:936DA01F-9ABD-4D9D-80C7-02AF85C822A8"
+    // );
+    // assert_eq!(
+    //     &buf as &[_],
+    //     b"urn:uuid:936DA01F-9ABD-4D9D-80C7-02AF85C822A8!!!!" as &[_]
+    // );
+    // ```
+    // */
+    pub(crate) fn encode_upper<'buf>(
+        &self,
+        buffer: &'buf mut [u8],
+    ) -> &'buf mut str {
+        buffer[..9].copy_from_slice(b"urn:uuid:");
+        encode(buffer, 9, self.0, true, true)
+    }
+}
+
+// TODO: uncomment when we undo the pub(crate) change
+// #[cfg(test)]
+// mod tests {
+// use Uuid;
+//
+// #[test]
+// fn hyphenated_trailing() {
+// let mut buf = [b'x'; 100];
+// let len = Uuid::nil().to_hyphenated().encode_lower(&mut buf).len();
+// assert_eq!(len, super::Hyphenated::LENGTH);
+// assert!(buf[len..].iter().all(|x| *x == b'x'));
+// }
+// #[test]
+// fn hyphenated_ref_trailing() {
+// let mut buf = [b'x'; 100];
+// let len = Uuid::nil().to_hyphenated().encode_lower(&mut buf).len();
+// assert_eq!(len, super::HyphenatedRef::LENGTH);
+// assert!(buf[len..].iter().all(|x| *x == b'x'));
+// }
+//
+// #[test]
+// fn simple_trailing() {
+// let mut buf = [b'x'; 100];
+// let len = Uuid::nil().to_simple().encode_lower(&mut buf).len();
+// assert_eq!(len, super::Simple::LENGTH);
+// assert!(buf[len..].iter().all(|x| *x == b'x'));
+// }
+// #[test]
+// fn simple_ref_trailing() {
+// let mut buf = [b'x'; 100];
+// let len = Uuid::nil().to_simple().encode_lower(&mut buf).len();
+// assert_eq!(len, super::SimpleRef::LENGTH);
+// assert!(buf[len..].iter().all(|x| *x == b'x'));
+// }
+//
+// #[test]
+// fn urn_trailing() {
+// let mut buf = [b'x'; 100];
+// let len = Uuid::nil().to_urn().encode_lower(&mut buf).len();
+// assert_eq!(len, super::Urn::LENGTH);
+// assert!(buf[len..].iter().all(|x| *x == b'x'));
+// }
+// #[test]
+// fn urn_ref_trailing() {
+// let mut buf = [b'x'; 100];
+// let len = Uuid::nil().to_urn().encode_lower(&mut buf).len();
+// assert_eq!(len, super::UrnRef::LENGTH);
+// assert!(buf[len..].iter().all(|x| *x == b'x'));
+// }
+//
+// #[test]
+// #[should_panic]
+// fn hyphenated_too_small() {
+// Uuid::nil().to_hyphenated().encode_lower(&mut [0; 35]);
+// }
+// #[test]
+// #[should_panic]
+// fn hyphenated_ref_too_small() {
+// Uuid::nil().to_hyphenated_ref().encode_lower(&mut [0; 35]);
+// }
+//
+// #[test]
+// #[should_panic]
+// fn simple_too_small() {
+// Uuid::nil().to_simple().encode_lower(&mut [0; 31]);
+// }
+// #[test]
+// #[should_panic]
+// fn simple_ref_too_small() {
+// Uuid::nil().to_simple_ref().encode_lower(&mut [0; 31]);
+// }
+// #[test]
+// #[should_panic]
+// fn urn_too_small() {
+// Uuid::nil().to_urn().encode_lower(&mut [0; 44]);
+// }
+// #[test]
+// #[should_panic]
+// fn urn_ref_too_small() {
+// Uuid::nil().to_urn_ref().encode_lower(&mut [0; 44]);
+// }
+// }
diff --git a/rustc_deps/vendor/uuid/src/core_support.rs b/rustc_deps/vendor/uuid/src/core_support.rs
new file mode 100644
index 0000000..82864d9
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/core_support.rs
@@ -0,0 +1,179 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// 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.
+
+use core::{fmt, str};
+use parser;
+use prelude::*;
+
+impl fmt::Display for Uuid {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(self, f)
+    }
+}
+
+impl fmt::Display for Variant {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Variant::NCS => write!(f, "NCS"),
+            Variant::RFC4122 => write!(f, "RFC4122"),
+            Variant::Microsoft => write!(f, "Microsoft"),
+            Variant::Future => write!(f, "Future"),
+        }
+    }
+}
+
+impl fmt::Display for ::BytesError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "invalid bytes length: expected {}, found {}",
+            self.expected(),
+            self.found()
+        )
+    }
+}
+
+impl fmt::LowerHex for Uuid {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::LowerHex::fmt(&self.to_hyphenated_ref(), f)
+    }
+}
+
+impl fmt::UpperHex for Uuid {
+    #[inline]
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::UpperHex::fmt(&self.to_hyphenated_ref(), f)
+    }
+}
+
+impl str::FromStr for Uuid {
+    type Err = parser::ParseError;
+
+    fn from_str(uuid_str: &str) -> Result<Self, Self::Err> {
+        Uuid::parse_str(uuid_str)
+    }
+}
+
+impl Default for Uuid {
+    #[inline]
+    fn default() -> Self {
+        Uuid::nil()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    extern crate std;
+
+    use self::std::prelude::v1::*;
+    use prelude::*;
+    use test_util;
+
+    macro_rules! check {
+        ($buf:ident, $format:expr, $target:expr, $len:expr, $cond:expr) => {
+            $buf.clear();
+            write!($buf, $format, $target).unwrap();
+            assert!($buf.len() == $len);
+            assert!($buf.chars().all($cond), "{}", $buf);
+        };
+    }
+
+    #[test]
+    fn test_uuid_compare() {
+        let uuid1 = test_util::new();
+        let uuid2 = test_util::new2();
+
+        assert_eq!(uuid1, uuid1);
+        assert_eq!(uuid2, uuid2);
+
+        assert_ne!(uuid1, uuid2);
+        assert_ne!(uuid2, uuid1);
+    }
+
+    #[test]
+    fn test_uuid_default() {
+        let default_uuid = Uuid::default();
+        let nil_uuid = Uuid::nil();
+
+        assert_eq!(default_uuid, nil_uuid);
+    }
+
+    #[test]
+    fn test_uuid_display() {
+        use super::fmt::Write;
+
+        let uuid = test_util::new();
+        let s = uuid.to_string();
+        let mut buffer = String::new();
+
+        assert_eq!(s, uuid.to_hyphenated().to_string());
+
+        check!(buffer, "{}", uuid, 36, |c| c.is_lowercase()
+            || c.is_digit(10)
+            || c == '-');
+    }
+
+    #[test]
+    fn test_uuid_lowerhex() {
+        use super::fmt::Write;
+
+        let mut buffer = String::new();
+        let uuid = test_util::new();
+
+        check!(buffer, "{:x}", uuid, 36, |c| c.is_lowercase()
+            || c.is_digit(10)
+            || c == '-');
+    }
+
+    // noinspection RsAssertEqual
+    #[test]
+    fn test_uuid_operator_eq() {
+        let uuid1 = test_util::new();
+        let uuid1_dup = uuid1.clone();
+        let uuid2 = test_util::new2();
+
+        assert!(uuid1 == uuid1);
+        assert!(uuid1 == uuid1_dup);
+        assert!(uuid1_dup == uuid1);
+
+        assert!(uuid1 != uuid2);
+        assert!(uuid2 != uuid1);
+        assert!(uuid1_dup != uuid2);
+        assert!(uuid2 != uuid1_dup);
+    }
+
+    #[test]
+    fn test_uuid_to_string() {
+        use super::fmt::Write;
+
+        let uuid = test_util::new();
+        let s = uuid.to_string();
+        let mut buffer = String::new();
+
+        assert_eq!(s.len(), 36);
+
+        check!(buffer, "{}", s, 36, |c| c.is_lowercase()
+            || c.is_digit(10)
+            || c == '-');
+    }
+
+    #[test]
+    fn test_uuid_upperhex() {
+        use super::fmt::Write;
+
+        let mut buffer = String::new();
+        let uuid = test_util::new();
+
+        check!(buffer, "{:X}", uuid, 36, |c| c.is_uppercase()
+            || c.is_digit(10)
+            || c == '-');
+    }
+}
diff --git a/rustc_deps/vendor/uuid/src/lib.rs b/rustc_deps/vendor/uuid/src/lib.rs
new file mode 100644
index 0000000..c27e404
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/lib.rs
@@ -0,0 +1,1461 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// 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.
+
+//! Generate and parse UUIDs.
+//!
+//! Provides support for Universally Unique Identifiers (UUIDs). A UUID is a
+//! unique 128-bit number, stored as 16 octets.  UUIDs are used to  assign
+//! unique identifiers to entities without requiring a central allocating
+//! authority.
+//!
+//! They are particularly useful in distributed systems, though can be used in
+//! disparate areas, such as databases and network protocols.  Typically a UUID
+//! is displayed in a readable string form as a sequence of hexadecimal digits,
+//! separated into groups by hyphens.
+//!
+//! The uniqueness property is not strictly guaranteed, however for all
+//! practical purposes, it can be assumed that an unintentional collision would
+//! be extremely unlikely.
+//!
+//! # Dependencies
+//!
+//! By default, this crate depends on nothing but `std` and cannot generate
+//! [`Uuid`]s. You need to enable the following Cargo features to enable
+//! various pieces of functionality:
+//!
+//! * `v1` - adds the `Uuid::new_v1` function and the ability to create a V1
+//!   using an implementation of `uuid::v1::ClockSequence` (usually
+//! `uuid::v1::Context`) and a timestamp from `time::timespec`.
+//! * `v3` - adds the `Uuid::new_v3` function and the ability to create a V3
+//!   UUID based on the MD5 hash of some data.
+//! * `v4` - adds the `Uuid::new_v4` function and the ability to randomly
+//!   generate a `Uuid`.
+//! * `v5` - adds the `Uuid::new_v5` function and the ability to create a V5
+//!   UUID based on the SHA1 hash of some data.
+//! * `serde` - adds the ability to serialize and deserialize a `Uuid` using the
+//!   `serde` crate.
+//!
+//! By default, `uuid` can be depended on with:
+//!
+//! ```toml
+//! [dependencies]
+//! uuid = "0.7"
+//! ```
+//!
+//! To activate various features, use syntax like:
+//!
+//! ```toml
+//! [dependencies]
+//! uuid = { version = "0.7", features = ["serde", "v4"] }
+//! ```
+//!
+//! You can disable default features with:
+//!
+//! ```toml
+//! [dependencies]
+//! uuid = { version = "0.7", default-features = false }
+//! ```
+//!
+//! # Examples
+//!
+//! To parse a UUID given in the simple format and print it as a urn:
+//!
+//! ```rust
+//! use uuid::Uuid;
+//!
+//! fn main() {
+//!     let my_uuid =
+//!         Uuid::parse_str("936DA01F9ABD4d9d80C702AF85C822A8").unwrap();
+//!     println!("{}", my_uuid.to_urn());
+//! }
+//! ```
+//!
+//! To create a new random (V4) UUID and print it out in hexadecimal form:
+//!
+//! ```ignore,rust
+//! // Note that this requires the `v4` feature enabled in the uuid crate.
+//!
+//! use uuid::Uuid;
+//!
+//! fn main() {
+//!     let my_uuid = Uuid::new_v4();
+//!     println!("{}", my_uuid);
+//! }
+//! ```
+//!
+//! # Strings
+//!
+//! Examples of string representations:
+//!
+//! * simple: `936DA01F9ABD4d9d80C702AF85C822A8`
+//! * hyphenated: `550e8400-e29b-41d4-a716-446655440000`
+//! * urn: `urn:uuid:F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4`
+//!
+//! # References
+//!
+//! * [Wikipedia: Universally Unique Identifier](
+//!     http://en.wikipedia.org/wiki/Universally_unique_identifier)
+//! * [RFC4122: A Universally Unique IDentifier (UUID) URN Namespace](
+//!     http://tools.ietf.org/html/rfc4122)
+
+#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(feature = "const_fn", feature(const_fn))]
+#![deny(
+    missing_copy_implementations,
+    missing_debug_implementations,
+    missing_docs
+)]
+#![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://docs.rs/uuid"
+)]
+
+#[cfg(feature = "byteorder")]
+extern crate byteorder;
+#[cfg(feature = "std")]
+extern crate core;
+#[cfg(feature = "md5")]
+extern crate md5;
+#[cfg(feature = "rand")]
+extern crate rand;
+#[cfg(feature = "serde")]
+extern crate serde;
+#[cfg(all(feature = "serde", test))]
+extern crate serde_test;
+#[cfg(feature = "sha1")]
+extern crate sha1;
+#[cfg(feature = "slog")]
+#[cfg_attr(test, macro_use)]
+extern crate slog;
+
+pub mod adapter;
+pub mod parser;
+pub mod prelude;
+#[cfg(feature = "v1")]
+pub mod v1;
+
+mod core_support;
+#[cfg(feature = "serde")]
+mod serde_support;
+#[cfg(feature = "slog")]
+mod slog_support;
+#[cfg(feature = "std")]
+mod std_support;
+#[cfg(test)]
+mod test_util;
+#[cfg(feature = "u128")]
+mod u128_support;
+#[cfg(feature = "v3")]
+mod v3;
+#[cfg(feature = "v4")]
+mod v4;
+#[cfg(feature = "v5")]
+mod v5;
+
+/// A 128-bit (16 byte) buffer containing the ID.
+pub type Bytes = [u8; 16];
+
+/// The error that can occur when creating a [`Uuid`].
+///
+/// [`Uuid`]: struct.Uuid.html
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct BytesError {
+    expected: usize,
+    found: usize,
+}
+
+/// The version of the UUID, denoting the generating algorithm.
+#[derive(Debug, PartialEq, Copy, Clone)]
+#[repr(C)]
+pub enum Version {
+    /// Special case for `nil` [`Uuid`].
+    ///
+    /// [`Uuid`]: struct.Uuid.html
+    Nil = 0,
+    /// Version 1: MAC address
+    Mac,
+    /// Version 2: DCE Security
+    Dce,
+    /// Version 3: MD5 hash
+    Md5,
+    /// Version 4: Random
+    Random,
+    /// Version 5: SHA-1 hash
+    Sha1,
+}
+
+/// The reserved variants of UUIDs.
+#[derive(Clone, Copy, Debug, PartialEq)]
+#[repr(C)]
+pub enum Variant {
+    /// Reserved by the NCS for backward compatibility
+    NCS = 0,
+    /// As described in the RFC4122 Specification (default)
+    RFC4122,
+    /// Reserved by Microsoft for backward compatibility
+    Microsoft,
+    /// Reserved for future expansion
+    Future,
+}
+
+/// A Universally Unique Identifier (UUID).
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct Uuid(Bytes);
+
+impl BytesError {
+    /// The expected number of bytes.
+    #[cfg(feature = "const_fn")]
+    #[inline]
+    pub const fn expected(&self) -> usize {
+        self.expected
+    }
+
+    /// The expected number of bytes.
+    #[cfg(not(feature = "const_fn"))]
+    #[inline]
+    pub fn expected(&self) -> usize {
+        self.expected
+    }
+
+    /// The number of bytes found.
+    #[cfg(feature = "const_fn")]
+    #[inline]
+    pub const fn found(&self) -> usize {
+        self.found
+    }
+
+    /// The number of bytes found.
+    #[cfg(not(feature = "const_fn"))]
+    #[inline]
+    pub fn found(&self) -> usize {
+        self.found
+    }
+
+    /// Create a new [`UuidError`].
+    ///
+    /// [`UuidError`]: struct.UuidError.html
+    #[cfg(feature = "const_fn")]
+    #[inline]
+    pub const fn new(expected: usize, found: usize) -> Self {
+        BytesError {
+            expected: expected,
+            found: found,
+        }
+    }
+
+    /// Create a new [`UuidError`].
+    ///
+    /// [`UuidError`]: struct.UuidError.html
+    #[cfg(not(feature = "const_fn"))]
+    #[inline]
+    pub fn new(expected: usize, found: usize) -> Self {
+        BytesError { expected, found }
+    }
+}
+
+impl Uuid {
+    /// [`Uuid`] namespace for Domain Name System (DNS).
+    ///
+    /// [`Uuid`]: struct.Uuid.html
+    pub const NAMESPACE_DNS: Self = Uuid([
+        0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0,
+        0x4f, 0xd4, 0x30, 0xc8,
+    ]);
+
+    /// [`Uuid`] namespace for ISO Object Identifiers (OIDs).
+    ///
+    /// [`Uuid`]: struct.Uuid.html
+    pub const NAMESPACE_OID: Self = Uuid([
+        0x6b, 0xa7, 0xb8, 0x12, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0,
+        0x4f, 0xd4, 0x30, 0xc8,
+    ]);
+
+    /// [`Uuid`] namespace for Uniform Resource Locators (URLs).
+    ///
+    /// [`Uuid`]: struct.Uuid.html
+    pub const NAMESPACE_URL: Self = Uuid([
+        0x6b, 0xa7, 0xb8, 0x11, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0,
+        0x4f, 0xd4, 0x30, 0xc8,
+    ]);
+
+    /// [`Uuid`] namespace for X.500 Distinguished Names (DNs).
+    ///
+    /// [`Uuid`]: struct.Uuid.html
+    pub const NAMESPACE_X500: Self = Uuid([
+        0x6b, 0xa7, 0xb8, 0x14, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0,
+        0x4f, 0xd4, 0x30, 0xc8,
+    ]);
+
+    /// The 'nil UUID'.
+    ///
+    /// The nil UUID is special form of UUID that is specified to have all
+    /// 128 bits set to zero, as defined in [IETF RFC 4122 Section 4.1.7][RFC].
+    ///
+    /// [RFC]: https://tools.ietf.org/html/rfc4122.html#section-4.1.7
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use uuid::Uuid;
+    ///
+    /// let uuid = Uuid::nil();
+    ///
+    /// assert_eq!(
+    ///     uuid.to_hyphenated().to_string(),
+    ///     "00000000-0000-0000-0000-000000000000"
+    /// );
+    /// ```
+    #[cfg(feature = "const_fn")]
+    pub const fn nil() -> Self {
+        Uuid::from_bytes([0; 16])
+    }
+
+    /// The 'nil UUID'.
+    ///
+    /// The nil UUID is special form of UUID that is specified to have all
+    /// 128 bits set to zero, as defined in [IETF RFC 4122 Section 4.1.7][RFC].
+    ///
+    /// [RFC]: https://tools.ietf.org/html/rfc4122.html#section-4.1.7
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use uuid::Uuid;
+    ///
+    /// let uuid = Uuid::nil();
+    ///
+    /// assert_eq!(
+    ///     uuid.to_hyphenated().to_string(),
+    ///     "00000000-0000-0000-0000-000000000000"
+    /// );
+    /// ```
+    #[cfg(not(feature = "const_fn"))]
+    pub fn nil() -> Uuid {
+        Uuid::from_bytes([0; 16])
+    }
+
+    /// Creates a `Uuid` from four field values.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if `d4`'s length is not 8 bytes.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use uuid::Uuid;
+    ///
+    /// let d4 = [12, 3, 9, 56, 54, 43, 8, 9];
+    ///
+    /// let uuid = Uuid::from_fields(42, 12, 5, &d4);
+    /// let uuid = uuid.map(|uuid| uuid.to_hyphenated().to_string());
+    ///
+    /// let expected_uuid =
+    ///     Ok(String::from("0000002a-000c-0005-0c03-0938362b0809"));
+    ///
+    /// assert_eq!(expected_uuid, uuid);
+    /// ```
+    ///
+    /// An invalid length:
+    ///
+    /// ```
+    /// use uuid::prelude::*;
+    ///
+    /// let d4 = [12];
+    ///
+    /// let uuid = uuid::Uuid::from_fields(42, 12, 5, &d4);
+    ///
+    /// let expected_uuid = Err(uuid::BytesError::new(8, d4.len()));
+    ///
+    /// assert_eq!(expected_uuid, uuid);
+    /// ```
+    pub fn from_fields(
+        d1: u32,
+        d2: u16,
+        d3: u16,
+        d4: &[u8],
+    ) -> Result<Uuid, BytesError> {
+        const D4_LEN: usize = 8;
+
+        let len = d4.len();
+
+        if len != D4_LEN {
+            return Err(BytesError::new(D4_LEN, len));
+        }
+
+        Ok(Uuid::from_bytes([
+            (d1 >> 24) as u8,
+            (d1 >> 16) as u8,
+            (d1 >> 8) as u8,
+            d1 as u8,
+            (d2 >> 8) as u8,
+            d2 as u8,
+            (d3 >> 8) as u8,
+            d3 as u8,
+            d4[0],
+            d4[1],
+            d4[2],
+            d4[3],
+            d4[4],
+            d4[5],
+            d4[6],
+            d4[7],
+        ]))
+    }
+
+    /// Creates a `Uuid` using the supplied bytes.
+    ///
+    /// # Errors
+    ///
+    /// This function will return an error if `b` has any length other than 16.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use uuid::Uuid;
+    ///
+    /// let bytes = [4, 54, 67, 12, 43, 2, 98, 76, 32, 50, 87, 5, 1, 33, 43, 87];
+    ///
+    /// let uuid = Uuid::from_slice(&bytes);
+    /// let uuid = uuid.map(|uuid| uuid.to_hyphenated().to_string());
+    ///
+    /// let expected_uuid =
+    ///     Ok(String::from("0436430c-2b02-624c-2032-570501212b57"));
+    ///
+    /// assert_eq!(expected_uuid, uuid);
+    /// ```
+    ///
+    /// An incorrect number of bytes:
+    ///
+    /// ```
+    /// use uuid::prelude::*;
+    ///
+    /// let bytes = [4, 54, 67, 12, 43, 2, 98, 76];
+    ///
+    /// let uuid = Uuid::from_slice(&bytes);
+    ///
+    /// let expected_uuid = Err(uuid::BytesError::new(16, 8));
+    ///
+    /// assert_eq!(expected_uuid, uuid);
+    /// ```
+    pub fn from_slice(b: &[u8]) -> Result<Uuid, BytesError> {
+        const BYTES_LEN: usize = 16;
+
+        let len = b.len();
+
+        if len != BYTES_LEN {
+            return Err(BytesError::new(BYTES_LEN, len));
+        }
+
+        let mut bytes: Bytes = [0; 16];
+        bytes.copy_from_slice(b);
+        Ok(Uuid::from_bytes(bytes))
+    }
+
+    /// Creates a `Uuid` using the supplied bytes.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use uuid::Bytes;
+    /// use uuid::Uuid;
+    ///
+    /// let bytes: Bytes = [
+    ///     70, 235, 208, 238, 14, 109, 67, 201, 185, 13, 204, 195, 90, 145, 63,
+    ///     62,
+    /// ];
+    ///
+    /// let uuid = Uuid::from_bytes(bytes);
+    /// let uuid = uuid.to_hyphenated().to_string();
+    ///
+    /// let expected_uuid = String::from("46ebd0ee-0e6d-43c9-b90d-ccc35a913f3e");
+    ///
+    /// assert_eq!(expected_uuid, uuid);
+    /// ```
+    ///
+    /// An incorrect number of bytes:
+    ///
+    /// ```compile_fail
+    /// use uuid::Uuid;
+    /// use uuid::UuidBytes;
+    ///
+    /// let bytes: UuidBytes = [4, 54, 67, 12, 43, 2, 98, 76]; // doesn't
+    /// compile
+    ///
+    /// let uuid = Uuid::from_bytes(bytes);
+    /// ```
+    #[cfg(not(feature = "const_fn"))]
+    pub fn from_bytes(bytes: Bytes) -> Uuid {
+        Uuid(bytes)
+    }
+
+    /// Creates a `Uuid` using the supplied bytes.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use uuid::Bytes;
+    /// use uuid::Uuid;
+    ///
+    /// let bytes: Bytes = [
+    ///     70, 235, 208, 238, 14, 109, 67, 201, 185, 13, 204, 195, 90, 145, 63,
+    ///     62,
+    /// ];
+    ///
+    /// let uuid = Uuid::from_bytes(bytes);
+    /// let uuid = uuid.to_hyphenated().to_string();
+    ///
+    /// let expected_uuid = String::from("46ebd0ee-0e6d-43c9-b90d-ccc35a913f3e");
+    ///
+    /// assert_eq!(expected_uuid, uuid);
+    /// ```
+    ///
+    /// An incorrect number of bytes:
+    ///
+    /// ```compile_fail
+    /// use uuid::Bytes;
+    /// use uuid::Uuid;
+    ///
+    /// let bytes: Bytes = [4, 54, 67, 12, 43, 2, 98, 76]; // doesn't compile
+    ///
+    /// let uuid = Uuid::from_bytes(bytes);
+    /// ```
+    #[cfg(feature = "const_fn")]
+    pub const fn from_bytes(bytes: Bytes) -> Uuid {
+        Uuid(bytes)
+    }
+
+    /// Creates a v4 Uuid from random bytes (e.g. bytes supplied from `Rand`
+    /// crate)
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use uuid::Bytes;
+    /// use uuid::Uuid;
+    ///
+    /// let bytes: Bytes = [
+    ///     70, 235, 208, 238, 14, 109, 67, 201, 185, 13, 204, 195, 90, 145, 63,
+    ///     62,
+    /// ];
+    /// let uuid = Uuid::from_random_bytes(bytes);
+    /// let uuid = uuid.to_hyphenated().to_string();
+    ///
+    /// let expected_uuid = String::from("46ebd0ee-0e6d-43c9-b90d-ccc35a913f3e");
+    ///
+    /// assert_eq!(expected_uuid, uuid);
+    /// ```
+    pub fn from_random_bytes(bytes: Bytes) -> Uuid {
+        let mut uuid = Uuid::from_bytes(bytes);
+        uuid.set_variant(Variant::RFC4122);
+        uuid.set_version(Version::Random);
+        uuid
+    }
+
+    /// Specifies the variant of the UUID structure
+    fn set_variant(&mut self, v: Variant) {
+        // Octet 8 contains the variant in the most significant 3 bits
+        self.0[8] = match v {
+            Variant::NCS => self.as_bytes()[8] & 0x7f, // b0xx...
+            Variant::RFC4122 => (self.as_bytes()[8] & 0x3f) | 0x80, // b10x...
+            Variant::Microsoft => (self.as_bytes()[8] & 0x1f) | 0xc0, // b110...
+            Variant::Future => (self.as_bytes()[8] & 0x1f) | 0xe0, // b111...
+        }
+    }
+
+    /// Returns the variant of the `Uuid` structure.
+    ///
+    /// This determines the interpretation of the structure of the UUID.
+    /// Currently only the RFC4122 variant is generated by this module.
+    ///
+    /// * [Variant Reference](http://tools.ietf.org/html/rfc4122#section-4.1.1)
+    pub fn get_variant(&self) -> Option<Variant> {
+        match self.as_bytes()[8] {
+            x if x & 0x80 == 0x00 => Some(Variant::NCS),
+            x if x & 0xc0 == 0x80 => Some(Variant::RFC4122),
+            x if x & 0xe0 == 0xc0 => Some(Variant::Microsoft),
+            x if x & 0xe0 == 0xe0 => Some(Variant::Future),
+            _ => None,
+        }
+    }
+
+    /// Specifies the version number of the `Uuid`.
+    fn set_version(&mut self, v: Version) {
+        self.0[6] = (self.as_bytes()[6] & 0xF) | ((v as u8) << 4);
+    }
+
+    /// Returns the version number of the `Uuid`.
+    ///
+    /// This represents the algorithm used to generate the contents.
+    ///
+    /// Currently only the Random (V4) algorithm is supported by this
+    /// module.  There are security and privacy implications for using
+    /// older versions - see [Wikipedia: Universally Unique Identifier](
+    /// http://en.wikipedia.org/wiki/Universally_unique_identifier) for
+    /// details.
+    ///
+    /// * [Version Reference](http://tools.ietf.org/html/rfc4122#section-4.1.3)
+    pub fn get_version_num(&self) -> usize {
+        (self.as_bytes()[6] >> 4) as usize
+    }
+
+    /// Returns the version of the `Uuid`.
+    ///
+    /// This represents the algorithm used to generate the contents
+    pub fn get_version(&self) -> Option<Version> {
+        let v = self.as_bytes()[6] >> 4;
+        match v {
+            0 if self.is_nil() => Some(Version::Nil),
+            1 => Some(Version::Mac),
+            2 => Some(Version::Dce),
+            3 => Some(Version::Md5),
+            4 => Some(Version::Random),
+            5 => Some(Version::Sha1),
+            _ => None,
+        }
+    }
+
+    /// Returns the four field values of the UUID.
+    ///
+    /// These values can be passed to the `from_fields()` method to get the
+    /// original `Uuid` back.
+    ///
+    /// * The first field value represents the first group of (eight) hex
+    ///   digits, taken as a big-endian `u32` value.  For V1 UUIDs, this field
+    ///   represents the low 32 bits of the timestamp.
+    /// * The second field value represents the second group of (four) hex
+    ///   digits, taken as a big-endian `u16` value.  For V1 UUIDs, this field
+    ///   represents the middle 16 bits of the timestamp.
+    /// * The third field value represents the third group of (four) hex
+    ///   digits, taken as a big-endian `u16` value.  The 4 most significant
+    ///   bits give the UUID version, and for V1 UUIDs, the last 12 bits
+    ///   represent the high 12 bits of the timestamp.
+    /// * The last field value represents the last two groups of four and
+    ///   twelve hex digits, taken in order.  The first 1-3 bits of this
+    ///   indicate the UUID variant, and for V1 UUIDs, the next 13-15 bits
+    ///   indicate the clock sequence and the last 48 bits indicate the node
+    ///   ID.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use uuid::Uuid;
+    ///
+    /// let uuid = Uuid::nil();
+    /// assert_eq!(uuid.as_fields(), (0, 0, 0, &[0u8; 8]));
+    ///
+    /// let uuid = Uuid::parse_str("936DA01F-9ABD-4D9D-80C7-02AF85C822A8").unwrap();
+    /// assert_eq!(
+    ///     uuid.as_fields(),
+    ///     (
+    ///         0x936DA01F,
+    ///         0x9ABD,
+    ///         0x4D9D,
+    ///         b"\x80\xC7\x02\xAF\x85\xC8\x22\xA8"
+    ///     )
+    /// );
+    /// ```
+    pub fn as_fields(&self) -> (u32, u16, u16, &[u8; 8]) {
+        let d1 = u32::from(self.as_bytes()[0]) << 24
+            | u32::from(self.as_bytes()[1]) << 16
+            | u32::from(self.as_bytes()[2]) << 8
+            | u32::from(self.as_bytes()[3]);
+
+        let d2 =
+            u16::from(self.as_bytes()[4]) << 8 | u16::from(self.as_bytes()[5]);
+
+        let d3 =
+            u16::from(self.as_bytes()[6]) << 8 | u16::from(self.as_bytes()[7]);
+
+        let d4: &[u8; 8] =
+            unsafe { &*(self.as_bytes()[8..16].as_ptr() as *const [u8; 8]) };
+        (d1, d2, d3, d4)
+    }
+
+    /// Returns an array of 16 octets containing the UUID data.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use uuid::Uuid;
+    ///
+    /// let uuid = Uuid::nil();
+    /// assert_eq!(uuid.as_bytes(), &[0; 16]);
+    ///
+    /// let uuid = Uuid::parse_str("936DA01F9ABD4d9d80C702AF85C822A8").unwrap();
+    /// assert_eq!(
+    ///     uuid.as_bytes(),
+    ///     &[
+    ///         147, 109, 160, 31, 154, 189, 77, 157, 128, 199, 2, 175, 133, 200,
+    ///         34, 168,
+    ///     ]
+    /// );
+    /// ```
+    #[cfg(feature = "const_fn")]
+    pub const fn as_bytes(&self) -> &Bytes {
+        &self.0
+    }
+
+    /// Returns an array of 16 octets containing the UUID data.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use uuid::Uuid;
+    ///
+    /// let uuid = Uuid::nil();
+    /// assert_eq!(uuid.as_bytes(), &[0; 16]);
+    ///
+    /// let uuid = Uuid::parse_str("936DA01F9ABD4d9d80C702AF85C822A8").unwrap();
+    /// assert_eq!(
+    ///     uuid.as_bytes(),
+    ///     &[
+    ///         147, 109, 160, 31, 154, 189, 77, 157, 128, 199, 2, 175, 133, 200,
+    ///         34, 168
+    ///     ]
+    /// );
+    /// ```
+    #[cfg(not(feature = "const_fn"))]
+    pub fn as_bytes(&self) -> &Bytes {
+        &self.0
+    }
+
+    /// Returns an Optional Tuple of (u64, u16) representing the timestamp and
+    /// counter portion of a V1 UUID.  If the supplied UUID is not V1, this
+    /// will return None
+    pub fn to_timestamp(&self) -> Option<(u64, u16)> {
+        if self
+            .get_version()
+            .map(|v| v != Version::Mac)
+            .unwrap_or(true)
+        {
+            return None;
+        }
+
+        let ts: u64 = u64::from(self.as_bytes()[6] & 0x0F) << 56
+            | u64::from(self.as_bytes()[7]) << 48
+            | u64::from(self.as_bytes()[4]) << 40
+            | u64::from(self.as_bytes()[5]) << 32
+            | u64::from(self.as_bytes()[0]) << 24
+            | u64::from(self.as_bytes()[1]) << 16
+            | u64::from(self.as_bytes()[2]) << 8
+            | u64::from(self.as_bytes()[3]);
+
+        let count: u16 = u16::from(self.as_bytes()[8] & 0x3F) << 8
+            | u16::from(self.as_bytes()[9]);
+
+        Some((ts, count))
+    }
+
+    /// Parses a `Uuid` from a string of hexadecimal digits with optional
+    /// hyphens.
+    ///
+    /// Any of the formats generated by this module (simple, hyphenated, urn)
+    /// are supported by this parsing function.
+    pub fn parse_str(mut input: &str) -> Result<Uuid, parser::ParseError> {
+        // Ensure length is valid for any of the supported formats
+        let len = input.len();
+
+        if len == adapter::Urn::LENGTH && input.starts_with("urn:uuid:") {
+            input = &input[9..];
+        } else if !parser::len_matches_any(
+            len,
+            &[adapter::Hyphenated::LENGTH, adapter::Simple::LENGTH],
+        ) {
+            return Err(parser::ParseError::InvalidLength {
+                expected: parser::Expected::Any(&[
+                    adapter::Hyphenated::LENGTH,
+                    adapter::Simple::LENGTH,
+                ]),
+                found: len,
+            });
+        }
+
+        // `digit` counts only hexadecimal digits, `i_char` counts all chars.
+        let mut digit = 0;
+        let mut group = 0;
+        let mut acc = 0;
+        let mut buffer = [0u8; 16];
+
+        for (i_char, chr) in input.bytes().enumerate() {
+            if digit as usize >= adapter::Simple::LENGTH && group != 4 {
+                if group == 0 {
+                    return Err(parser::ParseError::InvalidLength {
+                        expected: parser::Expected::Any(&[
+                            adapter::Hyphenated::LENGTH,
+                            adapter::Simple::LENGTH,
+                        ]),
+                        found: len,
+                    });
+                }
+
+                return Err(parser::ParseError::InvalidGroupCount {
+                    expected: parser::Expected::Any(&[1, 5]),
+                    found: group + 1,
+                });
+            }
+
+            if digit % 2 == 0 {
+                // First digit of the byte.
+                match chr {
+                    // Calulate upper half.
+                    b'0'...b'9' => acc = chr - b'0',
+                    b'a'...b'f' => acc = chr - b'a' + 10,
+                    b'A'...b'F' => acc = chr - b'A' + 10,
+                    // Found a group delimiter
+                    b'-' => {
+                        // TODO: remove the u8 cast
+                        // BODY: this only needed until we switch to
+                        //       ParseError
+                        if parser::ACC_GROUP_LENS[group] as u8 != digit {
+                            // Calculate how many digits this group consists of
+                            // in the input.
+                            let found = if group > 0 {
+                                // TODO: remove the u8 cast
+                                // BODY: this only needed until we switch to
+                                //       ParseError
+                                digit - parser::ACC_GROUP_LENS[group - 1] as u8
+                            } else {
+                                digit
+                            };
+
+                            return Err(
+                                parser::ParseError::InvalidGroupLength {
+                                    expected: parser::Expected::Exact(
+                                        parser::GROUP_LENS[group],
+                                    ),
+                                    found: found as usize,
+                                    group,
+                                },
+                            );
+                        }
+                        // Next group, decrement digit, it is incremented again
+                        // at the bottom.
+                        group += 1;
+                        digit -= 1;
+                    }
+                    _ => {
+                        return Err(parser::ParseError::InvalidCharacter {
+                            expected: "0123456789abcdefABCDEF-",
+                            found: input[i_char..].chars().next().unwrap(),
+                            index: i_char,
+                        });
+                    }
+                }
+            } else {
+                // Second digit of the byte, shift the upper half.
+                acc *= 16;
+                match chr {
+                    b'0'...b'9' => acc += chr - b'0',
+                    b'a'...b'f' => acc += chr - b'a' + 10,
+                    b'A'...b'F' => acc += chr - b'A' + 10,
+                    b'-' => {
+                        // The byte isn't complete yet.
+                        let found = if group > 0 {
+                            // TODO: remove the u8 cast
+                            // BODY: this only needed until we switch to
+                            //       ParseError
+                            digit - parser::ACC_GROUP_LENS[group - 1] as u8
+                        } else {
+                            digit
+                        };
+
+                        return Err(parser::ParseError::InvalidGroupLength {
+                            expected: parser::Expected::Exact(
+                                parser::GROUP_LENS[group],
+                            ),
+                            found: found as usize,
+                            group,
+                        });
+                    }
+                    _ => {
+                        return Err(parser::ParseError::InvalidCharacter {
+                            expected: "0123456789abcdefABCDEF-",
+                            found: input[i_char..].chars().next().unwrap(),
+                            index: i_char,
+                        });
+                    }
+                }
+                buffer[(digit / 2) as usize] = acc;
+            }
+            digit += 1;
+        }
+
+        // Now check the last group.
+        // TODO: remove the u8 cast
+        // BODY: this only needed until we switch to
+        //       ParseError
+        if parser::ACC_GROUP_LENS[4] as u8 != digit {
+            return Err(parser::ParseError::InvalidGroupLength {
+                expected: parser::Expected::Exact(parser::GROUP_LENS[4]),
+                found: (digit as usize - parser::ACC_GROUP_LENS[3]),
+                group,
+            });
+        }
+
+        Ok(Uuid::from_bytes(buffer))
+    }
+
+    /// Tests if the UUID is nil
+    pub fn is_nil(&self) -> bool {
+        self.as_bytes().iter().all(|&b| b == 0)
+    }
+    // A buffer that can be used for `encode_...` calls, that is
+    // guaranteed to be long enough for any of the adapters.
+    //
+    // # Examples
+    //
+    // ```rust
+    // use uuid::Uuid;
+    //
+    // let uuid = Uuid::nil();
+    //
+    // assert_eq!(
+    //     uuid.to_simple().encode_lower(&mut Uuid::encode_buffer()),
+    //     "00000000000000000000000000000000"
+    // );
+    //
+    // assert_eq!(
+    //     uuid.to_hyphenated()
+    //         .encode_lower(&mut Uuid::encode_buffer()),
+    //     "00000000-0000-0000-0000-000000000000"
+    // );
+    //
+    // assert_eq!(
+    //     uuid.to_urn().encode_lower(&mut Uuid::encode_buffer()),
+    //     "urn:uuid:00000000-0000-0000-0000-000000000000"
+    // );
+    // ```
+    pub(crate) fn encode_buffer() -> [u8; adapter::Urn::LENGTH] {
+        [0; adapter::Urn::LENGTH]
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    extern crate std;
+
+    use self::std::prelude::v1::*;
+    use super::test_util;
+    use prelude::*;
+
+    #[test]
+    fn test_nil() {
+        let nil = Uuid::nil();
+        let not_nil = test_util::new();
+        let from_bytes = Uuid::from_bytes([
+            4, 54, 67, 12, 43, 2, 2, 76, 32, 50, 87, 5, 1, 33, 43, 87,
+        ]);
+
+        assert_eq!(from_bytes.get_version(), None);
+
+        assert!(nil.is_nil());
+        assert!(!not_nil.is_nil());
+
+        assert_eq!(nil.get_version(), Some(Version::Nil));
+        assert_eq!(not_nil.get_version(), Some(Version::Random))
+    }
+
+    #[test]
+    fn test_predefined_namespaces() {
+        assert_eq!(
+            Uuid::NAMESPACE_DNS.to_hyphenated().to_string(),
+            "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+        );
+        assert_eq!(
+            Uuid::NAMESPACE_URL.to_hyphenated().to_string(),
+            "6ba7b811-9dad-11d1-80b4-00c04fd430c8"
+        );
+        assert_eq!(
+            Uuid::NAMESPACE_OID.to_hyphenated().to_string(),
+            "6ba7b812-9dad-11d1-80b4-00c04fd430c8"
+        );
+        assert_eq!(
+            Uuid::NAMESPACE_X500.to_hyphenated().to_string(),
+            "6ba7b814-9dad-11d1-80b4-00c04fd430c8"
+        );
+    }
+
+    #[cfg(feature = "v3")]
+    #[test]
+    fn test_get_version_v3() {
+        let uuid =
+            Uuid::new_v3(&Uuid::NAMESPACE_DNS, "rust-lang.org".as_bytes());
+
+        assert_eq!(uuid.get_version().unwrap(), Version::Md5);
+        assert_eq!(uuid.get_version_num(), 3);
+    }
+
+    #[test]
+    fn test_get_variant() {
+        let uuid1 = test_util::new();
+        let uuid2 =
+            Uuid::parse_str("550e8400-e29b-41d4-a716-446655440000").unwrap();
+        let uuid3 =
+            Uuid::parse_str("67e55044-10b1-426f-9247-bb680e5fe0c8").unwrap();
+        let uuid4 =
+            Uuid::parse_str("936DA01F9ABD4d9dC0C702AF85C822A8").unwrap();
+        let uuid5 =
+            Uuid::parse_str("F9168C5E-CEB2-4faa-D6BF-329BF39FA1E4").unwrap();
+        let uuid6 =
+            Uuid::parse_str("f81d4fae-7dec-11d0-7765-00a0c91e6bf6").unwrap();
+
+        assert_eq!(uuid1.get_variant().unwrap(), Variant::RFC4122);
+        assert_eq!(uuid2.get_variant().unwrap(), Variant::RFC4122);
+        assert_eq!(uuid3.get_variant().unwrap(), Variant::RFC4122);
+        assert_eq!(uuid4.get_variant().unwrap(), Variant::Microsoft);
+        assert_eq!(uuid5.get_variant().unwrap(), Variant::Microsoft);
+        assert_eq!(uuid6.get_variant().unwrap(), Variant::NCS);
+    }
+
+    #[test]
+    fn test_parse_uuid_v4() {
+        use adapter;
+        use parser;
+
+        const EXPECTED_UUID_LENGTHS: parser::Expected =
+            parser::Expected::Any(&[
+                adapter::Hyphenated::LENGTH,
+                adapter::Simple::LENGTH,
+            ]);
+
+        const EXPECTED_GROUP_COUNTS: parser::Expected =
+            parser::Expected::Any(&[1, 5]);
+
+        const EXPECTED_CHARS: &'static str = "0123456789abcdefABCDEF-";
+
+        // Invalid
+        assert_eq!(
+            Uuid::parse_str(""),
+            Err(parser::ParseError::InvalidLength {
+                expected: EXPECTED_UUID_LENGTHS,
+                found: 0,
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("!"),
+            Err(parser::ParseError::InvalidLength {
+                expected: EXPECTED_UUID_LENGTHS,
+                found: 1
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E45"),
+            Err(parser::ParseError::InvalidLength {
+                expected: EXPECTED_UUID_LENGTHS,
+                found: 37,
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("F9168C5E-CEB2-4faa-BBF-329BF39FA1E4"),
+            Err(parser::ParseError::InvalidLength {
+                expected: EXPECTED_UUID_LENGTHS,
+                found: 35
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("F9168C5E-CEB2-4faa-BGBF-329BF39FA1E4"),
+            Err(parser::ParseError::InvalidCharacter {
+                expected: EXPECTED_CHARS,
+                found: 'G',
+                index: 20,
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("F9168C5E-CEB2F4faaFB6BFF329BF39FA1E4"),
+            Err(parser::ParseError::InvalidGroupCount {
+                expected: EXPECTED_GROUP_COUNTS,
+                found: 2
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("F9168C5E-CEB2-4faaFB6BFF329BF39FA1E4"),
+            Err(parser::ParseError::InvalidGroupCount {
+                expected: EXPECTED_GROUP_COUNTS,
+                found: 3,
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("F9168C5E-CEB2-4faa-B6BFF329BF39FA1E4"),
+            Err(parser::ParseError::InvalidGroupCount {
+                expected: EXPECTED_GROUP_COUNTS,
+                found: 4,
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("F9168C5E-CEB2-4faa"),
+            Err(parser::ParseError::InvalidLength {
+                expected: EXPECTED_UUID_LENGTHS,
+                found: 18,
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("F9168C5E-CEB2-4faaXB6BFF329BF39FA1E4"),
+            Err(parser::ParseError::InvalidCharacter {
+                expected: EXPECTED_CHARS,
+                found: 'X',
+                index: 18,
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("F9168C5E-CEB-24fa-eB6BFF32-BF39FA1E4"),
+            Err(parser::ParseError::InvalidGroupLength {
+                expected: parser::Expected::Exact(4),
+                found: 3,
+                group: 1,
+            })
+        );
+        // (group, found, expecting)
+        //
+        assert_eq!(
+            Uuid::parse_str("01020304-1112-2122-3132-41424344"),
+            Err(parser::ParseError::InvalidGroupLength {
+                expected: parser::Expected::Exact(12),
+                found: 8,
+                group: 4,
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c"),
+            Err(parser::ParseError::InvalidLength {
+                expected: EXPECTED_UUID_LENGTHS,
+                found: 31,
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c88"),
+            Err(parser::ParseError::InvalidLength {
+                expected: EXPECTED_UUID_LENGTHS,
+                found: 33,
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("67e5504410b1426f9247bb680e5fe0cg8"),
+            Err(parser::ParseError::InvalidLength {
+                expected: EXPECTED_UUID_LENGTHS,
+                found: 33,
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("67e5504410b1426%9247bb680e5fe0c8"),
+            Err(parser::ParseError::InvalidCharacter {
+                expected: EXPECTED_CHARS,
+                found: '%',
+                index: 15,
+            })
+        );
+
+        assert_eq!(
+            Uuid::parse_str("231231212212423424324323477343246663"),
+            Err(parser::ParseError::InvalidLength {
+                expected: EXPECTED_UUID_LENGTHS,
+                found: 36,
+            })
+        );
+
+        // Valid
+        assert!(Uuid::parse_str("00000000000000000000000000000000").is_ok());
+        assert!(
+            Uuid::parse_str("67e55044-10b1-426f-9247-bb680e5fe0c8").is_ok()
+        );
+        assert!(
+            Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF-329BF39FA1E4").is_ok()
+        );
+        assert!(Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c8").is_ok());
+        assert!(
+            Uuid::parse_str("01020304-1112-2122-3132-414243444546").is_ok()
+        );
+        assert!(
+            Uuid::parse_str("urn:uuid:67e55044-10b1-426f-9247-bb680e5fe0c8")
+                .is_ok()
+        );
+
+        // Nil
+        let nil = Uuid::nil();
+        assert_eq!(
+            Uuid::parse_str("00000000000000000000000000000000").unwrap(),
+            nil
+        );
+        assert_eq!(
+            Uuid::parse_str("00000000-0000-0000-0000-000000000000").unwrap(),
+            nil
+        );
+
+        // Round-trip
+        let uuid_orig = test_util::new();
+        let orig_str = uuid_orig.to_string();
+        let uuid_out = Uuid::parse_str(&orig_str).unwrap();
+        assert_eq!(uuid_orig, uuid_out);
+
+        // Test error reporting
+        assert_eq!(
+            Uuid::parse_str("67e5504410b1426f9247bb680e5fe0c"),
+            Err(parser::ParseError::InvalidLength {
+                expected: EXPECTED_UUID_LENGTHS,
+                found: 31,
+            })
+        );
+        assert_eq!(
+            Uuid::parse_str("67e550X410b1426f9247bb680e5fe0cd"),
+            Err(parser::ParseError::InvalidCharacter {
+                expected: EXPECTED_CHARS,
+                found: 'X',
+                index: 6,
+            })
+        );
+        assert_eq!(
+            Uuid::parse_str("67e550-4105b1426f9247bb680e5fe0c"),
+            Err(parser::ParseError::InvalidGroupLength {
+                expected: parser::Expected::Exact(8),
+                found: 6,
+                group: 0,
+            })
+        );
+        assert_eq!(
+            Uuid::parse_str("F9168C5E-CEB2-4faa-B6BF1-02BF39FA1E4"),
+            Err(parser::ParseError::InvalidGroupLength {
+                expected: parser::Expected::Exact(4),
+                found: 5,
+                group: 3,
+            })
+        );
+    }
+
+    #[test]
+    fn test_to_simple_string() {
+        let uuid1 = test_util::new();
+        let s = uuid1.to_simple().to_string();
+
+        assert_eq!(s.len(), 32);
+        assert!(s.chars().all(|c| c.is_digit(16)));
+    }
+
+    #[test]
+    fn test_to_hyphenated_string() {
+        let uuid1 = test_util::new();
+        let s = uuid1.to_hyphenated().to_string();
+
+        assert!(s.len() == 36);
+        assert!(s.chars().all(|c| c.is_digit(16) || c == '-'));
+    }
+
+    #[test]
+    fn test_upper_lower_hex() {
+        use tests::std::fmt::Write;
+
+        let mut buf = String::new();
+        let u = test_util::new();
+
+        macro_rules! check {
+            ($buf:ident, $format:expr, $target:expr, $len:expr, $cond:expr) => {
+                $buf.clear();
+                write!($buf, $format, $target).unwrap();
+                assert!(buf.len() == $len);
+                assert!($buf.chars().all($cond), "{}", $buf);
+            };
+        }
+
+        check!(buf, "{:X}", u, 36, |c| c.is_uppercase()
+            || c.is_digit(10)
+            || c == '-');
+        check!(buf, "{:X}", u.to_hyphenated(), 36, |c| c.is_uppercase()
+            || c.is_digit(10)
+            || c == '-');
+        check!(buf, "{:X}", u.to_simple(), 32, |c| c.is_uppercase()
+            || c.is_digit(10));
+
+        check!(buf, "{:x}", u.to_hyphenated(), 36, |c| c.is_lowercase()
+            || c.is_digit(10)
+            || c == '-');
+        check!(buf, "{:x}", u.to_simple(), 32, |c| c.is_lowercase()
+            || c.is_digit(10));
+    }
+
+    #[test]
+    fn test_to_urn_string() {
+        let uuid1 = test_util::new();
+        let ss = uuid1.to_urn().to_string();
+        let s = &ss[9..];
+
+        assert!(ss.starts_with("urn:uuid:"));
+        assert_eq!(s.len(), 36);
+        assert!(s.chars().all(|c| c.is_digit(16) || c == '-'));
+    }
+
+    #[test]
+    fn test_to_simple_string_matching() {
+        let uuid1 = test_util::new();
+
+        let hs = uuid1.to_hyphenated().to_string();
+        let ss = uuid1.to_simple().to_string();
+
+        let hsn = hs.chars().filter(|&c| c != '-').collect::<String>();
+
+        assert_eq!(hsn, ss);
+    }
+
+    #[test]
+    fn test_string_roundtrip() {
+        let uuid = test_util::new();
+
+        let hs = uuid.to_hyphenated().to_string();
+        let uuid_hs = Uuid::parse_str(&hs).unwrap();
+        assert_eq!(uuid_hs, uuid);
+
+        let ss = uuid.to_string();
+        let uuid_ss = Uuid::parse_str(&ss).unwrap();
+        assert_eq!(uuid_ss, uuid);
+    }
+
+    #[test]
+    fn test_from_fields() {
+        let d1: u32 = 0xa1a2a3a4;
+        let d2: u16 = 0xb1b2;
+        let d3: u16 = 0xc1c2;
+        let d4 = [0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8];
+
+        let u = Uuid::from_fields(d1, d2, d3, &d4).unwrap();
+
+        let expected = "a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8";
+        let result = u.to_simple().to_string();
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_as_fields() {
+        let u = test_util::new();
+        let (d1, d2, d3, d4) = u.as_fields();
+
+        assert_ne!(d1, 0);
+        assert_ne!(d2, 0);
+        assert_ne!(d3, 0);
+        assert_eq!(d4.len(), 8);
+        assert!(!d4.iter().all(|&b| b == 0));
+    }
+
+    #[test]
+    fn test_fields_roundtrip() {
+        let d1_in: u32 = 0xa1a2a3a4;
+        let d2_in: u16 = 0xb1b2;
+        let d3_in: u16 = 0xc1c2;
+        let d4_in = &[0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8];
+
+        let u = Uuid::from_fields(d1_in, d2_in, d3_in, d4_in).unwrap();
+        let (d1_out, d2_out, d3_out, d4_out) = u.as_fields();
+
+        assert_eq!(d1_in, d1_out);
+        assert_eq!(d2_in, d2_out);
+        assert_eq!(d3_in, d3_out);
+        assert_eq!(d4_in, d4_out);
+    }
+
+    #[test]
+    fn test_from_slice() {
+        let b = [
+            0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2, 0xd1, 0xd2, 0xd3,
+            0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
+        ];
+
+        let u = Uuid::from_slice(&b).unwrap();
+        let expected = "a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8";
+
+        assert_eq!(u.to_simple().to_string(), expected);
+    }
+
+    #[test]
+    fn test_from_bytes() {
+        let b = [
+            0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2, 0xd1, 0xd2, 0xd3,
+            0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
+        ];
+
+        let u = Uuid::from_bytes(b);
+        let expected = "a1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8";
+
+        assert_eq!(u.to_simple().to_string(), expected);
+    }
+
+    #[test]
+    fn test_as_bytes() {
+        let u = test_util::new();
+        let ub = u.as_bytes();
+
+        assert_eq!(ub.len(), 16);
+        assert!(!ub.iter().all(|&b| b == 0));
+    }
+
+    #[test]
+    fn test_bytes_roundtrip() {
+        let b_in: ::Bytes = [
+            0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2, 0xd1, 0xd2, 0xd3,
+            0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
+        ];
+
+        let u = Uuid::from_slice(&b_in).unwrap();
+
+        let b_out = u.as_bytes();
+
+        assert_eq!(&b_in, b_out);
+    }
+
+    #[test]
+    fn test_from_random_bytes() {
+        let b = [
+            0xa1, 0xa2, 0xa3, 0xa4, 0xb1, 0xb2, 0xc1, 0xc2, 0xd1, 0xd2, 0xd3,
+            0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
+        ];
+
+        let u = Uuid::from_random_bytes(b);
+        let expected = "a1a2a3a4b1b241c291d2d3d4d5d6d7d8";
+
+        assert_eq!(u.to_simple().to_string(), expected);
+    }
+
+    #[test]
+    fn test_iterbytes_impl_for_uuid() {
+        let mut set = std::collections::HashSet::new();
+        let id1 = test_util::new();
+        let id2 = test_util::new2();
+        set.insert(id1.clone());
+
+        assert!(set.contains(&id1));
+        assert!(!set.contains(&id2));
+    }
+}
diff --git a/rustc_deps/vendor/uuid/src/parser/core_support.rs b/rustc_deps/vendor/uuid/src/parser/core_support.rs
new file mode 100644
index 0000000..d358bed
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/parser/core_support.rs
@@ -0,0 +1,62 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// 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.
+
+use core::fmt;
+use parser;
+
+impl<'a> fmt::Display for parser::Expected {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            parser::Expected::Any(ref crits) => write!(f, "one of {:?}", crits),
+            parser::Expected::Exact(crit) => write!(f, "{}", crit),
+            parser::Expected::Range { min, max } => {
+                write!(f, "{}..{} inclusive", min, max)
+            }
+        }
+    }
+}
+
+impl fmt::Display for parser::ParseError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}: ", self._description())?;
+
+        match *self {
+            parser::ParseError::InvalidCharacter {
+                expected,
+                found,
+                index,
+            } => write!(
+                f,
+                "expected {:?}, found {} at {}",
+                expected.chars(),
+                found,
+                index
+            ),
+            parser::ParseError::InvalidGroupCount {
+                ref expected,
+                found,
+            } => write!(f, "expected {}, found {}", expected, found),
+            parser::ParseError::InvalidGroupLength {
+                ref expected,
+                found,
+                group,
+            } => write!(
+                f,
+                "expected {}, found {} in group {}",
+                expected, found, group,
+            ),
+            parser::ParseError::InvalidLength {
+                ref expected,
+                found,
+            } => write!(f, "expected {}, found {}", expected, found),
+        }
+    }
+}
diff --git a/rustc_deps/vendor/uuid/src/parser/mod.rs b/rustc_deps/vendor/uuid/src/parser/mod.rs
new file mode 100644
index 0000000..edd959d
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/parser/mod.rs
@@ -0,0 +1,128 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// 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.
+
+//! [`Uuid`] parsing constructs and utilities.
+//!
+//! [`Uuid`]: ../struct.Uuid.html
+
+mod core_support;
+#[cfg(feature = "std")]
+mod std_support;
+
+/// The expected value.
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum Expected {
+    /// Expected any one of the given values.
+    Any(&'static [usize]),
+    /// Expected the given value.
+    Exact(usize),
+    /// Expected any values in the given range.
+    Range {
+        /// The minimum expected value.
+        min: usize,
+        /// The maximum expected value.
+        max: usize,
+    },
+}
+
+/// An error that can occur while parsing a [`Uuid`] string.
+///
+/// [`Uuid`]: ../struct.Uuid.html
+#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum ParseError {
+    /// Invalid character in the [`Uuid`] string.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    InvalidCharacter {
+        /// The expected characters.
+        expected: &'static str,
+        /// The invalid character found.
+        found: char,
+        /// The invalid character position.
+        index: usize,
+    },
+    /// Invalid number of segments in the [`Uuid`] string.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    InvalidGroupCount {
+        /// The expected number of segments.
+        // TODO: explain multiple segment count.
+        // BODY: Parsers can expect a range of Uuid segment count.
+        //       This needs to be expanded on.
+        expected: Expected,
+        /// The number of segments found.
+        found: usize,
+    },
+    /// Invalid length of a segment in a [`Uuid`] string.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    InvalidGroupLength {
+        /// The expected length of the segment.
+        expected: Expected,
+        /// The length of segment found.
+        found: usize,
+        /// The segment with invalid length.
+        group: usize,
+    },
+    /// Invalid length of the [`Uuid`] string.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    InvalidLength {
+        /// The expected length(s).
+        // TODO: explain multiple lengths.
+        // BODY: Parsers can expect a range of Uuid lenghts.
+        //       This needs to be expanded on.
+        expected: Expected,
+        /// The invalid length found.
+        found: usize,
+    },
+}
+
+impl ParseError {
+    fn _description(&self) -> &str {
+        match *self {
+            ParseError::InvalidCharacter { .. } => "invalid character",
+            ParseError::InvalidGroupCount { .. } => "invalid number of groups",
+            ParseError::InvalidGroupLength { .. } => "invalid group length",
+            ParseError::InvalidLength { .. } => "invalid length",
+        }
+    }
+}
+
+/// Check if the length matches any of the given criteria lengths.
+pub(crate) fn len_matches_any(len: usize, crits: &[usize]) -> bool {
+    for crit in crits {
+        if len == *crit {
+            return true;
+        }
+    }
+
+    false
+}
+
+/// Check if the length matches any criteria lengths in the given range
+/// (inclusive).
+#[allow(dead_code)]
+pub(crate) fn len_matches_range(len: usize, min: usize, max: usize) -> bool {
+    for crit in min..(max + 1) {
+        if len == crit {
+            return true;
+        }
+    }
+
+    false
+}
+
+// Accumulated length of each hyphenated group in hex digits.
+pub(crate) const ACC_GROUP_LENS: [usize; 5] = [8, 12, 16, 20, 32];
+
+// Length of each hyphenated group in hex digits.
+pub(crate) const GROUP_LENS: [usize; 5] = [8, 4, 4, 4, 12];
diff --git a/rustc_deps/vendor/uuid/src/parser/std_support.rs b/rustc_deps/vendor/uuid/src/parser/std_support.rs
new file mode 100644
index 0000000..2307012
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/parser/std_support.rs
@@ -0,0 +1,19 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// 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.
+
+use parser;
+use std::error;
+
+impl error::Error for parser::ParseError {
+    fn description(&self) -> &str {
+        self._description()
+    }
+}
diff --git a/rustc_deps/vendor/uuid/src/prelude.rs b/rustc_deps/vendor/uuid/src/prelude.rs
new file mode 100644
index 0000000..5351fd0
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/prelude.rs
@@ -0,0 +1,51 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// 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.
+
+//! The [`uuid`] prelude.
+//!
+//! This module contains the most important items of the [`uuid`] crate.
+//!
+//! To use the prelude, include the following in your crate root:
+//!
+//! ```rust
+//! extern crate uuid;
+//! ```
+//!
+//! and the following in every module:
+//!
+//! ```rust
+//! use uuid::prelude::*;
+//! ```
+//!
+//! # Prelude Contents
+//!
+//! Currently the prelude reexports the following:
+//!
+//! [`uuid`]`::{`[`Uuid`], [`Variant`], [`Version`]`}`: The fundamental
+//! types used in [`uuid`] crate.
+//!
+//! [`uuid`]: ../index.html
+//! [`Uuid`]: ../struct.Uuid.html
+//! [`Variant`]: ../enum.Variant.html
+//! [`Version`]: ../enum.Version.html
+//!
+#![cfg_attr(feature = "v1",
+doc = "
+[`uuid::v1`]`::{`[`ClockSequence`],[`Context`]`}`: The types useful for
+handling uuid version 1. Requires feature `v1`.
+
+[`uuid::v1`]: ../v1/index.html
+[`Context`]: ../v1/struct.Context.html
+[`ClockSequence`]: ../v1/trait.ClockSequence.html")]
+
+pub use super::{Bytes, Uuid, Variant, Version};
+#[cfg(feature = "v1")]
+pub use v1::{ClockSequence, Context};
diff --git a/rustc_deps/vendor/uuid/src/serde_support.rs b/rustc_deps/vendor/uuid/src/serde_support.rs
new file mode 100644
index 0000000..f71eb44
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/serde_support.rs
@@ -0,0 +1,118 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// 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.
+
+use core::fmt;
+use prelude::*;
+use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
+
+impl Serialize for Uuid {
+    fn serialize<S: Serializer>(
+        &self,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        if serializer.is_human_readable() {
+            serializer
+                .serialize_str(&self.to_hyphenated().encode_lower(&mut [0; 36]))
+        } else {
+            serializer.serialize_bytes(self.as_bytes())
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for Uuid {
+    fn deserialize<D: Deserializer<'de>>(
+        deserializer: D,
+    ) -> Result<Self, D::Error> {
+        if deserializer.is_human_readable() {
+            struct UuidStringVisitor;
+
+            impl<'vi> de::Visitor<'vi> for UuidStringVisitor {
+                type Value = Uuid;
+
+                fn expecting(
+                    &self,
+                    formatter: &mut fmt::Formatter,
+                ) -> fmt::Result {
+                    write!(formatter, "a UUID string")
+                }
+
+                fn visit_str<E: de::Error>(
+                    self,
+                    value: &str,
+                ) -> Result<Uuid, E> {
+                    value.parse::<Uuid>().map_err(E::custom)
+                }
+
+                fn visit_bytes<E: de::Error>(
+                    self,
+                    value: &[u8],
+                ) -> Result<Uuid, E> {
+                    Uuid::from_slice(value).map_err(E::custom)
+                }
+            }
+
+            deserializer.deserialize_str(UuidStringVisitor)
+        } else {
+            struct UuidBytesVisitor;
+
+            impl<'vi> de::Visitor<'vi> for UuidBytesVisitor {
+                type Value = Uuid;
+
+                fn expecting(
+                    &self,
+                    formatter: &mut fmt::Formatter,
+                ) -> fmt::Result {
+                    write!(formatter, "bytes")
+                }
+
+                fn visit_bytes<E: de::Error>(
+                    self,
+                    value: &[u8],
+                ) -> Result<Uuid, E> {
+                    Uuid::from_slice(value).map_err(E::custom)
+                }
+            }
+
+            deserializer.deserialize_bytes(UuidBytesVisitor)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_test;
+
+    use prelude::*;
+
+    #[test]
+    fn test_serialize_readable() {
+        use serde_test::Configure;
+
+        let uuid_str = "f9168c5e-ceb2-4faa-b6bf-329bf39fa1e4";
+        let u = Uuid::parse_str(uuid_str).unwrap();
+        serde_test::assert_tokens(
+            &u.readable(),
+            &[serde_test::Token::Str(uuid_str)],
+        );
+    }
+
+    #[test]
+    fn test_serialize_compact() {
+        use serde_test::Configure;
+
+        let uuid_bytes = b"F9168C5E-CEB2-4F";
+        let u = Uuid::from_slice(uuid_bytes).unwrap();
+        serde_test::assert_tokens(
+            &u.compact(),
+            &[serde_test::Token::Bytes(uuid_bytes)],
+        );
+    }
+}
diff --git a/rustc_deps/vendor/uuid/src/slog_support.rs b/rustc_deps/vendor/uuid/src/slog_support.rs
new file mode 100644
index 0000000..2de9ce9
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/slog_support.rs
@@ -0,0 +1,39 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// 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.
+
+use prelude::*;
+use slog;
+
+impl slog::Value for Uuid {
+    fn serialize(
+        &self,
+        _: &slog::Record,
+        key: slog::Key,
+        serializer: &mut slog::Serializer,
+    ) -> Result<(), slog::Error> {
+        serializer.emit_arguments(key, &format_args!("{}", self))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    #[test]
+    fn test_slog_kv() {
+        use slog;
+        use slog::Drain;
+        use test_util;
+
+        let root = slog::Logger::root(slog::Discard.fuse(), o!());
+        let u1 = test_util::new();
+        crit!(root, "test"; "u1" => u1);
+    }
+}
diff --git a/rustc_deps/vendor/uuid/src/std_support.rs b/rustc_deps/vendor/uuid/src/std_support.rs
new file mode 100644
index 0000000..f6f9aea
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/std_support.rs
@@ -0,0 +1,18 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// 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.
+
+use std::error;
+
+impl error::Error for ::BytesError {
+    fn description(&self) -> &str {
+        "invalid number of uuid bytes"
+    }
+}
diff --git a/rustc_deps/vendor/uuid/src/test_util.rs b/rustc_deps/vendor/uuid/src/test_util.rs
new file mode 100644
index 0000000..22b38c1
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/test_util.rs
@@ -0,0 +1,26 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// 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.
+
+use prelude::*;
+
+pub fn new() -> Uuid {
+    Uuid::from_bytes([
+        0xF9, 0x16, 0x8C, 0x5E, 0xCE, 0xB2, 0x4F, 0xAA, 0xB6, 0xBF, 0x32, 0x9B,
+        0xF3, 0x9F, 0xA1, 0xE4,
+    ])
+}
+
+pub fn new2() -> Uuid {
+    Uuid::from_bytes([
+        0xF9, 0x16, 0x8C, 0x5E, 0xCE, 0xB2, 0x4F, 0xAB, 0xB6, 0xBF, 0x32, 0x9B,
+        0xF3, 0x9F, 0xA1, 0xE4,
+    ])
+}
diff --git a/rustc_deps/vendor/uuid/src/u128_support.rs b/rustc_deps/vendor/uuid/src/u128_support.rs
new file mode 100644
index 0000000..3fc52d9
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/u128_support.rs
@@ -0,0 +1,57 @@
+// Copyright 2013-2014 The Rust Project Developers.
+// Copyright 2018 The Uuid Project Developers.
+//
+// See the COPYRIGHT file at the top-level directory of this distribution.
+//
+// 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.
+
+use byteorder;
+use prelude::*;
+
+impl Uuid {
+    /// Creates a new [`Uuid`] from a `u128` value.
+    ///
+    /// To create a [`Uuid`] from `u128`s, you need `u128` feature enabled for
+    /// this crate.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    #[inline]
+    pub fn from_u128(quad: u128) -> Self {
+        Uuid::from(quad)
+    }
+}
+
+impl From<u128> for Uuid {
+    fn from(f: u128) -> Self {
+        let mut bytes: ::Bytes = [0; 16];
+
+        {
+            use byteorder::ByteOrder;
+
+            byteorder::NativeEndian::write_u128(&mut bytes[..], f);
+        }
+
+        Uuid::from_bytes(bytes)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use prelude::*;
+
+    #[test]
+    fn test_from_u128() {
+        const U128: u128 = 0x3a0724b4_93a0_4d87_ac28_759c6caa13c4;
+
+        let uuid = Uuid::from(U128);
+
+        let uuid2: Uuid = U128.into();
+
+        assert_eq!(uuid, uuid2)
+    }
+
+}
diff --git a/rustc_deps/vendor/uuid/src/v1.rs b/rustc_deps/vendor/uuid/src/v1.rs
new file mode 100644
index 0000000..dc5a057
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/v1.rs
@@ -0,0 +1,195 @@
+//! The implementation for Version 1 [`Uuid`]s.
+//!
+//! Note that you need feature `v1` in order to use these features.
+//!
+//! [`Uuid`]: ../struct.Uuid.html
+
+use core::sync::atomic;
+use prelude::*;
+
+/// A thread-safe, stateful context for the v1 generator to help ensure
+/// process-wide uniqueness.
+#[derive(Debug)]
+pub struct Context {
+    count: atomic::AtomicUsize,
+}
+
+/// A trait that abstracts over generation of Uuid v1 "Clock Sequence" values.
+pub trait ClockSequence {
+    /// Return a 16-bit number that will be used as the "clock sequence" in
+    /// the Uuid. The number must be different if the time has changed since
+    /// the last time a clock sequence was requested.
+    fn generate_sequence(&self, seconds: u64, nano_seconds: u32) -> u16;
+}
+
+impl Uuid {
+    /// Create a new [`Uuid`] (version 1) using a time value + sequence +
+    /// *NodeId*.
+    ///
+    /// This expects two values representing a monotonically increasing value
+    /// as well as a unique 6 byte NodeId, and an implementation of
+    /// [`ClockSequence`]. This function is only guaranteed to produce
+    /// unique values if the following conditions hold:
+    ///
+    /// 1. The *NodeId* is unique for this process,
+    /// 2. The *Context* is shared across all threads which are generating v1
+    ///    [`Uuid`]s,
+    /// 3. The [`ClockSequence`] implementation reliably returns unique
+    ///    clock sequences (this crate provides [`Context`] for this
+    ///    purpose. However you can create your own [`ClockSequence`]
+    ///    implementation, if [`Context`] does not meet your needs).
+    ///
+    /// The NodeID must be exactly 6 bytes long. If the NodeID is not a valid
+    /// length this will return a [`ParseError`]`::InvalidLength`.
+    ///
+    /// The function is not guaranteed to produce monotonically increasing
+    /// values however.  There is a slight possibility that two successive
+    /// equal time values could be supplied and the sequence counter wraps back
+    /// over to 0.
+    ///
+    /// If uniqueness and monotonicity is required, the user is responsible for
+    /// ensuring that the time value always increases between calls (including
+    /// between restarts of the process and device).
+    ///
+    /// Note that usage of this method requires the `v1` feature of this crate
+    /// to be enabled.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```rust
+    /// use uuid::v1::Context;
+    /// use uuid::Uuid;
+    ///
+    /// let context = Context::new(42);
+    /// if let Ok(uuid) =
+    ///     Uuid::new_v1(&context, 1497624119, 1234, &[1, 2, 3, 4, 5, 6])
+    /// {
+    ///     assert_eq!(
+    ///         uuid.to_hyphenated().to_string(),
+    ///         "f3b4958c-52a1-11e7-802a-010203040506"
+    ///     )
+    /// } else {
+    ///     panic!()
+    /// }
+    /// ```
+    ///
+    /// [`ParseError`]: ../enum.ParseError.html
+    /// [`Uuid`]: ../struct.Uuid.html
+    /// [`ClockSequence`]: struct.ClockSequence.html
+    /// [`Context`]: struct.Context.html
+    pub fn new_v1<T>(
+        context: &T,
+        seconds: u64,
+        nano_seconds: u32,
+        node_id: &[u8],
+    ) -> Result<Self, ::BytesError>
+    where
+        T: ClockSequence,
+    {
+        const NODE_ID_LEN: usize = 6;
+
+        let len = node_id.len();
+        if len != NODE_ID_LEN {
+            return Err(::BytesError::new(NODE_ID_LEN, len));
+        }
+
+        let time_low;
+        let time_mid;
+        let time_high_and_version;
+
+        {
+            /// The number of 100 ns ticks between the UUID epoch
+            /// `1582-10-15 00:00:00` and the Unix epoch `1970-01-01 00:00:00`.
+            const UUID_TICKS_BETWEEN_EPOCHS: u64 = 0x01B2_1DD2_1381_4000;
+
+            let timestamp =
+                seconds * 10_000_000 + u64::from(nano_seconds / 100);
+            let uuid_time = timestamp + UUID_TICKS_BETWEEN_EPOCHS;
+
+            time_low = (uuid_time & 0xFFFF_FFFF) as u32;
+            time_mid = ((uuid_time >> 32) & 0xFFFF) as u16;
+            time_high_and_version =
+                (((uuid_time >> 48) & 0x0FFF) as u16) | (1 << 12);
+        }
+
+        let mut d4 = [0; 8];
+
+        {
+            let count = context.generate_sequence(seconds, nano_seconds);
+            d4[0] = (((count & 0x3F00) >> 8) as u8) | 0x80;
+            d4[1] = (count & 0xFF) as u8;
+        }
+
+        d4[2..].copy_from_slice(node_id);
+
+        Uuid::from_fields(time_low, time_mid, time_high_and_version, &d4)
+    }
+}
+
+impl Context {
+    /// Creates a thread-safe, internally mutable context to help ensure
+    /// uniqueness.
+    ///
+    /// This is a context which can be shared across threads. It maintains an
+    /// internal counter that is incremented at every request, the value ends
+    /// up in the clock_seq portion of the [`Uuid`] (the fourth group). This
+    /// will improve the probability that the [`Uuid`] is unique across the
+    /// process.
+    ///
+    /// [`Uuid`]: ../struct.Uuid.html
+    pub fn new(count: u16) -> Self {
+        Self {
+            count: atomic::AtomicUsize::new(count as usize),
+        }
+    }
+}
+
+impl ClockSequence for Context {
+    fn generate_sequence(&self, _: u64, _: u32) -> u16 {
+        (self.count.fetch_add(1, atomic::Ordering::SeqCst) & 0xffff) as u16
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_new_v1() {
+        use super::Context;
+        use prelude::*;
+
+        let time: u64 = 1_496_854_535;
+        let time_fraction: u32 = 812_946_000;
+        let node = [1, 2, 3, 4, 5, 6];
+        let context = Context::new(0);
+
+        {
+            let uuid =
+                Uuid::new_v1(&context, time, time_fraction, &node).unwrap();
+
+            assert_eq!(uuid.get_version(), Some(Version::Mac));
+            assert_eq!(uuid.get_variant(), Some(Variant::RFC4122));
+            assert_eq!(
+                uuid.to_hyphenated().to_string(),
+                "20616934-4ba2-11e7-8000-010203040506"
+            );
+
+            let ts = uuid.to_timestamp().unwrap();
+
+            assert_eq!(ts.0 - 0x01B2_1DD2_1381_4000, 14_968_545_358_129_460);
+            assert_eq!(ts.1, 0);
+        };
+
+        {
+            let uuid2 =
+                Uuid::new_v1(&context, time, time_fraction, &node).unwrap();
+
+            assert_eq!(
+                uuid2.to_hyphenated().to_string(),
+                "20616934-4ba2-11e7-8001-010203040506"
+            );
+            assert_eq!(uuid2.to_timestamp().unwrap().1, 1)
+        };
+    }
+}
diff --git a/rustc_deps/vendor/uuid/src/v3.rs b/rustc_deps/vendor/uuid/src/v3.rs
new file mode 100644
index 0000000..f2248d7
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/v3.rs
@@ -0,0 +1,140 @@
+use md5;
+use prelude::*;
+
+impl Uuid {
+    /// Creates a [`Uuid`] using a name from a namespace, based on the MD5
+    /// hash.
+    ///
+    /// A number of namespaces are available as constants in this crate:
+    ///
+    /// * [`NAMESPACE_DNS`]
+    /// * [`NAMESPACE_OID`]
+    /// * [`NAMESPACE_URL`]
+    /// * [`NAMESPACE_X500`]
+    ///
+    /// Note that usage of this method requires the `v3` feature of this crate
+    /// to be enabled.
+    ///
+    /// [`NAMESPACE_DNS`]: ../ns/const.NAMESPACE_DNS.html
+    /// [`NAMESPACE_OID`]: ../ns/const.NAMESPACE_OID.html
+    /// [`NAMESPACE_URL`]: ../ns/const.NAMESPACE_URL.html
+    /// [`NAMESPACE_X500`]: ../ns/const.NAMESPACE_X500.html
+    /// [`Uuid`]: ../struct.Uuid.html
+    pub fn new_v3(namespace: &Uuid, name: &[u8]) -> Uuid {
+        let mut context = md5::Context::new();
+
+        context.consume(namespace.as_bytes());
+        context.consume(name);
+
+        let mut uuid = Uuid::from_bytes(context.compute().into());
+
+        uuid.set_variant(Variant::RFC4122);
+        uuid.set_version(Version::Md5);
+        uuid
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use prelude::*;
+
+    static FIXTURE: &'static [(&'static Uuid, &'static str, &'static str)] = &[
+        (
+            &Uuid::NAMESPACE_DNS,
+            "example.org",
+            "04738bdf-b25a-3829-a801-b21a1d25095b",
+        ),
+        (
+            &Uuid::NAMESPACE_DNS,
+            "rust-lang.org",
+            "c6db027c-615c-3b4d-959e-1a917747ca5a",
+        ),
+        (
+            &Uuid::NAMESPACE_DNS,
+            "42",
+            "5aab6e0c-b7d3-379c-92e3-2bfbb5572511",
+        ),
+        (
+            &Uuid::NAMESPACE_DNS,
+            "lorem ipsum",
+            "4f8772e9-b59c-3cc9-91a9-5c823df27281",
+        ),
+        (
+            &Uuid::NAMESPACE_URL,
+            "example.org",
+            "39682ca1-9168-3da2-a1bb-f4dbcde99bf9",
+        ),
+        (
+            &Uuid::NAMESPACE_URL,
+            "rust-lang.org",
+            "7ed45aaf-e75b-3130-8e33-ee4d9253b19f",
+        ),
+        (
+            &Uuid::NAMESPACE_URL,
+            "42",
+            "08998a0c-fcf4-34a9-b444-f2bfc15731dc",
+        ),
+        (
+            &Uuid::NAMESPACE_URL,
+            "lorem ipsum",
+            "e55ad2e6-fb89-34e8-b012-c5dde3cd67f0",
+        ),
+        (
+            &Uuid::NAMESPACE_OID,
+            "example.org",
+            "f14eec63-2812-3110-ad06-1625e5a4a5b2",
+        ),
+        (
+            &Uuid::NAMESPACE_OID,
+            "rust-lang.org",
+            "6506a0ec-4d79-3e18-8c2b-f2b6b34f2b6d",
+        ),
+        (
+            &Uuid::NAMESPACE_OID,
+            "42",
+            "ce6925a5-2cd7-327b-ab1c-4b375ac044e4",
+        ),
+        (
+            &Uuid::NAMESPACE_OID,
+            "lorem ipsum",
+            "5dd8654f-76ba-3d47-bc2e-4d6d3a78cb09",
+        ),
+        (
+            &Uuid::NAMESPACE_X500,
+            "example.org",
+            "64606f3f-bd63-363e-b946-fca13611b6f7",
+        ),
+        (
+            &Uuid::NAMESPACE_X500,
+            "rust-lang.org",
+            "bcee7a9c-52f1-30c6-a3cc-8c72ba634990",
+        ),
+        (
+            &Uuid::NAMESPACE_X500,
+            "42",
+            "c1073fa2-d4a6-3104-b21d-7a6bdcf39a23",
+        ),
+        (
+            &Uuid::NAMESPACE_X500,
+            "lorem ipsum",
+            "02f09a3f-1624-3b1d-8409-44eff7708208",
+        ),
+    ];
+
+    #[test]
+    fn test_new() {
+        for &(ref ns, ref name, _) in FIXTURE {
+            let uuid = Uuid::new_v3(*ns, name.as_bytes());
+            assert_eq!(uuid.get_version().unwrap(), Version::Md5);
+            assert_eq!(uuid.get_variant().unwrap(), Variant::RFC4122);
+        }
+    }
+
+    #[test]
+    fn test_to_hyphenated_string() {
+        for &(ref ns, ref name, ref expected) in FIXTURE {
+            let uuid = Uuid::new_v3(*ns, name.as_bytes());
+            assert_eq!(uuid.to_hyphenated().to_string(), *expected);
+        }
+    }
+}
diff --git a/rustc_deps/vendor/uuid/src/v4.rs b/rustc_deps/vendor/uuid/src/v4.rs
new file mode 100644
index 0000000..2a84753
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/v4.rs
@@ -0,0 +1,57 @@
+use prelude::*;
+use rand;
+
+impl Uuid {
+    /// Creates a random [`Uuid`].
+    ///
+    /// This uses the [`rand`] crate's default task RNG as the source of random
+    /// numbers. If you'd like to use a custom generator, don't use this
+    /// method: use the `rand::Rand trait`'s `rand()` method instead.
+    ///
+    /// Note that usage of this method requires the `v4` feature of this crate
+    /// to be enabled.
+    ///
+    /// # Examples
+    ///
+    /// Basic usage:
+    ///
+    /// ```
+    /// use uuid::Uuid;
+    ///
+    /// let uuid = Uuid::new_v4();
+    /// ```
+    ///
+    /// [`rand`]: https://crates.io/crates/rand
+    /// [`Uuid`]: ../struct.Uuid.html
+    pub fn new_v4() -> Self {
+        use rand::RngCore;
+
+        let mut rng = rand::thread_rng();
+        let mut bytes = [0; 16];
+
+        rng.fill_bytes(&mut bytes);
+
+        Self::from_random_bytes(bytes)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use prelude::*;
+
+    #[test]
+    fn test_new() {
+        let uuid = Uuid::new_v4();
+
+        assert_eq!(uuid.get_version(), Some(Version::Random));
+        assert_eq!(uuid.get_variant(), Some(Variant::RFC4122));
+    }
+
+    #[test]
+    fn test_get_version() {
+        let uuid = Uuid::new_v4();
+
+        assert_eq!(uuid.get_version(), Some(Version::Random));
+        assert_eq!(uuid.get_version_num(), 4)
+    }
+}
diff --git a/rustc_deps/vendor/uuid/src/v5.rs b/rustc_deps/vendor/uuid/src/v5.rs
new file mode 100644
index 0000000..d2d878e
--- /dev/null
+++ b/rustc_deps/vendor/uuid/src/v5.rs
@@ -0,0 +1,153 @@
+use prelude::*;
+use sha1;
+
+impl Uuid {
+    /// Creates a UUID using a name from a namespace, based on the SHA-1 hash.
+    ///
+    /// A number of namespaces are available as constants in this crate:
+    ///
+    /// * [`NAMESPACE_DNS`]
+    /// * [`NAMESPACE_OID`]
+    /// * [`NAMESPACE_URL`]
+    /// * [`NAMESPACE_X500`]
+    ///
+    /// Note that usage of this method requires the `v5` feature of this crate
+    /// to be enabled.
+    ///
+    /// [`NAMESPACE_DNS`]: struct.Uuid.html#associatedconst.NAMESPACE_DNS
+    /// [`NAMESPACE_OID`]: struct.Uuid.html#associatedconst.NAMESPACE_OID
+    /// [`NAMESPACE_URL`]: struct.Uuid.html#associatedconst.NAMESPACE_URL
+    /// [`NAMESPACE_X500`]: struct.Uuid.html#associatedconst.NAMESPACE_X500
+    pub fn new_v5(namespace: &Uuid, name: &[u8]) -> Uuid {
+        let mut hash = sha1::Sha1::new();
+
+        hash.update(namespace.as_bytes());
+        hash.update(name);
+
+        let buffer = hash.digest().bytes();
+        let mut uuid = Uuid::default();
+
+        uuid.0.copy_from_slice(&buffer[..16]);
+        uuid.set_variant(Variant::RFC4122);
+        uuid.set_version(Version::Sha1);
+
+        uuid
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use prelude::*;
+
+    static FIXTURE: &'static [(&'static Uuid, &'static str, &'static str)] = &[
+        (
+            &Uuid::NAMESPACE_DNS,
+            "example.org",
+            "aad03681-8b63-5304-89e0-8ca8f49461b5",
+        ),
+        (
+            &Uuid::NAMESPACE_DNS,
+            "rust-lang.org",
+            "c66bbb60-d62e-5f17-a399-3a0bd237c503",
+        ),
+        (
+            &Uuid::NAMESPACE_DNS,
+            "42",
+            "7c411b5e-9d3f-50b5-9c28-62096e41c4ed",
+        ),
+        (
+            &Uuid::NAMESPACE_DNS,
+            "lorem ipsum",
+            "97886a05-8a68-5743-ad55-56ab2d61cf7b",
+        ),
+        (
+            &Uuid::NAMESPACE_URL,
+            "example.org",
+            "54a35416-963c-5dd6-a1e2-5ab7bb5bafc7",
+        ),
+        (
+            &Uuid::NAMESPACE_URL,
+            "rust-lang.org",
+            "c48d927f-4122-5413-968c-598b1780e749",
+        ),
+        (
+            &Uuid::NAMESPACE_URL,
+            "42",
+            "5c2b23de-4bad-58ee-a4b3-f22f3b9cfd7d",
+        ),
+        (
+            &Uuid::NAMESPACE_URL,
+            "lorem ipsum",
+            "15c67689-4b85-5253-86b4-49fbb138569f",
+        ),
+        (
+            &Uuid::NAMESPACE_OID,
+            "example.org",
+            "34784df9-b065-5094-92c7-00bb3da97a30",
+        ),
+        (
+            &Uuid::NAMESPACE_OID,
+            "rust-lang.org",
+            "8ef61ecb-977a-5844-ab0f-c25ef9b8d5d6",
+        ),
+        (
+            &Uuid::NAMESPACE_OID,
+            "42",
+            "ba293c61-ad33-57b9-9671-f3319f57d789",
+        ),
+        (
+            &Uuid::NAMESPACE_OID,
+            "lorem ipsum",
+            "6485290d-f79e-5380-9e64-cb4312c7b4a6",
+        ),
+        (
+            &Uuid::NAMESPACE_X500,
+            "example.org",
+            "e3635e86-f82b-5bbc-a54a-da97923e5c76",
+        ),
+        (
+            &Uuid::NAMESPACE_X500,
+            "rust-lang.org",
+            "26c9c3e9-49b7-56da-8b9f-a0fb916a71a3",
+        ),
+        (
+            &Uuid::NAMESPACE_X500,
+            "42",
+            "e4b88014-47c6-5fe0-a195-13710e5f6e27",
+        ),
+        (
+            &Uuid::NAMESPACE_X500,
+            "lorem ipsum",
+            "b11f79a5-1e6d-57ce-a4b5-ba8531ea03d0",
+        ),
+    ];
+
+    #[test]
+    fn test_get_version() {
+        let uuid =
+            Uuid::new_v5(&Uuid::NAMESPACE_DNS, "rust-lang.org".as_bytes());
+
+        assert_eq!(uuid.get_version(), Some(Version::Sha1));
+        assert_eq!(uuid.get_version_num(), 5);
+    }
+
+    #[test]
+    fn test_hyphenated() {
+        for &(ref ns, ref name, ref expected) in FIXTURE {
+            let uuid = Uuid::new_v5(*ns, name.as_bytes());
+
+            assert_eq!(uuid.to_hyphenated().to_string(), *expected)
+        }
+    }
+
+    #[test]
+    fn test_new() {
+        for &(ref ns, ref name, ref u) in FIXTURE {
+            let uuid = Uuid::new_v5(*ns, name.as_bytes());
+
+            assert_eq!(uuid.get_variant(), Some(Variant::RFC4122));
+            assert_eq!(uuid.get_version(), Some(Version::Sha1));
+            assert_eq!(Ok(uuid), u.parse());
+        }
+    }
+}
diff --git a/rustc_deps/vendor/valico/.cargo-checksum.json b/rustc_deps/vendor/valico/.cargo-checksum.json
new file mode 100644
index 0000000..edea2ca
--- /dev/null
+++ b/rustc_deps/vendor/valico/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CONTRIBUTING.md":"aa48af3a35ab5dc6965b4cb5135697602ff4bb5963aff21337a4b8773d0116c1","Cargo.toml":"12742fa0a756d070f9e543f0619e13a757c3fd987be5e92081f19bac1ad59726","LICENSE":"a2291d25c9665f3b8a4e803622947a50a0af558b2a843f3bb53f7699ccb1d99e","Makefile":"3a66ffb53cfdaa04a457924b9338f69516616e58951b7e613b9cac5be4040950","README.md":"4abea8dafc107fd0092868bc8da470cea0eef55dbfe5c5a0d573bea34ac3cb8c","benches/schema.rs":"3f4451794784ad2b5012bf7a33486b86515200174eb4d233727bf54492406d26","build.rs":"ddc4b037ed5cf50037b5a093352fbb7fc08707aaae9f30f019bca79ca1083b40","examples/example01.rs":"2a76f4861af0ea5b500b28b3a9395dfcc2b040ac53edf46c8b24102279886417","src/common/error.rs":"f7c831613afcd40386ba3e4cbec75e3144a5442ac7581739e9da6ec8e68d7f8d","src/common/mod.rs":"c8b688031e83ea467361fa1e5ae2ae5379f4b2a69b566fdd654fb55d79575e61","src/json_dsl/builder.rs":"9fd21a78afe45f9a0f015e57385968d80e09712d26b587bb5c6cbb2cdd8986c5","src/json_dsl/coercers.rs":"6594bb5c244ea46e52a29b897f39c7c115dd263666e5d7e6f064b1e17896329c","src/json_dsl/errors.rs":"a8cec9c7de6acafdd0a5c93cb438a07aaddc08076f50f464bcba1ee7c2821bb3","src/json_dsl/mod.rs":"38470331b209688053a35266cc305dc174d2ae17c0f7edf5b49d4e119e6b828f","src/json_dsl/param.rs":"023931ff18b869a09592ba9cfb6fecd7aa5e166e19f47b7d5401eca14284361b","src/json_dsl/validators/allowed_values.rs":"ce46b32c54391cf1d30e430d9f6cd13a87043ed1ca4096f18e45a15c26d57f2b","src/json_dsl/validators/at_least_one_of.rs":"ed7acf3c5b0fe164f5f0022b7818748e4caba1fdf1061d2b3f53827bc919bf7c","src/json_dsl/validators/exactly_one_of.rs":"3bf29e5f4d849a4dc835e4d52577df6d13a22a93d01624dd57f334c5cc55e599","src/json_dsl/validators/mod.rs":"706768e41f275352d02b4c4f516e67c2b8aa73a98865e80e6d3fd5cc4cbe32c5","src/json_dsl/validators/mutually_exclusive.rs":"a160bbbad3673466a077c134e5bc5a41aae9a56e20e588923c1e8a056d6f3531","src/json_dsl/validators/regex.rs":"03d179a3ff1bd5a380e5e0949ac770a0ad784a9e47b76323962b1d6509983e68","src/json_dsl/validators/rejected_values.rs":"030e938e93b99c1199024156a5238f45b9ec057786f72226d31491c0900bcbe2","src/json_schema/builder.rs":"ffd587acf980cc8b2c185cf850a492f3460a3b28f7f33bcba7c8b16f9052b3ed","src/json_schema/errors.rs":"8bbfaffce0f46f07dc3725b6987c6cbce759426c0e1072bdb796b5e9625d5e76","src/json_schema/helpers.rs":"0952e28ff5a325ba9f3d7a05e395ef90436dcc8c24e122306a38a9638a98758b","src/json_schema/keywords/dependencies.rs":"ee920d060064c4270f6930276f7a972e66756441d193a010adc9eaa9cee0c41b","src/json_schema/keywords/enum_.rs":"e5c19f06e5b36a71140e832d0e932cf86be61795ffe77533394a41c675baea6a","src/json_schema/keywords/format.rs":"95201732ef32467d911f40267d579fabc0455d222a66617fa0f8a1f163776054","src/json_schema/keywords/items.rs":"f8c36dba5be386119ff2a91ba0fb58e2aee9db7e8f99854493b17ed5de48ac6c","src/json_schema/keywords/maxmin.rs":"6737e3246e985d42cfbbcb8fe2631a44051e35b8d950f40c971676af2345f53a","src/json_schema/keywords/maxmin_items.rs":"15f3a223ea6bcd0d545af2c036a8fbbf630cad4e8bf7c567adff66659dbad497","src/json_schema/keywords/maxmin_length.rs":"7b77318f3728e4f019e591c3d28b5306e0311e4f4a229409c8f8d4d76351f3fe","src/json_schema/keywords/maxmin_properties.rs":"f4daa5a1d4aba62dd5e503340ca54f817bacd9ae2b6bc5026efe685994e52cb3","src/json_schema/keywords/mod.rs":"c8c76fa9ef9a033f70edd3ca7c13331928bea0db8aa9fc286af667544a3a11dd","src/json_schema/keywords/multiple_of.rs":"011f79a46388c4623c090e2921bbbc26b9795ad4ae74c5b26fdd6e9c4e6da036","src/json_schema/keywords/not.rs":"4ff07a0fe1fe030e8cd475d795e83bd0b2f3482b4842eda64424b0114ebb33f2","src/json_schema/keywords/of.rs":"0fceae8f607eb509b62be73cb1db0599effa2dff86a9eb29a43507b13a75c9d7","src/json_schema/keywords/pattern.rs":"b469c06d11d607c816409b02ff1c0250c9a109d08f8df65b35affb070392a6eb","src/json_schema/keywords/properties.rs":"5e0b49b5f226f731b1f00b2e0f3364ed71ca4c558a2ef42a9645dfc0b12bf501","src/json_schema/keywords/ref_.rs":"d3e7120905569f738303ae39d43ff644be7db88f67ece9a3348313bea44ab612","src/json_schema/keywords/required.rs":"d2d90902e8c71cfe0ade77c9b870382e4232481995ead5804c8033dfe3535587","src/json_schema/keywords/type_.rs":"7cc60ecd574a8609e5277a0e262803c2a7e39f6834f9695e67cca9fe9f9fac69","src/json_schema/keywords/unique_items.rs":"dffa0c51fcb5e9851c767bbaf4f8a1218c28e0e034363d8ff3f39b38d4e86b1e","src/json_schema/mod.rs":"4ac611711b77295dacdc9ed5cb1220cb88cb46686023d1a5cadaf891b7bbfb81","src/json_schema/schema.rs":"10611390509369f97f1a7bed1ce05de543467b22a03796838a3b650f365ab6c9","src/json_schema/scope.rs":"d90da255225e5a4959315d7182fdaa082c80694712c99f98248953546fd6563f","src/json_schema/validators/dependencies.rs":"992d19479cf9fbf1e94a5c5fbbd5bff43b89df28ae7c1a198346bc1b0addcc86","src/json_schema/validators/enum_.rs":"9ee8ebffc01a7d99e84a252ad3db6aef64ccda6737ac6572c52d5b32c8325d01","src/json_schema/validators/formats.rs":"0530b6010815dd66aeb212118d93f84b8b4939d54d08806fbdf5b92c4e26931b","src/json_schema/validators/items.rs":"caf2567b7fb9782a995d0dd1ca87588caa8e90cd7a05cfe79177db25023e0048","src/json_schema/validators/maxmin.rs":"d0a8b33a6ce9eb6d63f26f72df00931b369ac3516df12ed84ed6aeb9c27dfb18","src/json_schema/validators/maxmin_items.rs":"5e194b60020660c878d496b1e59455aef5532051aa1091b449765e9e6df349aa","src/json_schema/validators/maxmin_length.rs":"f64ecc573754f29106311e8794edea7ac33e3a6607ab9f2c760e8f64e389b133","src/json_schema/validators/maxmin_properties.rs":"31a0fcefb83d042e4ac92888e7c48008d177b23e2e6d0ec640f60fed5bad383b","src/json_schema/validators/mod.rs":"3470649ac4e7ade6e50477b1021a641bd32e29a4128ab5c23552195686efd2c3","src/json_schema/validators/multiple_of.rs":"5729a45ffba5b5bc18e5f740f79d301ae9cdcaef62f0aa555ff27aa3ec9f36cc","src/json_schema/validators/not.rs":"81250c7c14e596ca33de134826fb749632f3248471711d87769e715b0fc8337b","src/json_schema/validators/of.rs":"e97d46364c67d9a90597b368e46acb625f9e8ea9efd4ad0ad8a0fde2077715cb","src/json_schema/validators/pattern.rs":"8a6057626a619aee2473ef003c57cbb066c5c0a7be6c294c7e57bf15ec668918","src/json_schema/validators/properties.rs":"ca1686e65e8c9417eb34bf4cfedb90f1d3422548d52c781ab205d872915b3b78","src/json_schema/validators/ref_.rs":"2a85c334d3757c7a2ce7b91cee34f8b3191951d0c3bb140494e912a8e947f1c6","src/json_schema/validators/required.rs":"8ae71bd7bf64500dabafc5520dac0a96c72a9ba5694eb58219d210c9a95e5584","src/json_schema/validators/type_.rs":"8e07c39b18da5a6850836f20f163f9f04d6b6d521d016445f6bffc894ca15571","src/json_schema/validators/unique_items.rs":"5263b64dbc0615160d8c7971984ffd427c8cf5dde25b25fd6c20bfece013cdbd","src/lib.rs":"a8cea3db49846e2f787ed58507530673c0ecc48dce2c650f802e15790ceb2d06","tests/dsl/helpers.rs":"b84d9a746355a988b9e644122244d9f6fcc713df996d43162fe04f1706586d4e","tests/dsl/mod.rs":"b878317f70d216d3c957162aa1e80cbd8baed5061b569015b840565eb996f27c","tests/schema/JSON-Schema-Test-Suite/LICENSE":"837402bd25fad9b704265801ca3f92566a98157c1f9a7acd6f446299ba1c305a","tests/schema/JSON-Schema-Test-Suite/README.md":"d505f665195035782b9531af7a0c6416ff9a5314419fd6ef9d04330dcb3b0285","tests/schema/JSON-Schema-Test-Suite/bin/jsonschema_suite":"8c824bd25820ccf8bd48593ec13d5a14603e91a9ac921c4c341deef298dc062a","tests/schema/JSON-Schema-Test-Suite/remotes/folder/folderInteger.json":"5409ac74ef1225a78c51025c707b7c3b68439e64bfb760dcfca6b2b8d0fd8038","tests/schema/JSON-Schema-Test-Suite/remotes/integer.json":"5409ac74ef1225a78c51025c707b7c3b68439e64bfb760dcfca6b2b8d0fd8038","tests/schema/JSON-Schema-Test-Suite/remotes/subSchemas.json":"86cd4e6a45679ebca0f679c1fb2b8dff89e7c1e073c3c9176ea0563efef2f83e","tests/schema/JSON-Schema-Test-Suite/tests/draft3/additionalItems.json":"346c57f3f8d2ad182b63fe02ed7483c76a703c83aaac27d03c37db2310276eaf","tests/schema/JSON-Schema-Test-Suite/tests/draft3/additionalProperties.json":"1e7999eadbdc57ae664394e071aa941fabb2b049a5c150bdefad858ea43fac50","tests/schema/JSON-Schema-Test-Suite/tests/draft3/default.json":"37e0350cc4d4d6c5f0de3ca829cff1e4ae4d4e2716ddf3b8cb807a80f8e19876","tests/schema/JSON-Schema-Test-Suite/tests/draft3/dependencies.json":"a46ce7b9c905ae8c009fa8897c46b8f71dc76fd217112746b3c182794811d979","tests/schema/JSON-Schema-Test-Suite/tests/draft3/disallow.json":"a326f0120ce2674d86280300f09ad5c6c295477f970588796c1df93745f8ab93","tests/schema/JSON-Schema-Test-Suite/tests/draft3/divisibleBy.json":"81f0190157ca5fc6fa4b09316d76bda09564aa81a44ac9a4549ca22a37103ae3","tests/schema/JSON-Schema-Test-Suite/tests/draft3/enum.json":"3daa4059d0625ad287b340ce48ed355dae3d60149de662fa0c8c200543cc5962","tests/schema/JSON-Schema-Test-Suite/tests/draft3/extends.json":"257d41d133294b4d8620b58061d4ea6d9fbcaee0dfddc09e46fb0311a88f0e7b","tests/schema/JSON-Schema-Test-Suite/tests/draft3/items.json":"d698b51a3d3707701d610836453e1fd0c65dd249240ec1d9874ad725556cf5fe","tests/schema/JSON-Schema-Test-Suite/tests/draft3/maxItems.json":"4adca55d27b10c1eefc7891c05f31d9dfc8f11beee2328f6370c63fec3ee13b9","tests/schema/JSON-Schema-Test-Suite/tests/draft3/maxLength.json":"08511ada9dccc03e942880b7d87e59adce1a5e613159dea7e44a0f2577ebd74a","tests/schema/JSON-Schema-Test-Suite/tests/draft3/maximum.json":"f2cf731dabcdacd9c2f3bb0af9e67aa47b75c63f03d22939e0d400f92405e488","tests/schema/JSON-Schema-Test-Suite/tests/draft3/minItems.json":"f20fbbfebbb3311a12027ed2064cb4334f09b6d06642e3de0dd0a69bc4ff7ce5","tests/schema/JSON-Schema-Test-Suite/tests/draft3/minLength.json":"ec7bec136ed05519b69b2e441a2e6abe9bd4e6f29f39fa0380f9395254fc050d","tests/schema/JSON-Schema-Test-Suite/tests/draft3/minimum.json":"52e98407446b4b8f5dc2a3f50c942b3f3c42354835702c8c80ff60478252a723","tests/schema/JSON-Schema-Test-Suite/tests/draft3/optional/bignum.json":"4bbe93617efeedc563ea45739cbd3a76821e60d572ed8c8d59fbf3467920e2b8","tests/schema/JSON-Schema-Test-Suite/tests/draft3/optional/format.json":"d327147a9c57b6051de7dc9824d745a0d4d5578ff0e358f5aa1969dd3a250375","tests/schema/JSON-Schema-Test-Suite/tests/draft3/optional/jsregex.json":"09d3bac97c9998f6f0a0756a59b33881a1e36cdfca6b839acf3db220903daa99","tests/schema/JSON-Schema-Test-Suite/tests/draft3/optional/zeroTerminatedFloats.json":"0da6f9c562259d9596901c301f02b28dfa2c9ffa4b4b88a072f8a1549bbf6b3d","tests/schema/JSON-Schema-Test-Suite/tests/draft3/pattern.json":"bf2211cf8fd220bf6b42f9545507ced63830de067f37f74477faf2dd97dcf144","tests/schema/JSON-Schema-Test-Suite/tests/draft3/patternProperties.json":"118dca75012c96300c1ce2ad0cda7cb59e897ada1abdbb867aaaac08ad86cd07","tests/schema/JSON-Schema-Test-Suite/tests/draft3/properties.json":"10df6e99c89fefd96e8a2b3b25dee4adc0964b1def2175fa513c775ed8d41a64","tests/schema/JSON-Schema-Test-Suite/tests/draft3/ref.json":"8f3fe8cdd647f8f4a5ba9e030020b390a73fef49465c9acd80cadd5d43aa886b","tests/schema/JSON-Schema-Test-Suite/tests/draft3/refRemote.json":"6b68176b94b3532cdfe51a51507e5b640ceb87398bf429bd1945b1a55f72b538","tests/schema/JSON-Schema-Test-Suite/tests/draft3/required.json":"9b874a91f6fa946f6565338e4915ed76d9fed5b1d3aa45c5eed42950d6d6032c","tests/schema/JSON-Schema-Test-Suite/tests/draft3/type.json":"263b1a7d73fa1945a85590f75f47041d33f1f1391da3b96a00e3f662a3826a3f","tests/schema/JSON-Schema-Test-Suite/tests/draft3/uniqueItems.json":"dc6f68c737784fe041fc51ddf3dcec414acce426994680ddcb7931b62b0c0654","tests/schema/JSON-Schema-Test-Suite/tests/draft4/additionalItems.json":"cc023933a34d18f374934ae699cc9726733744a8de3fb96be02e85223f81366a","tests/schema/JSON-Schema-Test-Suite/tests/draft4/additionalProperties.json":"1e7999eadbdc57ae664394e071aa941fabb2b049a5c150bdefad858ea43fac50","tests/schema/JSON-Schema-Test-Suite/tests/draft4/allOf.json":"3bc02ea1b18622036bbd94e7202057e0eb237821796c96511714b3ecbcf8e1b4","tests/schema/JSON-Schema-Test-Suite/tests/draft4/anyOf.json":"d0d124e0e14a427b8865d22e197fbba47329ecc6c0f105518a93ea86980919a3","tests/schema/JSON-Schema-Test-Suite/tests/draft4/default.json":"37e0350cc4d4d6c5f0de3ca829cff1e4ae4d4e2716ddf3b8cb807a80f8e19876","tests/schema/JSON-Schema-Test-Suite/tests/draft4/definitions.json":"a912c8584563f08434719989d6a7148badee33d90f49b172317860fe309c13c2","tests/schema/JSON-Schema-Test-Suite/tests/draft4/dependencies.json":"55df208626c9e90e989cfbce92dbff23b2fd863651978fdb02613bef8a1db492","tests/schema/JSON-Schema-Test-Suite/tests/draft4/enum.json":"245bc40854457d5e278c7a85dc7dc3f1f7f6a3814c1ac36730595aa78ad739c8","tests/schema/JSON-Schema-Test-Suite/tests/draft4/items.json":"d698b51a3d3707701d610836453e1fd0c65dd249240ec1d9874ad725556cf5fe","tests/schema/JSON-Schema-Test-Suite/tests/draft4/maxItems.json":"4adca55d27b10c1eefc7891c05f31d9dfc8f11beee2328f6370c63fec3ee13b9","tests/schema/JSON-Schema-Test-Suite/tests/draft4/maxLength.json":"6b59c08a3c6bec799cd4917915d046407f4aaa2c8debc0b14eae7fa20511736d","tests/schema/JSON-Schema-Test-Suite/tests/draft4/maxProperties.json":"31b1716cce0ae84e5ac85fe08e0d7260c8d1e81a5fc6e93bc92a2a65321a1127","tests/schema/JSON-Schema-Test-Suite/tests/draft4/maximum.json":"f2cf731dabcdacd9c2f3bb0af9e67aa47b75c63f03d22939e0d400f92405e488","tests/schema/JSON-Schema-Test-Suite/tests/draft4/minItems.json":"f20fbbfebbb3311a12027ed2064cb4334f09b6d06642e3de0dd0a69bc4ff7ce5","tests/schema/JSON-Schema-Test-Suite/tests/draft4/minLength.json":"ec7bec136ed05519b69b2e441a2e6abe9bd4e6f29f39fa0380f9395254fc050d","tests/schema/JSON-Schema-Test-Suite/tests/draft4/minProperties.json":"d4e395ea0c698d0d2c663821fd4128e4516021e88eb1e27a7bf8fc556ca7ca26","tests/schema/JSON-Schema-Test-Suite/tests/draft4/minimum.json":"52e98407446b4b8f5dc2a3f50c942b3f3c42354835702c8c80ff60478252a723","tests/schema/JSON-Schema-Test-Suite/tests/draft4/multipleOf.json":"a850e2a1729f2cf099d42c912860ecd21906718135199e473331a6db565d5192","tests/schema/JSON-Schema-Test-Suite/tests/draft4/not.json":"73fdbd077087b54977bc73c05a47fad62f47e7b825caff5b29b21114f0ea919b","tests/schema/JSON-Schema-Test-Suite/tests/draft4/oneOf.json":"b59cfcf89c32b3ae136f189ae9b4caecf9928775378935c45b8afd1d2f66e761","tests/schema/JSON-Schema-Test-Suite/tests/draft4/optional/bignum.json":"4bbe93617efeedc563ea45739cbd3a76821e60d572ed8c8d59fbf3467920e2b8","tests/schema/JSON-Schema-Test-Suite/tests/draft4/optional/format.json":"e2cec2bc6f02f1e79bfe1e0f3547869cc05f2f70196e776662bf0d4bc195daa6","tests/schema/JSON-Schema-Test-Suite/tests/draft4/optional/zeroTerminatedFloats.json":"0da6f9c562259d9596901c301f02b28dfa2c9ffa4b4b88a072f8a1549bbf6b3d","tests/schema/JSON-Schema-Test-Suite/tests/draft4/pattern.json":"bf2211cf8fd220bf6b42f9545507ced63830de067f37f74477faf2dd97dcf144","tests/schema/JSON-Schema-Test-Suite/tests/draft4/patternProperties.json":"118dca75012c96300c1ce2ad0cda7cb59e897ada1abdbb867aaaac08ad86cd07","tests/schema/JSON-Schema-Test-Suite/tests/draft4/properties.json":"10df6e99c89fefd96e8a2b3b25dee4adc0964b1def2175fa513c775ed8d41a64","tests/schema/JSON-Schema-Test-Suite/tests/draft4/ref.json":"095c83715a5c450baa30e186656dad65fbbfbd4353cdc1b17a8d08abe31f797d","tests/schema/JSON-Schema-Test-Suite/tests/draft4/refRemote.json":"6b68176b94b3532cdfe51a51507e5b640ceb87398bf429bd1945b1a55f72b538","tests/schema/JSON-Schema-Test-Suite/tests/draft4/required.json":"59d20612c28c570457f8f7248d6b2aa2aeba08f150483608e505634a48e9dec7","tests/schema/JSON-Schema-Test-Suite/tests/draft4/type.json":"bff6b02ad3409a50ecb83c5f7c474c92a4ce31ab7dfbe6e544cb2094dc694807","tests/schema/JSON-Schema-Test-Suite/tests/draft4/uniqueItems.json":"dc6f68c737784fe041fc51ddf3dcec414acce426994680ddcb7931b62b0c0654","tests/schema/JSON-Schema-Test-Suite/tox.ini":"936f56fd2809ca1c65c3c75eee39150073b57052f988a3b4a9d3a1c73976f043","tests/schema/mod.rs":"5ecfc1d9c002949b049c17937bdbeb6e808ab67daaf6d6c80f8476872c11f440","tests/schema/schema.json":"7353ff13faa979027813b95c8b35f992057822696a70c43c79b3bfb7249e76b4","tests/tests.rs":"f96f7205397b3346c92705403d4c694792a6766fcce41940890cec959ec83400"},"package":"a236e2b29a1d4d3ad6b5c8c69fc2bfbef0fc14a3397d037fbcb10be9f91db258"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/CONTRIBUTING.md b/rustc_deps/vendor/valico/CONTRIBUTING.md
new file mode 100644
index 0000000..ae5e451
--- /dev/null
+++ b/rustc_deps/vendor/valico/CONTRIBUTING.md
@@ -0,0 +1,81 @@
+# Contributing to Valico
+
+You want to contribute? You're awesome! When submitting a Pull Request, please have your commits follow these guidelines:
+
+## Getting source
+
+When cloning, ensure to clone recursively to get the submodules.
+
+    git clone --recurse-submodules git@github.com:rustless/valico.git
+
+If you've already cloned normally, use this to get the submodules:
+
+    git submodule update --init --recursive
+
+## Git Commit Guidelines
+
+These guidelines have been copied from the [AngularJS](https://github.com/angular/angular.js/blob/master/CONTRIBUTING.md#-git-commit-guidelines)
+project.
+
+We have very precise rules over how our git commit messages can be formatted.  This leads to **more
+readable messages** that are easy to follow when looking through the **project history**.  But also,
+we use the git commit messages to **generate the change log**.
+
+### Commit Message Format
+Each commit message consists of a **header**, a **body** and a **footer**.  The header has a special
+format that includes a **type**, a **scope** and a **subject**:
+
+``
+<type>(<scope>): <subject>
+<BLANK LINE>
+<body>
+<BLANK LINE>
+<footer>
+``
+
+Any line of the commit message cannot be longer 100 characters! This allows the message to be easier
+to read on github as well as in various git tools.
+
+### Type
+Must be one of the following:
+
+* **feat**: A new feature
+* **fix**: A bug fix
+* **docs**: Documentation only changes
+* **style**: Changes that do not affect the meaning of the code (white-space, formatting, missing
+  semi-colons, etc)
+* **refactor**: A code change that neither fixes a bug or adds a feature
+* **perf**: A code change that improves performance
+* **test**: Adding missing tests
+* **chore**: Changes to the build process or auxiliary tools and libraries such as documentation
+    generation
+
+### Scope
+The scope should refer to a module in rustless that is being touched. Examples:
+
+* json_dsl
+* json_schema
+* common
+* lib
+
+### Subject
+The subject contains succinct description of the change:
+
+* use the imperative, present tense: "change" not "changed" nor "changes"
+* don't capitalize first letter
+* no dot (.) at the end
+
+###Body
+Just as in the **subject**, use the imperative, present tense: "change" not "changed" nor "changes"
+The body should include the motivation for the change and contrast this with previous behavior.
+
+###Footer
+The footer should contain any information about **Breaking Changes** and is also the place to
+reference GitHub issues that this commit **Closes**.
+
+The last line of commits introducing breaking changes should be in the form `BREAKING_CHANGE: <desc>`
+
+
+A detailed explanation can be found in this [document][commit-message-format].
+
+[commit-message-format]: https://docs.google.com/document/d/1QrDFcIiPjSLDn3EL15IJygNPiHORgU1_OOAqWjiDU5Y/edit#
diff --git a/rustc_deps/vendor/valico/Cargo.toml b/rustc_deps/vendor/valico/Cargo.toml
new file mode 100644
index 0000000..4035010
--- /dev/null
+++ b/rustc_deps/vendor/valico/Cargo.toml
@@ -0,0 +1,51 @@
+# 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 = "valico"
+version = "2.3.1"
+authors = ["Stanislav Panferov <fnight.m@gmail.com>"]
+build = "build.rs"
+description = "JSON Schema validator and JSON coercer"
+homepage = "https://github.com/rustless/valico"
+documentation = "http://rustless.org/valico/doc/valico/"
+keywords = ["json", "validator", "json-schema"]
+license = "MIT"
+
+[[test]]
+name = "tests"
+[dependencies.jsonway]
+version = "2.0"
+
+[dependencies.lazy_static]
+version = "0.2"
+
+[dependencies.phf]
+version = "0.7"
+
+[dependencies.regex]
+version = "1.0"
+
+[dependencies.serde]
+version = "1.0"
+
+[dependencies.serde_json]
+version = "1.0"
+
+[dependencies.url]
+version = "1"
+
+[dependencies.uuid]
+version = "0.7"
+features = ["v4"]
+[build-dependencies.phf_codegen]
+version = "0.7"
diff --git a/rustc_deps/vendor/valico/LICENSE b/rustc_deps/vendor/valico/LICENSE
new file mode 100644
index 0000000..f0f4394
--- /dev/null
+++ b/rustc_deps/vendor/valico/LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Stanislav Panferov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/Makefile b/rustc_deps/vendor/valico/Makefile
new file mode 100644
index 0000000..d22b108
--- /dev/null
+++ b/rustc_deps/vendor/valico/Makefile
@@ -0,0 +1,10 @@
+doc:
+	git checkout gh-pages
+	git reset --hard master
+	cargo doc
+	cp -r target/doc doc
+	git add --all
+	msg="doc(*): rebuilding docs `date`"
+	git commit -m "$msg"
+	git push -f origin gh-pages
+	git checkout master
diff --git a/rustc_deps/vendor/valico/README.md b/rustc_deps/vendor/valico/README.md
new file mode 100644
index 0000000..ccf6560
--- /dev/null
+++ b/rustc_deps/vendor/valico/README.md
@@ -0,0 +1,453 @@
+## What is Valico?
+
+[![Build Status](https://travis-ci.org/rustless/valico.svg?branch=master)](https://travis-ci.org/rustless/valico)
+
+Valico is a validation and coercion tool for JSON objects, written in Rust. It designed to be a support library for the various REST-like frameworks or other tools that need to validate and coerce JSON input from outside world.
+
+Valico has two features:
+
+* **DSL** — a set of simple validators and coercers inspired by [Grape]. It has built-in support for common coercers, validators and can return detailed error messages if something goes wrong.
+* **JSON Schema** — An implementation of JSON Schema, based on IETF's draft v4.
+
+References:
+
+* http://json-schema.org
+* http://json-schema.org/latest/json-schema-core.html
+* http://json-schema.org/latest/json-schema-validation.html
+
+```toml
+# Cargo.toml
+valico = "2"
+```
+
+[API docs](http://rustless.org/valico/doc/valico/)
+
+See also:
+
+* [Rustless] - REST-like API micro-framework for Rust that use Valico.
+* [queryst] - Rust query string parser with nesting support can be used together with Valico to provide simple and safe toolchain for parsing query strings.
+* [jsonway] — JSON building DSL and configurable serializers for Rust
+
+[Rustless]: https://github.com/rustless/rustless
+[queryst]: https://github.com/rustless/queryst
+[Grape]: https://github.com/intridea/grape
+[jsonway]: https://github.com/rustless/jsonway
+
+## JSON Schema
+
+It passes the entire [JSON-Schema-Test-Suite](https://github.com/json-schema/JSON-Schema-Test-Suite/tree/develop/tests/draft4) except for remoteRefs and maxLength/minLength when using unicode surrogate pairs. It also can validate your schema and give you an explanation about what is wrong in it.
+
+### Example
+
+~~~rust
+extern crate serde_json;
+extern crate valico;
+
+use serde_json::Value;
+use valico::json_schema;
+use std::fs::File;
+
+fn main() {
+    let json_v4_schema: Value = serde_json::from_reader(File::open("tests/schema/schema.json").unwrap()).unwrap();
+
+    let mut scope = json_schema::Scope::new();
+    let schema = scope.compile_and_return(json_v4_schema.clone(), false).unwrap();
+
+    println!("Is valid: {}", schema.validate(&json_v4_schema).is_valid());
+}
+~~~
+
+### JSON Schema builder
+
+Valico goes with `valico::json_schema::schema(|scheme| { /* .. */ }) -> json::Json` function that allows to use simple DSL to generate your schemes. It allows you not to use strings and raw JSON manipulation. It also prevent some kinds of spelling and type errors.
+
+~~~rust
+builder::schema(|s| {
+    s.properties(|properties| {
+        properties.insert("prop1", |prop1| {
+            prop1.maximum(10f64, false);
+        });
+    });
+    s.pattern_properties(|properties| {
+        properties.insert("prop.*", |prop| {
+            prop.maximum(1000f64, false);
+        });
+    });
+    s.additional_properties_schema(|additional| {
+        additional.maximum(5f64, false)
+    });
+})
+~~~
+
+TODO more docs about JSON Schema here
+
+## DSL
+
+### Basic Usage
+
+All Valico stuff is making by Builder instance. Below is a simple example showing how one can create and setup Builder:
+
+~~~rust
+let params = Builder::build(|params| {
+	params.req_nested("user", Builder::list(), |params| {
+		params.req_typed("name", json_dsl::string());
+		params.req_typed("friend_ids", json_dsl::array_of(json_dsl::u64()))
+	});
+});
+~~~
+
+Later `params` instance can be used to process one or more JSON objects with it's `process` method with signature `fn process(&self, tree: &mut JsonObject) -> ValicoResult<()>`.
+
+**Note** that Valico will **mutate** borrowed JSON value if some coercion is needed.
+
+Example:
+
+~~~rust
+
+extern crate valico;
+extern crate serialize;
+
+use serialize::json;
+use serialize::json::{ToJson};
+use valico::{Builder, MutableJson};
+
+fn main() {
+
+    let params = Builder::build(|params| {
+        params.req_nested("user", Builder::list(), |params| {
+            params.req_typed("name", json_dsl::string());
+            params.req_typed("friend_ids", json_dsl::array_of(json_dsl::u64()))
+        });
+    });
+
+    let mut obj = json::from_str(
+        r#"{"user": {"name": "Frodo", "friend_ids": ["1223"]}}"#
+    ).unwrap();
+
+    match params.process(obj.as_object_mut().unwrap()) {
+        Ok(()) => {
+            println!("Result object is {}", obj.to_pretty_str());
+        },
+        Err(err) => {
+            panic!("Error during process: {}", err.to_json().to_pretty_str());
+        }
+    }
+
+}
+~~~
+
+Also you can look to the [specs] for more details and examples.
+
+[specs]: https://github.com/s-panferov/valico/blob/master/tests/builder.rs
+
+### Validation and coercion
+
+You can define validations and coercion options for your parameters using a `Builder::build` block. Parameters can be **optional** and **required**. Requires parameters must be always present. Optional parameters can be omitted.
+
+When parameter is present in JSON all validation and coercions will be applied and error fired if something goes wrong.
+
+#### Builder
+
+This functions are available in Builder to define parameters:
+
+~~~rust
+
+// Parameter is required, no coercion
+fn req_defined(&mut self, name: &str);
+
+// Parameter is required, with coercion
+fn req_typed(&mut self, name: &str, coercer: Box<Coercer>);
+
+// Parameter is required, with coercion and nested checks
+fn req_nested(&mut self, name: &str, coercer: Box<Coercer>, nest_def: |&mut Builder|);
+
+// Parameter is required, setup with Param DSL
+fn req(&mut self, name: &str, param_builder: |&mut Param|);
+
+// Parameter is optional, no coercion
+fn opt_defined(&mut self, name: &str);
+
+// Parameter is optional, with coercion
+fn opt_typed(&mut self, name: &str, coercer: Box<Coercer>);
+
+// Parameter is optional, with coercion and nested checks
+fn opt_nested(&mut self, name: &str, coercer: Box<Coercer>, nest_def: |&mut Builder|);
+
+// Parameter is required, setup with Param DSL
+fn opt(&mut self, name: &str, param_builder: |&mut Param|);
+
+~~~
+
+#### Built-in Coercers
+
+Available list of coercers:
+
+* json_dsl::i64()
+* json_dsl::u64()
+* json_dsl::f64()
+* json_dsl::string()
+* json_dsl::boolean()
+* json_dsl::null()
+* json_dsl::array()
+* json_dsl::array_of()
+* json_dsl::encoded_array() — use it for string-encoded arrays e.g. "red,green,blue" -> ["red", "green", "blue"]
+* json_dsl::encoded_array_of() — use it for string-encoded arrays of some type e.g. "1,2,3" -> [1, 2, 3]
+* json_dsl::object()
+
+Example of usage:
+
+~~~rust
+let params = Builder::build(|params| {
+    params.req_typed("id", json_dsl::u64());
+    params.req_typed("name", json_dsl::string());
+    params.opt_typed("is_active", json_dsl::boolean());
+    params.opt_typed("tags", json_dsl::array_of(json_dsl::strings()));
+});
+~~~
+
+#### Nested processing
+
+You can specify rules to nesting processing for **lists** and **objects**:
+
+~~~rust
+let params = Builder::build(|params| {
+    params.req_nested("user", json_dsl::object(), |params| {
+        params.req_typed("name", json_dsl::string());
+        params.opt_typed("is_active", json_dsl::boolean());
+        params.opt_typed("tags", json_dsl::array_of(json_dsl::strings()));
+    });
+});
+
+let params = Builder::build(|params| {
+    params.req_nested("users", Builder::list(), |params| {
+        params.req_typed("name", json_dsl::string());
+        params.opt_typed("is_active", json_dsl::boolean());
+        params.opt_typed("tags", json_dsl::array_of(json_dsl::strings()));
+    });
+});
+~~~
+
+Nesting level is not limited in Valico.
+
+#### Validate with JSON Schema
+
+DSL allows to use JSON Schema validations to validate objects at the Builder level and the Param level:
+
+~~~rust
+let params = json_dsl::Builder::build(|params| {
+    params.req("a", |a| {
+        a.schema(|schema| {
+            schema.integer();
+            schema.maximum(10f64, false);
+        })
+    });
+});
+~~~
+
+Note that JSON Schema validates object AFTER coerce pass:
+
+~~~rust
+let mut params = json_dsl::Builder::build(|params| {
+    params.req("a", |a| {
+        a.coerce(json_dsl::u64());
+        a.schema(|schema| {
+            schema.maximum(10f64, false);
+        })
+    });
+});
+~~~
+
+Don't forget to create a `json_schema::Scope` BEFORE processing:
+
+~~~rust
+let mut scope = json_schema::Scope::new();
+params.build_schemes(&mut scope).unwrap();
+~~~
+
+#### Parameters DSL
+
+You can use DSL block to setup parameters with more flexible way:
+
+~~~rust
+let params = Builder::build(|params| {
+    params.req("user", |user| {
+        user.desc("Parameter is used to create new user");
+        user.coerce(json_dsl::object());
+
+        // this allows null to be a valid value
+        user.allow_null();
+
+        user.nest(|params| {
+            params.req_typed("name", json_dsl::string());
+            params.opt("kind", |kind| {
+                kind.coerce(json_dsl::string());
+
+                // optional parameters can have default values
+                kind.default("simeple_user".to_string())
+            });
+        });
+    });
+});
+~~~
+
+#### Parameter validations
+
+DSL supports several parameter validations. They considered outdated and likely to be **removed** in the future in favour of JSON Schema validation.
+
+##### allow_values
+
+Parameters can be restricted to a specific set of values with **allow_values**:
+
+~~~rust
+let params = Builder::build(|params| {
+    params.req("kind", |kind| {
+        kind.coerce(json_dsl::string());
+        kind.allow_values(["circle".to_string(), "square".to_string()]);
+    })
+})
+~~~
+
+##### reject_values
+
+Some values can be rejected with **reject_values**:
+
+~~~rust
+let params = Builder::build(|params| {
+    params.req("user_role", |kind| {
+        kind.coerce(json_dsl::string());
+        kind.reject_values(["admin".to_string(), "manager".to_string()]);
+    })
+})
+~~~
+
+##### regex
+
+String values can be tested with Regex:
+
+~~~rust
+let params = Builder::build(|params| {
+    params.req("nickname", |a| {
+        a.coerce(json_dsl::string());
+
+        // force all nicknames to start with "Amazing"
+        a.regex(regex!("^Amazing"));
+    })
+});
+~~~
+
+##### validate_with
+
+Sometimes it's usefull to use some custom function as validator:
+
+~~~rust
+let params = Builder::build(|params| {
+    params.req("pushkin_birthday", |a| {
+        a.coerce(json_dsl::u64());
+
+        fn guess(val: &Json) -> Result<(), String> {
+            if *val == 1799u.to_json() {
+                Ok(())
+            } else {
+                Err("No!".to_string())
+            }
+        }
+
+        a.validate_with(guess);
+    });
+});
+~~~
+
+##### validate
+
+One can use custom validator. Docs in Progress.
+
+#### Builder validations
+
+Some validators can be specified in Builder DSL block to validate a set of parameters.
+
+##### mutually_exclusive
+
+Parameters can be defined as mutually_exclusive, ensuring that they aren't present at the same time in a request.
+
+~~~rust
+let params = Builder::build(|params| {
+    params.opt_defined("vodka");
+    params.opt_defined("beer");
+
+    params.mutually_exclusive(["vodka", "beer"]);
+});
+~~~
+
+##### mutually_exclusive
+
+Parameters can be defined as mutually_exclusive, ensuring that they aren't present at the same time in a request.
+
+~~~rust
+let params = Builder::build(|params| {
+    params.opt_defined("vodka");
+    params.opt_defined("beer");
+
+    params.mutually_exclusive(["vodka", "beer"]);
+});
+~~~
+
+Multiple sets can be defined:
+
+~~~rust
+let params = Builder::build(|params| {
+    params.opt_defined("vodka");
+    params.opt_defined("beer");
+    params.mutually_exclusive(["vodka", "beer"]);
+
+    params.opt_defined("lard");
+    params.opt_defined("jamon");
+    params.mutually_exclusive(["lard", "jamon"]);
+});
+~~~
+
+**Warning**: Never define mutually exclusive sets with any required params. Two mutually exclusive required params will mean params are never valid. One required param mutually exclusive with an optional param will mean the latter is never valid.
+
+##### exactly_one_of
+
+Parameters can be defined as 'exactly_one_of', ensuring that exactly one parameter gets selected.
+
+~~~rust
+let params = Builder::build(|params| {
+    params.opt_defined("vodka");
+    params.opt_defined("beer");
+    params.exactly_one_of(["vodka", "beer"]);
+});
+~~~
+
+##### at_least_one_of
+
+Parameters can be defined as 'at_least_one_of', ensuring that at least one parameter gets selected.
+
+~~~rust
+let params = Builder::build(|params| {
+    params.opt_defined("vodka");
+    params.opt_defined("beer");
+    params.opt_defined("wine");
+    params.exactly_one_of(["vodka", "beer", "wine"]);
+});
+~~~
+
+##### validate_with
+
+Sometimes it's usefull to use some custom function as validator:
+
+~~~rust
+let params = Builder::build(|params| {
+    params.req_defined("monster_name");
+
+    fn validate_params(_: &JsonObject) -> Result<(),String> {
+        Err("YOU SHALL NOT PASS".to_string())
+    }
+
+    params.validate_with(validate_params);
+});
+~~~
+
+##### validate
+
+One can use custom validator. Docs in Progress.
diff --git a/rustc_deps/vendor/valico/benches/schema.rs b/rustc_deps/vendor/valico/benches/schema.rs
new file mode 100644
index 0000000..2f65667
--- /dev/null
+++ b/rustc_deps/vendor/valico/benches/schema.rs
@@ -0,0 +1,48 @@
+#![feature(test)]
+
+extern crate valico;
+extern crate test;
+extern crate serde_json;
+
+use std::fs;
+use std::path;
+use std::io::Read;
+use serde_json::{Value, from_str};
+use valico::json_schema;
+
+fn read_schema() -> Value {
+    let mut content = String::new();
+    fs::File::open(&path::Path::new("tests/schema/schema.json")).ok().unwrap()
+        .read_to_string(&mut content).ok().unwrap();
+
+    from_str(&content).unwrap()
+}
+
+#[bench]
+fn bench_compilation(b: &mut test::Bencher) {
+    let schema = read_schema();
+
+    b.iter(|| {
+        let mut scope = json_schema::Scope::new();
+        scope.compile(schema.clone(), false).ok().unwrap();
+    });
+}
+
+#[bench]
+fn bench_compilation_ban(b: &mut test::Bencher) {
+    let schema = read_schema();
+
+    b.iter(|| {
+        let mut scope = json_schema::Scope::new();
+        scope.compile(schema.clone(), true).ok().unwrap();
+    });
+}
+
+#[bench]
+fn bench_validation(b: &mut test::Bencher) {
+    let schema = read_schema();
+    let mut scope = json_schema::Scope::new();
+    let compiled_schema = scope.compile_and_return(schema.clone(), true).ok().unwrap();
+
+    b.iter(|| assert!(compiled_schema.validate(&schema).is_valid()));
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/build.rs b/rustc_deps/vendor/valico/build.rs
new file mode 100644
index 0000000..9b6d664
--- /dev/null
+++ b/rustc_deps/vendor/valico/build.rs
@@ -0,0 +1,53 @@
+extern crate phf_codegen;
+
+use std::fs::File;
+use std::io::{BufWriter, Write};
+use std::path::Path;
+use std::env;
+
+fn main() {
+    let path = Path::new(&env::var("OUT_DIR").unwrap()).join("codegen.rs");
+    let mut file = BufWriter::new(File::create(&path).unwrap());
+
+    write!(&mut file, "static PROPERTY_KEYS: phf::Set<&'static str> = ").unwrap();
+    phf_codegen::Set::new()
+        .entry("properties")
+        .entry("patternProperties")
+        .build(&mut file)
+        .unwrap();
+    write!(&mut file, ";\n").unwrap();
+
+    write!(&mut file, "static NON_SCHEMA_KEYS: phf::Set<&'static str> = ").unwrap();
+    phf_codegen::Set::new()
+        .entry("properties")
+        .entry("patternProperties")
+        .entry("dependencies")
+        .entry("definitions")
+        .entry("anyOf")
+        .entry("allOf")
+        .entry("oneOf")
+        .build(&mut file)
+        .unwrap();
+    write!(&mut file, ";\n").unwrap();
+
+    write!(&mut file, "static FINAL_KEYS: phf::Set<&'static str> = ").unwrap();
+    phf_codegen::Set::new()
+        .entry("enum")
+        .entry("required")
+        .entry("type")
+        .build(&mut file)
+        .unwrap();
+    write!(&mut file, ";\n").unwrap();
+
+    write!(&mut file, "const ALLOW_NON_CONSUMED_KEYS: phf::Set<&'static str> = ").unwrap();
+    phf_codegen::Set::new()
+        .entry("definitions")
+        .entry("$schema")
+        .entry("id")
+        .entry("default")
+        .entry("description")
+        .entry("format")
+        .build(&mut file)
+        .unwrap();
+    write!(&mut file, ";\n").unwrap();
+}
diff --git a/rustc_deps/vendor/valico/examples/example01.rs b/rustc_deps/vendor/valico/examples/example01.rs
new file mode 100644
index 0000000..97a74ca
--- /dev/null
+++ b/rustc_deps/vendor/valico/examples/example01.rs
@@ -0,0 +1,25 @@
+extern crate valico;
+extern crate serde_json;
+
+use valico::json_dsl;
+use serde_json::{from_str, to_string_pretty};
+
+fn main() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req_nested("user", json_dsl::array(), |params| {
+            params.req_typed("name", json_dsl::string());
+            params.req_typed("friend_ids", json_dsl::array_of(json_dsl::u64()))
+        });
+    });
+
+    let mut obj = from_str(r#"{"user": {"name": "Frodo", "friend_ids": ["1223"]}}"#).unwrap();
+
+    let state = params.process(&mut obj, &None);
+    if state.is_valid() {
+        println!("Result object is {}", to_string_pretty(&obj).unwrap());
+    } else {
+        panic!("Errors during process: {:?}", state);
+    }
+
+}
diff --git a/rustc_deps/vendor/valico/src/common/error.rs b/rustc_deps/vendor/valico/src/common/error.rs
new file mode 100644
index 0000000..f4d814c
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/common/error.rs
@@ -0,0 +1,137 @@
+use std::error::Error;
+use std::fmt::Debug;
+use std::any::{Any, TypeId};
+use std::mem;
+use serde::{Serialize, Serializer};
+use serde_json::{Value, to_value};
+
+pub trait GetTypeId: Any { fn typeid(&self) -> TypeId { TypeId::of::<Self>() } }
+impl<T: Any> GetTypeId for T {}
+
+pub fn get_data_ptr<T: ?Sized>(d: *const T) -> *const () {
+    d as *const ()
+}
+
+pub trait ValicoError : Error + Send + Debug + GetTypeId {
+    fn get_code(&self) -> &str;
+    fn get_path(&self) -> &str;
+    fn get_title(&self) -> &str;
+    fn get_detail(&self) -> Option<&str> { None }
+}
+
+impl ValicoError {
+    /// Is this `Error` object of type `E`?
+    pub fn is<E: ValicoError>(&self) -> bool { self.typeid() == TypeId::of::<E>() }
+
+    /// If this error is `E`, downcast this error to `E`, by reference.
+    pub fn downcast<E: ValicoError>(&self) -> Option<&E> {
+        if self.is::<E>() {
+            unsafe { Some(mem::transmute(get_data_ptr(self))) }
+        } else {
+            None
+        }
+    }
+}
+
+impl Serialize for ValicoError {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+        let mut map = ::serde_json::Map::new();
+        map.insert("code".to_string(), to_value(self.get_code()).unwrap());
+        map.insert("title".to_string(), to_value(self.get_title()).unwrap());
+        map.insert("path".to_string(), to_value(self.get_path()).unwrap());
+        match self.get_detail() {
+            Some(ref detail) => { map.insert("detail".to_string(), to_value(detail).unwrap()); },
+            None => ()
+        }
+        Value::Object(map).serialize(serializer)
+    }
+}
+
+pub type ValicoErrors = Vec<Box<ValicoError>>;
+
+macro_rules! impl_basic_err {
+    ($err:ty, $code:expr) => {
+        impl ::std::error::Error for $err {
+            fn description(&self) -> &str {
+                $code
+            }
+        }
+
+        impl ::std::fmt::Display for $err {
+            fn fmt(&self, formatter: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+                self.description().fmt(formatter)
+            }
+        }
+    }
+}
+
+macro_rules! impl_err {
+    ($err:ty, $code:expr, $title:expr) => {
+        impl_basic_err!($err, $code);
+
+        impl $crate::common::error::ValicoError for $err {
+            fn get_code(&self) -> &str { $code }
+            fn get_title(&self) -> &str { $title }
+            fn get_path(&self) -> &str { self.path.as_ref() }
+        }
+    };
+
+    ($err:ty, $code:expr, $title:expr, +detail) => {
+        impl_basic_err!($err, $code);
+
+        impl $crate::common::error::ValicoError for $err {
+            fn get_code(&self) -> &str { $code }
+            fn get_title(&self) -> &str { $title }
+            fn get_path(&self) -> &str { self.path.as_ref() }
+            fn get_detail(&self) -> Option<&str> { Some(self.detail.as_ref()) }
+        }
+    };
+
+    ($err:ty, $code:expr, $title:expr, +opt_detail) => {
+        impl_basic_err!($err, $code);
+
+        impl $crate::common::error::ValicoError for $err {
+            fn get_code(&self) -> &str { $code }
+            fn get_title(&self) -> &str { $title }
+            fn get_path(&self) -> &str { self.path.as_ref() }
+            fn get_detail(&self) -> Option<&str> { self.detail.as_ref().map(|s| s.as_ref()) }
+        }
+    }
+}
+
+macro_rules! impl_serialize{
+    ($err:ty) => {
+        impl Serialize for $err {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+                let mut map = ::serde_json::Map::new();
+                map.insert("code".to_string(), to_value(self.get_code()).unwrap());
+                map.insert("title".to_string(), to_value(self.get_title()).unwrap());
+                map.insert("path".to_string(), to_value(self.get_path()).unwrap());
+                match self.get_detail() {
+                    Some(ref detail) => { map.insert("detail".to_string(), to_value(detail).unwrap()); },
+                    None => ()
+                }
+                Value::Object(map).serialize(serializer)
+            }
+        }
+    };
+    ($err:ty, $($sp:expr),+) => {
+        impl Serialize for $err {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+                let mut map = ::serde_json::Map::new();
+                map.insert("code".to_string(), to_value(self.get_code()).unwrap());
+                map.insert("title".to_string(), to_value(self.get_title()).unwrap());
+                map.insert("path".to_string(), to_value(self.get_path()).unwrap());
+                match self.get_detail() {
+                    Some(ref detail) => { map.insert("detail".to_string(), to_value(detail).unwrap()); },
+                    None => ()
+                }
+                $({
+                    let closure = $sp;
+                    closure(self, &mut map);
+                })+
+                Value::Object(map).serialize(serializer)
+            }
+        }
+    }
+}
diff --git a/rustc_deps/vendor/valico/src/common/mod.rs b/rustc_deps/vendor/valico/src/common/mod.rs
new file mode 100644
index 0000000..90fda98
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/common/mod.rs
@@ -0,0 +1 @@
+#[macro_use] pub mod error;
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_dsl/builder.rs b/rustc_deps/vendor/valico/src/json_dsl/builder.rs
new file mode 100644
index 0000000..95173c7
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_dsl/builder.rs
@@ -0,0 +1,280 @@
+use serde_json::{Value, to_value};
+use url;
+
+use super::super::json_schema;
+use super::param;
+use super::coercers;
+use super::validators;
+use super::errors;
+
+pub struct Builder {
+    requires: Vec<param::Param>,
+    optional: Vec<param::Param>,
+    validators: validators::Validators,
+    schema_builder: Option<Box<Fn(&mut json_schema::Builder) + Send + Sync>>,
+    schema_id: Option<url::Url>
+}
+
+unsafe impl Send for Builder { }
+
+impl Builder {
+
+    pub fn new() -> Builder {
+        Builder {
+            requires: vec![],
+            optional: vec![],
+            validators: vec![],
+            schema_builder: None,
+            schema_id: None
+        }
+    }
+
+    pub fn build<F>(rules: F) -> Builder where F: FnOnce(&mut Builder) {
+        let mut builder = Builder::new();
+        rules(&mut builder);
+
+        builder
+    }
+
+    pub fn get_required(&self) -> &Vec<param::Param> {
+        return &self.requires;
+    }
+
+    pub fn get_optional(&self) -> &Vec<param::Param> {
+        return &self.optional;
+    }
+
+    pub fn get_validators(&self) -> &validators::Validators {
+        return &self.validators;
+    }
+
+    pub fn req_defined(&mut self, name: &str) {
+        let params = param::Param::new(name);
+        self.requires.push(params);
+    }
+
+    pub fn req_typed(&mut self, name: &str, coercer: Box<coercers::Coercer + Send + Sync>) {
+        let params = param::Param::new_with_coercer(name, coercer);
+        self.requires.push(params);
+    }
+
+    pub fn req_nested<F>(&mut self, name: &str, coercer: Box<coercers::Coercer + Send + Sync>, nest_def: F) where F: FnOnce(&mut Builder) {
+        let nest_builder = Builder::build(nest_def);
+        let params = param::Param::new_with_nest(name, coercer, nest_builder);
+        self.requires.push(params);
+    }
+
+    pub fn req<F>(&mut self, name: &str, param_builder: F) where F: FnOnce(&mut param::Param) {
+        let params = param::Param::build(name, param_builder);
+        self.requires.push(params);
+    }
+
+    pub fn opt_defined(&mut self, name: &str) {
+        let params = param::Param::new(name);
+        self.optional.push(params);
+    }
+
+    pub fn opt_typed(&mut self, name: &str, coercer: Box<coercers::Coercer + Send + Sync>) {
+        let params = param::Param::new_with_coercer(name, coercer);
+        self.optional.push(params);
+    }
+
+    pub fn opt_nested<F>(&mut self, name: &str, coercer: Box<coercers::Coercer + Send + Sync>, nest_def: F) where F: FnOnce(&mut Builder) {
+        let nest_builder = Builder::build(nest_def);
+        let params = param::Param::new_with_nest(name, coercer, nest_builder);
+        self.optional.push(params);
+    }
+
+    pub fn opt<F>(&mut self, name: &str, param_builder: F) where F: FnOnce(&mut param::Param) {
+        let params = param::Param::build(name, param_builder);
+        self.optional.push(params);
+    }
+
+    pub fn validate(&mut self, validator: Box<validators::Validator + 'static + Send + Sync>) {
+        self.validators.push(validator);
+    }
+
+    pub fn validate_with<F>(&mut self, validator: F) where F: Fn(&Value, &str) -> validators::ValidatorResult + 'static + Send+Sync {
+        self.validators.push(Box::new(validator));
+    }
+
+    pub fn mutually_exclusive(&mut self, params: &[&str]) {
+        let validator = Box::new(validators::MutuallyExclusive::new(params));
+        self.validators.push(validator);
+    }
+
+    pub fn exactly_one_of(&mut self, params: &[&str]) {
+        let validator = Box::new(validators::ExactlyOneOf::new(params));
+        self.validators.push(validator);
+    }
+
+    pub fn at_least_one_of(&mut self, params: &[&str]) {
+        let validator = Box::new(validators::AtLeastOneOf::new(params));
+        self.validators.push(validator);
+    }
+
+    pub fn schema_id(&mut self, id: url::Url) {
+        self.schema_id = Some(id);
+    }
+
+    pub fn schema<F>(&mut self, build: F) where F: Fn(&mut json_schema::Builder,) + 'static + Send + Sync {
+        self.schema_builder = Some(Box::new(build));
+    }
+
+    pub fn build_schemes(&mut self, scope: &mut json_schema::Scope) -> Result<(), json_schema::SchemaError> {
+        for param in self.requires.iter_mut().chain(self.optional.iter_mut()) {
+            if param.schema_builder.is_some() {
+                let json_schema = json_schema::builder::schema_box(param.schema_builder.take().unwrap());
+                let id = try!(scope.compile(to_value(&json_schema).unwrap(), true));
+                param.schema_id = Some(id);
+            }
+
+            if param.nest.is_some() {
+                try!(param.nest.as_mut().unwrap().build_schemes(scope));
+            }
+        }
+
+        if self.schema_builder.is_some() {
+            let json_schema = json_schema::builder::schema_box(self.schema_builder.take().unwrap());
+            let id = try!(scope.compile(to_value(&json_schema).unwrap(), true));
+            self.schema_id = Some(id);
+        }
+
+        Ok(())
+    }
+
+    pub fn process(&self, val: &mut Value, scope: &Option<&json_schema::Scope>) -> json_schema::ValidationState {
+        self.process_nest(val, "", scope)
+    }
+
+    pub fn process_nest(&self, val: &mut Value, path: &str, scope: &Option<&json_schema::Scope>) -> json_schema::ValidationState {
+        let mut state = if val.is_array() {
+            let mut state = json_schema::ValidationState::new();
+            let array = val.as_array_mut().unwrap();
+            for (idx, item) in array.iter_mut().enumerate() {
+                let item_path = [path, idx.to_string().as_ref()].join("/");
+                if item.is_object() {
+                    let process_state = self.process_object(item, item_path.as_ref(), scope);
+                    state.append(process_state);
+                } else {
+                    state.errors.push(
+                        Box::new(errors::WrongType {
+                            path: item_path.to_string(),
+                            detail: "List value is not and object".to_string()
+                        })
+                    )
+                }
+            }
+
+            state
+        } else if val.is_object() {
+            self.process_object(val, path, scope)
+        } else {
+            let mut state = json_schema::ValidationState::new();
+            state.errors.push(
+                Box::new(errors::WrongType {
+                    path: path.to_string(),
+                    detail: "Value is not an object or an array".to_string()
+                })
+            );
+
+            state
+        };
+
+        let path = if path == "" {
+            "/"
+        } else {
+            path
+        };
+
+        if self.schema_id.is_some() && scope.is_some() {
+            let id = self.schema_id.as_ref().unwrap();
+            let schema = scope.as_ref().unwrap().resolve(id);
+            match schema {
+                Some(schema) => state.append(schema.validate_in(val, path)),
+                None => state.missing.push(id.clone())
+            }
+        }
+
+        state
+    }
+
+    fn process_object(&self, val: &mut Value, path: &str, scope: &Option<&json_schema::Scope>) -> json_schema::ValidationState  {
+
+        let mut state = json_schema::ValidationState::new();
+
+        {
+            let object = val.as_object_mut().expect("We expect object here");
+            for param in self.requires.iter() {
+                let ref name = param.name;
+                let present = object.contains_key(name);
+                let param_path = [path, name.as_ref()].join("/");
+                if present {
+                    let process_result = param.process(object.get_mut(name).unwrap(), param_path.as_ref(), scope);
+                    match process_result.value  {
+                        Some(new_value) => { object.insert(name.clone(), new_value); },
+                        None => ()
+                    }
+
+                    state.append(process_result.state);
+                } else {
+                    state.errors.push(Box::new(errors::Required {
+                        path: param_path.clone()
+                    }))
+                }
+            }
+
+            for param in self.optional.iter() {
+                let ref name = param.name;
+                let present = object.contains_key(name);
+                let param_path = [path, name.as_ref()].join("/");
+                if present {
+                    let process_result = param.process(object.get_mut(name).unwrap(), param_path.as_ref(), scope);
+                    match process_result.value  {
+                        Some(new_value) => { object.insert(name.clone(), new_value); },
+                        None => ()
+                    }
+
+                    state.append(process_result.state);
+                }
+            }
+        }
+
+        let path = if path == "" {
+            "/"
+        } else {
+            path
+        };
+
+        for validator in self.validators.iter() {
+            match validator.validate(val, path) {
+                Ok(()) => (),
+                Err(err) => {
+                    state.errors.extend(err);
+                }
+            };
+        }
+
+        {
+            if state.is_valid() {
+                let object = val.as_object_mut().expect("We expect object here");
+
+                // second pass we need to validate without default values in optionals
+                for param in self.optional.iter() {
+                    let ref name = param.name;
+                    let present = object.contains_key(name);
+                    if !present {
+                        match param.default.as_ref() {
+                            Some(val) => { object.insert(name.clone(), val.clone()); },
+                            None => ()
+                        };
+                    }
+                }
+            }
+        }
+
+        state
+    }
+}
+
+
diff --git a/rustc_deps/vendor/valico/src/json_dsl/coercers.rs b/rustc_deps/vendor/valico/src/json_dsl/coercers.rs
new file mode 100644
index 0000000..e9b3a05
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_dsl/coercers.rs
@@ -0,0 +1,332 @@
+use serde_json::{Value, to_string, to_value};
+
+use super::errors;
+
+#[allow(dead_code)]
+#[derive(Copy, Clone)]
+pub enum PrimitiveType {
+    String,
+    I64,
+    U64,
+    F64,
+    Boolean,
+    Null,
+    Array,
+    Object,
+    // Reserved for future use in Rustless
+    File
+}
+
+pub type CoercerResult<T> = Result<T, super::super::ValicoErrors>;
+
+pub trait Coercer: Send + Sync {
+    fn get_primitive_type(&self) -> PrimitiveType;
+    fn coerce(&self, &mut Value, &str) -> CoercerResult<Option<Value>>;
+}
+
+#[derive(Copy, Clone)]
+pub struct StringCoercer;
+
+impl Coercer for StringCoercer {
+    fn get_primitive_type(&self) -> PrimitiveType { PrimitiveType::String }
+    fn coerce(&self, val: &mut Value, path: &str) -> CoercerResult<Option<Value>> {
+        if val.is_string() {
+            Ok(None)
+        } else if val.is_number() {
+            Ok(Some(to_value(&to_string(&val).unwrap()).unwrap()))
+        } else {
+            Err(vec![
+                Box::new(errors::WrongType {
+                    path: path.to_string(),
+                    detail: "Can't coerce value to string".to_string()
+                })
+            ])
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct I64Coercer;
+
+impl Coercer for I64Coercer {
+    fn get_primitive_type(&self) -> PrimitiveType { PrimitiveType::I64 }
+    fn coerce(&self, val: &mut Value, path: &str) -> CoercerResult<Option<Value>> {
+        if val.is_i64() {
+            return Ok(None)
+        } else if val.is_u64() {
+            let val = val.as_u64().unwrap();
+            return Ok(Some(to_value(&(val as i64)).unwrap()));
+        } else if val.is_f64() {
+            let val = val.as_f64().unwrap();
+            return Ok(Some(to_value(&(val as i64)).unwrap()));
+        } else if val.is_string() {
+            let val = val.as_str().unwrap();
+            let converted: Option<i64> = val.parse().ok();
+            match converted {
+                Some(num) => Ok(Some(to_value(&num).unwrap())),
+                None => Err(vec![
+                    Box::new(errors::WrongType {
+                        path: path.to_string(),
+                        detail: "Can't coerce string value to i64".to_string()
+                    })
+                ])
+            }
+        } else {
+            Err(vec![
+                Box::new(errors::WrongType {
+                    path: path.to_string(),
+                    detail: "Can't coerce object value to i64".to_string()
+                })
+            ])
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct U64Coercer;
+
+impl Coercer for U64Coercer {
+    fn get_primitive_type(&self) -> PrimitiveType { PrimitiveType::U64 }
+    fn coerce(&self, val: &mut Value, path: &str) -> CoercerResult<Option<Value>> {
+        if val.is_u64() {
+            return Ok(None)
+        } else if val.is_i64() {
+            let val = val.as_i64().unwrap();
+            return Ok(Some(to_value(&(val as u64)).unwrap()));
+        } else if val.is_f64() {
+            let val = val.as_f64().unwrap();
+            return Ok(Some(to_value(&(val as u64)).unwrap()));
+        } else if val.is_string() {
+            let val = val.as_str().unwrap();
+            let converted: Option<u64> = val.parse().ok();
+            match converted {
+                Some(num) => Ok(Some(to_value(&num).unwrap())),
+                None => Err(vec![
+                    Box::new(errors::WrongType {
+                        path: path.to_string(),
+                        detail: "Can't coerce string value to u64".to_string()
+                    })
+                ])
+            }
+        } else {
+            Err(vec![
+                Box::new(errors::WrongType {
+                    path: path.to_string(),
+                    detail: "Can't coerce object value to u64".to_string()
+                })
+            ])
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct F64Coercer;
+
+impl Coercer for F64Coercer {
+    fn get_primitive_type(&self) -> PrimitiveType { PrimitiveType::F64 }
+    fn coerce(&self, val: &mut Value, path: &str) -> CoercerResult<Option<Value>> {
+        if val.is_f64() {
+            return Ok(None)
+        } else if val.is_i64() {
+            let val = val.as_i64().unwrap();
+            return Ok(Some(to_value(&(val as f64)).unwrap()));
+        } else if val.is_u64() {
+            let val = val.as_u64().unwrap();
+            return Ok(Some(to_value(&(val as f64)).unwrap()));
+        } else if val.is_string() {
+            let val = val.as_str().unwrap();
+            let converted: Option<f64> = val.parse().ok();
+            match converted {
+                Some(num) => Ok(Some(to_value(&num).unwrap())),
+                None => Err(vec![
+                    Box::new(errors::WrongType {
+                        path: path.to_string(),
+                        detail: "Can't coerce string value to f64".to_string()
+                    })
+                ])
+            }
+        } else {
+            Err(vec![
+                Box::new(errors::WrongType {
+                    path: path.to_string(),
+                    detail: "Can't coerce object value to f64".to_string()
+                })
+            ])
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct BooleanCoercer;
+
+impl Coercer for BooleanCoercer {
+    fn get_primitive_type(&self) -> PrimitiveType { PrimitiveType::Boolean }
+    fn coerce(&self, val: &mut Value, path: &str) -> CoercerResult<Option<Value>> {
+        if val.is_boolean() {
+            Ok(None)
+        } else if val.is_string() {
+            let val = val.as_str().unwrap();
+            if val == "true" {
+                Ok(Some(Value::Bool(true)))
+            } else if val == "false" {
+                Ok(Some(Value::Bool(false)))
+            } else {
+                Err(vec![
+                    Box::new(errors::WrongType {
+                        path: path.to_string(),
+                        detail: "Can't coerce this string value to boolean. Correct values are 'true' and 'false'".to_string()
+                    })
+                ])
+            }
+        } else {
+            Err(vec![
+                Box::new(errors::WrongType {
+                    path: path.to_string(),
+                    detail: "Can't coerce object to boolean".to_string()
+                })
+            ])
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct NullCoercer;
+
+impl Coercer for NullCoercer {
+    fn get_primitive_type(&self) -> PrimitiveType { PrimitiveType::Null }
+    fn coerce(&self, val: &mut Value, path: &str) -> CoercerResult<Option<Value>> {
+        if val.is_null() {
+            Ok(None)
+        } else if val.is_string() {
+            let val = val.as_str().unwrap();
+            if val == "" {
+                Ok(Some(Value::Null))
+            } else {
+                Err(vec![
+                    Box::new(errors::WrongType {
+                        path: path.to_string(),
+                        detail: "Can't coerce this string value to null. Correct value is only empty string".to_string()
+                    })
+                ])
+            }
+        } else {
+            Err(vec![
+                Box::new(errors::WrongType {
+                    path: path.to_string(),
+                    detail: "Can't coerce object to null".to_string()
+                })
+            ])
+        }
+    }
+}
+
+pub struct ArrayCoercer {
+    sub_coercer: Option<Box<Coercer + Send + Sync>>,
+    separator: Option<String>
+}
+
+impl ArrayCoercer {
+    pub fn new() -> ArrayCoercer {
+        ArrayCoercer {
+            sub_coercer: None,
+            separator: None
+        }
+    }
+
+    pub fn encoded(separator: String) -> ArrayCoercer {
+        ArrayCoercer {
+            separator: Some(separator),
+            sub_coercer: None
+        }
+    }
+
+    pub fn encoded_of(separator: String, sub_coercer: Box<Coercer + Send + Sync>) -> ArrayCoercer {
+        ArrayCoercer {
+            separator: Some(separator),
+            sub_coercer: Some(sub_coercer)
+        }
+    }
+
+    pub fn of_type(sub_coercer: Box<Coercer + Send + Sync>) -> ArrayCoercer {
+        ArrayCoercer {
+            separator: None,
+            sub_coercer: Some(sub_coercer)
+        }
+    }
+
+    fn coerce_array(&self, val: &mut Value, path: &str) -> CoercerResult<Option<Value>> {
+        let array = val.as_array_mut().unwrap();
+        if self.sub_coercer.is_some() {
+            let sub_coercer = self.sub_coercer.as_ref().unwrap();
+            let mut errors = vec![];
+            for i in 0..array.len() {
+                let item_path = [path, i.to_string().as_ref()].join("/");
+                match sub_coercer.coerce(&mut array[i], item_path.as_ref()) {
+                    Ok(Some(value)) => {
+                        array.remove(i);
+                        array.insert(i, value);
+                    },
+                    Ok(None) => (),
+                    Err(err) => {
+                        errors.extend(err);
+                    }
+                }
+            }
+
+            if errors.len() == 0 {
+                Ok(None)
+            } else {
+                Err(errors)
+            }
+        } else {
+            Ok(None)
+        }
+    }
+}
+
+impl Coercer for ArrayCoercer {
+    fn get_primitive_type(&self) -> PrimitiveType { PrimitiveType::Array }
+
+    fn coerce(&self, val: &mut Value, path: &str) -> CoercerResult<Option<Value>> {
+        if val.is_array() {
+            self.coerce_array(val, path)
+        } else if val.is_string() && self.separator.is_some() {
+            let separator = self.separator.as_ref().unwrap();
+            let string = val.as_str().unwrap();
+            let mut array = Value::Array(
+                string
+                    .split(&separator[..])
+                    .map(|s| Value::String(s.to_string()))
+                    .collect::<Vec<Value>>()
+            );
+            try!(self.coerce_array(&mut array, path));
+            Ok(Some(array))
+        } else {
+            Err(vec![
+                Box::new(errors::WrongType {
+                    path: path.to_string(),
+                    detail: "Can't coerce object to array".to_string()
+                })
+            ])
+        }
+    }
+}
+
+#[derive(Copy, Clone)]
+pub struct ObjectCoercer;
+
+impl Coercer for ObjectCoercer {
+    fn get_primitive_type(&self) -> PrimitiveType { PrimitiveType::Object }
+    fn coerce(&self, val: &mut Value, path: &str) -> CoercerResult<Option<Value>> {
+        if val.is_object() {
+            Ok(None)
+        } else {
+            Err(vec![
+                Box::new(errors::WrongType {
+                    path: path.to_string(),
+                    detail: "Can't coerce non-object value to the object type".to_string()
+                })
+            ])
+        }
+    }
+}
diff --git a/rustc_deps/vendor/valico/src/json_dsl/errors.rs b/rustc_deps/vendor/valico/src/json_dsl/errors.rs
new file mode 100644
index 0000000..d68b12f
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_dsl/errors.rs
@@ -0,0 +1,68 @@
+use std::error::{Error};
+use super::super::common::error::ValicoError;
+use serde_json::{Value, to_value};
+use serde::{Serialize, Serializer};
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct Required {
+    pub path: String
+}
+impl_err!(Required, "required", "This field is required");
+impl_serialize!(Required);
+
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct WrongType {
+    pub path: String,
+    pub detail: String
+}
+impl_err!(WrongType, "wrong_type", "Type of the value is wrong", +detail);
+impl_serialize!(WrongType);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct WrongValue {
+    pub path: String,
+    pub detail: Option<String>,
+}
+impl_err!(WrongValue, "wrong_value", "The value is wrong or mailformed", +opt_detail);
+impl_serialize!(WrongValue);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct MutuallyExclusive {
+    pub path: String,
+    pub detail: Option<String>,
+    pub params: Vec<String>
+}
+impl_err!(MutuallyExclusive, "mutually_exclusive", "The values are mutually exclusive", +opt_detail);
+impl_serialize!(MutuallyExclusive, |err: &MutuallyExclusive, map: &mut ::serde_json::Map<String, Value>| {
+    map.insert("params".to_string(), to_value(&err.params).unwrap());
+});
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct ExactlyOne {
+    pub path: String,
+    pub detail: Option<String>,
+    pub params: Vec<String>
+}
+impl_err!(ExactlyOne, "exactly_one", "Exacly one of the values must be present", +opt_detail);
+impl_serialize!(ExactlyOne, |err: &ExactlyOne, map: &mut ::serde_json::Map<String, Value>| {
+    map.insert("params".to_string(), to_value(&err.params).unwrap())
+});
+
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct AtLeastOne {
+    pub path: String,
+    pub detail: Option<String>,
+    pub params: Vec<String>
+}
+impl_err!(AtLeastOne, "at_least_one", "At least one of the values must be present", +opt_detail);
+impl_serialize!(AtLeastOne, |err: &AtLeastOne, map: &mut ::serde_json::Map<String, Value>| {
+    map.insert("params".to_string(), to_value(&err.params).unwrap())
+});
diff --git a/rustc_deps/vendor/valico/src/json_dsl/mod.rs b/rustc_deps/vendor/valico/src/json_dsl/mod.rs
new file mode 100644
index 0000000..61ef0d3
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_dsl/mod.rs
@@ -0,0 +1,75 @@
+mod builder;
+mod coercers;
+mod param;
+pub mod errors;
+#[macro_use] pub mod validators;
+
+use super::json_schema;
+
+pub use self::param::Param;
+pub use self::builder::Builder;
+pub use self::coercers::{
+    PrimitiveType,
+    Coercer,
+    StringCoercer,
+    I64Coercer,
+    U64Coercer,
+    F64Coercer,
+    BooleanCoercer,
+    NullCoercer,
+    ArrayCoercer,
+    ObjectCoercer,
+};
+
+pub fn i64() -> Box<coercers::Coercer + Send + Sync> { Box::new(coercers::I64Coercer) }
+pub fn u64() -> Box<coercers::Coercer + Send + Sync> { Box::new(coercers::U64Coercer) }
+pub fn f64() -> Box<coercers::Coercer + Send + Sync> { Box::new(coercers::F64Coercer) }
+pub fn string() -> Box<coercers::Coercer + Send + Sync> { Box::new(coercers::StringCoercer) }
+pub fn boolean() -> Box<coercers::Coercer + Send + Sync> { Box::new(coercers::BooleanCoercer) }
+pub fn null() -> Box<coercers::Coercer + Send + Sync> { Box::new(coercers::NullCoercer) }
+pub fn array() -> Box<coercers::Coercer + Send + Sync> { Box::new(coercers::ArrayCoercer::new()) }
+pub fn array_of(coercer: Box<coercers::Coercer + Send + Sync>) -> Box<coercers::Coercer + Send + Sync> {
+    Box::new(coercers::ArrayCoercer::of_type(coercer))
+}
+
+pub fn encoded_array(separator: &str) -> Box<coercers::Coercer + Send + Sync> {
+    Box::new(coercers::ArrayCoercer::encoded(separator.to_string()))
+}
+
+pub fn encoded_array_of(separator: &str, coercer: Box<coercers::Coercer + Send + Sync>) -> Box<coercers::Coercer + Send + Sync> {
+    Box::new(coercers::ArrayCoercer::encoded_of(separator.to_string(), coercer))
+}
+
+pub fn object() -> Box<coercers::Coercer + Send + Sync> { Box::new(coercers::ObjectCoercer) }
+
+pub struct ExtendedResult<T> {
+    value: T,
+    state: json_schema::ValidationState
+}
+
+impl<T> ExtendedResult<T> {
+    pub fn new(value: T) -> ExtendedResult<T> {
+        ExtendedResult {
+            value: value,
+            state: json_schema::ValidationState::new()
+        }
+    }
+
+    pub fn with_errors(value: T, errors: super::ValicoErrors) -> ExtendedResult<T> {
+        ExtendedResult {
+            value: value,
+            state: json_schema::ValidationState {
+                errors: errors,
+                missing: vec![]
+            }
+        }
+    }
+
+    pub fn is_valid(&self) -> bool {
+        self.state.is_valid()
+    }
+
+    pub fn append(&mut self, second: json_schema::ValidationState) {
+        self.state.append(second);
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_dsl/param.rs b/rustc_deps/vendor/valico/src/json_dsl/param.rs
new file mode 100644
index 0000000..5d0d5c9
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_dsl/param.rs
@@ -0,0 +1,192 @@
+use regex;
+use url;
+use serde_json::{Value, to_value};
+use serde::{Serialize};
+
+use super::super::json_schema;
+use super::builder;
+use super::coercers;
+use super::validators;
+
+pub struct Param {
+    pub name: String,
+    pub coercer: Option<Box<coercers::Coercer + Send + Sync>>,
+    pub nest: Option<builder::Builder>,
+    pub description: Option<String>,
+    pub allow_null: bool,
+    pub validators: validators::Validators,
+    pub default: Option<Value>,
+    pub schema_builder: Option<Box<Fn(&mut json_schema::Builder) + Send + Sync>>,
+    pub schema_id: Option<url::Url>
+}
+
+unsafe impl Send for Param { }
+
+impl Param {
+
+    pub fn new(name: &str) -> Param {
+        Param {
+            name: name.to_string(),
+            description: None,
+            coercer: None,
+            nest: None,
+            allow_null: false,
+            validators: vec![],
+            default: None,
+            schema_builder: None,
+            schema_id: None
+        }
+    }
+
+    pub fn new_with_coercer(name: &str, coercer: Box<coercers::Coercer  + Send + Sync>) -> Param {
+        Param {
+            name: name.to_string(),
+            description: None,
+            coercer: Some(coercer),
+            nest: None,
+            allow_null: false,
+            validators: vec![],
+            default: None,
+            schema_builder: None,
+            schema_id: None
+        }
+    }
+
+    pub fn new_with_nest(name: &str, coercer: Box<coercers::Coercer + Send + Sync>, nest: builder::Builder) -> Param {
+        Param {
+            name: name.to_string(),
+            description: None,
+            coercer: Some(coercer),
+            nest: Some(nest),
+            allow_null: false,
+            validators: vec![],
+            default: None,
+            schema_builder: None,
+            schema_id: None
+        }
+    }
+
+    pub fn build<F>(name: &str, build_def: F) -> Param where F: FnOnce(&mut Param) {
+        let mut param = Param::new(name);
+        build_def(&mut param);
+
+        param
+    }
+
+    pub fn desc(&mut self, description: &str) {
+        self.description = Some(description.to_string());
+    }
+
+    pub fn schema_id(&mut self, id: url::Url) {
+        self.schema_id = Some(id);
+    }
+
+    pub fn schema<F>(&mut self, build: F) where F: Fn(&mut json_schema::Builder,) + 'static + Send + Sync {
+        self.schema_builder = Some(Box::new(build));
+    }
+
+    pub fn coerce(&mut self, coercer: Box<coercers::Coercer + Send + Sync>) {
+        self.coercer = Some(coercer);
+    }
+
+    pub fn nest<F>(&mut self, nest_def: F) where F: FnOnce(&mut builder::Builder) -> () {
+        self.nest = Some(builder::Builder::build(nest_def));
+    }
+
+    pub fn allow_null(&mut self) {
+        self.allow_null = true;
+    }
+
+    pub fn regex(&mut self, regex: regex::Regex) {
+        self.validators.push(Box::new(regex));
+    }
+
+    pub fn validate(&mut self, validator: Box<validators::Validator + 'static + Send + Sync>) {
+        self.validators.push(validator);
+    }
+
+    pub fn validate_with<F>(&mut self, validator: F) where F: Fn(&Value, &str) -> super::validators::ValidatorResult + 'static + Send+Sync {
+        self.validators.push(Box::new(validator));
+    }
+
+    fn process_validators(&self, val: &Value, path: &str) -> super::super::ValicoErrors {
+        let mut errors = vec![];
+        for validator in self.validators.iter() {
+            match validator.validate(val, path) {
+                Ok(()) => (),
+                Err(validation_errors) => errors.extend(validation_errors)
+            }
+        };
+
+        errors
+    }
+
+    pub fn process(&self, val: &mut Value, path: &str, scope: &Option<&json_schema::Scope>) -> super::ExtendedResult<Option<Value>> {
+        if val.is_null() && self.allow_null {
+            return super::ExtendedResult::new(None)
+        }
+
+        let mut result = super::ExtendedResult::new(None);
+        let mut return_value = None;
+
+        {
+
+            let val = if self.coercer.is_some() {
+                match self.coercer.as_ref().unwrap().coerce(val, path) {
+                    Ok(None) => val,
+                    Ok(Some(new_value)) => {
+                        return_value = Some(new_value);
+                        return_value.as_mut().unwrap()
+                    },
+                    Err(errors) => {
+                        result.state.errors.extend(errors);
+                        return result;
+                    }
+                }
+            } else {
+                val
+            };
+
+            if self.nest.is_some() {
+                let process_state = self.nest.as_ref().unwrap().process_nest(val, path, scope);
+                result.append(process_state);
+            }
+
+            let validation_errors = self.process_validators(val, path);
+            result.state.errors.extend(validation_errors);
+
+            if self.schema_id.is_some() && scope.is_some() {
+                let id = self.schema_id.as_ref().unwrap();
+                let schema = scope.as_ref().unwrap().resolve(id);
+                match schema {
+                    Some(schema) => result.append(schema.validate_in(val, path)),
+                    None => result.state.missing.push(id.clone())
+                }
+            }
+        }
+
+        if return_value.is_some() {
+            result.value = return_value;
+        }
+
+        result
+    }
+}
+
+impl Param {
+    pub fn allow_values<T: Serialize>(&mut self, values: &[T]) {
+        self.validators.push(Box::new(validators::AllowedValues::new(
+            values.iter().map(|v| to_value(v).unwrap()).collect()
+        )));
+    }
+
+    pub fn reject_values<T: Serialize>(&mut self, values: &[T]) {
+        self.validators.push(Box::new(validators::RejectedValues::new(
+            values.iter().map(|v| to_value(v).unwrap()).collect()
+        )));
+    }
+
+    pub fn default<T: Serialize>(&mut self, default: T) {
+        self.default = Some(to_value(&default).unwrap());
+    }
+}
diff --git a/rustc_deps/vendor/valico/src/json_dsl/validators/allowed_values.rs b/rustc_deps/vendor/valico/src/json_dsl/validators/allowed_values.rs
new file mode 100644
index 0000000..8b946d8
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_dsl/validators/allowed_values.rs
@@ -0,0 +1,34 @@
+use serde_json::{Value};
+use super::super::errors;
+
+pub struct AllowedValues {
+    allowed_values: Vec<Value>
+}
+
+impl AllowedValues {
+    pub fn new(values: Vec<Value>) -> AllowedValues {
+        AllowedValues {
+            allowed_values: values
+        }
+    }
+}
+
+impl super::Validator for AllowedValues {
+    fn validate(&self, val: &Value, path: &str) -> super::ValidatorResult {
+        let mut matched = false;
+        for allowed_value in self.allowed_values.iter() {
+            if val == allowed_value { matched = true; }
+        }
+
+        if matched {
+            Ok(())
+        } else {
+            Err(vec![
+                Box::new(errors::WrongValue {
+                    path: path.to_string(),
+                    detail: Some("Value is not among allowed list".to_string())
+                })
+            ])
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_dsl/validators/at_least_one_of.rs b/rustc_deps/vendor/valico/src/json_dsl/validators/at_least_one_of.rs
new file mode 100644
index 0000000..bfc8376
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_dsl/validators/at_least_one_of.rs
@@ -0,0 +1,40 @@
+use serde_json::{Value};
+
+use super::super::errors;
+
+pub struct AtLeastOneOf {
+    params: Vec<String>
+}
+
+impl AtLeastOneOf {
+    pub fn new(params: &[&str]) -> AtLeastOneOf {
+        AtLeastOneOf {
+            params: params.iter().map(|s| s.to_string()).collect()
+        }
+    }
+}
+
+impl super::Validator for AtLeastOneOf {
+    fn validate(&self, val: &Value, path: &str) -> super::ValidatorResult {
+
+        let object = strict_process!(val.as_object(), path, "The value must be an object");
+
+        let mut matched = vec![];
+        for param in self.params.iter() {
+            if object.contains_key(param) { matched.push(param.clone()); }
+        }
+
+        let len = matched.len();
+        if len >= 1 {
+            Ok(())
+        } else {
+            Err(vec![
+                Box::new(errors::AtLeastOne {
+                    path: path.to_string(),
+                    detail: Some("At least one must be present".to_string()),
+                    params: self.params.clone()
+                })
+            ])
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_dsl/validators/exactly_one_of.rs b/rustc_deps/vendor/valico/src/json_dsl/validators/exactly_one_of.rs
new file mode 100644
index 0000000..0d2ee7c
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_dsl/validators/exactly_one_of.rs
@@ -0,0 +1,48 @@
+use serde_json::{Value};
+
+use super::super::errors;
+
+pub struct ExactlyOneOf {
+    params: Vec<String>
+}
+
+impl ExactlyOneOf {
+    pub fn new(params: &[&str]) -> ExactlyOneOf {
+        ExactlyOneOf {
+            params: params.iter().map(|s| s.to_string()).collect()
+        }
+    }
+}
+
+impl super::Validator for ExactlyOneOf {
+    fn validate(&self, val: &Value, path: &str) -> super::ValidatorResult {
+
+        let object = strict_process!(val.as_object(), path, "The value must be an object");
+
+        let mut matched = vec![];
+        for param in self.params.iter() {
+            if object.contains_key(param) { matched.push(param.clone()); }
+        }
+
+        let len = matched.len();
+        if len == 1 {
+            Ok(())
+        } else if len > 1 {
+            Err(vec![
+                Box::new(errors::ExactlyOne {
+                    path: path.to_string(),
+                    detail: Some("Exactly one is allowed at one time".to_string()),
+                    params: matched
+                })
+            ])
+        } else {
+            Err(vec![
+                Box::new(errors::ExactlyOne {
+                    path: path.to_string(),
+                    detail: Some("Exactly one must be present".to_string()),
+                    params: self.params.clone()
+                })
+            ])
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_dsl/validators/mod.rs b/rustc_deps/vendor/valico/src/json_dsl/validators/mod.rs
new file mode 100644
index 0000000..6295e57
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_dsl/validators/mod.rs
@@ -0,0 +1,54 @@
+use serde_json::{Value};
+use std::fmt;
+
+use common::error;
+
+pub use self::allowed_values::{AllowedValues};
+pub use self::at_least_one_of::{AtLeastOneOf};
+pub use self::exactly_one_of::{ExactlyOneOf};
+pub use self::mutually_exclusive::{MutuallyExclusive};
+pub use self::rejected_values::{RejectedValues};
+
+macro_rules! strict_process {
+    ($val:expr, $path:ident, $err:expr) => {{
+        let maybe_val = $val;
+        if maybe_val.is_none() {
+            return Err(vec![
+                Box::new($crate::json_dsl::errors::WrongType {
+                    path: $path.to_string(),
+                    detail: $err.to_string()
+                })
+            ])
+        }
+
+        maybe_val.unwrap()
+    }}
+}
+
+mod allowed_values;
+mod at_least_one_of;
+mod exactly_one_of;
+mod mutually_exclusive;
+mod regex;
+mod rejected_values;
+
+pub type ValidatorResult = Result<(), error::ValicoErrors>;
+
+pub trait Validator {
+    fn validate(&self, item: &Value, &str) -> ValidatorResult;
+}
+
+impl fmt::Debug for Validator + 'static {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.write_str("[validator]")
+    }
+}
+
+pub type BoxedValidator = Box<Validator + 'static + Send + Sync>;
+pub type Validators = Vec<BoxedValidator>;
+
+impl<T> Validator for T where T: Fn(&Value, &str) -> ValidatorResult {
+    fn validate(&self, val: &Value, path: &str) -> ValidatorResult {
+        self(val, path)
+    }
+}
diff --git a/rustc_deps/vendor/valico/src/json_dsl/validators/mutually_exclusive.rs b/rustc_deps/vendor/valico/src/json_dsl/validators/mutually_exclusive.rs
new file mode 100644
index 0000000..3693c89
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_dsl/validators/mutually_exclusive.rs
@@ -0,0 +1,39 @@
+use serde_json::{Value};
+
+use super::super::errors;
+
+pub struct MutuallyExclusive {
+    params: Vec<String>
+}
+
+impl MutuallyExclusive {
+    pub fn new(params: &[&str]) -> MutuallyExclusive {
+        MutuallyExclusive {
+            params: params.iter().map(|s| s.to_string()).collect()
+        }
+    }
+}
+
+impl super::Validator for MutuallyExclusive {
+    fn validate(&self, val: &Value, path: &str) -> super::ValidatorResult {
+
+        let object = strict_process!(val.as_object(), path, "The value must be an object");
+
+        let mut matched = vec![];
+        for param in self.params.iter() {
+            if object.contains_key(param) { matched.push(param.clone()); }
+        }
+
+        if matched.len() <= 1 {
+            Ok(())
+        } else {
+            Err(vec![
+                Box::new(errors::MutuallyExclusive{
+                    path: path.to_string(),
+                    params: matched,
+                    detail: Some("Fields are mutually exclusive".to_string())
+                })
+            ])
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_dsl/validators/regex.rs b/rustc_deps/vendor/valico/src/json_dsl/validators/regex.rs
new file mode 100644
index 0000000..cf0f21d
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_dsl/validators/regex.rs
@@ -0,0 +1,22 @@
+use serde_json::{Value};
+use regex;
+
+use super::super::errors;
+
+impl super::Validator for regex::Regex {
+    fn validate(&self, val: &Value, path: &str) -> super::ValidatorResult {
+
+        let string = strict_process!(val.as_str(), path, "The value must be a string");
+
+        if self.is_match(string) {
+            Ok(())
+        } else {
+            Err(vec![
+                Box::new(errors::WrongValue {
+                    path: path.to_string(),
+                    detail: Some("Value is not matched by required pattern".to_string())
+                })
+            ])
+        }
+    }
+}
diff --git a/rustc_deps/vendor/valico/src/json_dsl/validators/rejected_values.rs b/rustc_deps/vendor/valico/src/json_dsl/validators/rejected_values.rs
new file mode 100644
index 0000000..2a9f036
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_dsl/validators/rejected_values.rs
@@ -0,0 +1,35 @@
+use serde_json::{Value};
+
+use super::super::errors;
+
+pub struct RejectedValues {
+    rejected_values: Vec<Value>
+}
+
+impl RejectedValues {
+    pub fn new(values: Vec<Value>) -> RejectedValues {
+        RejectedValues {
+            rejected_values: values
+        }
+    }
+}
+
+impl super::Validator for RejectedValues {
+    fn validate(&self, val: &Value, path: &str) -> super::ValidatorResult {
+        let mut matched = false;
+        for rejected_value in self.rejected_values.iter() {
+            if val == rejected_value { matched = true; }
+        }
+
+        if matched {
+            Err(vec![
+                Box::new(errors::WrongValue {
+                    path: path.to_string(),
+                    detail: Some("Value is among reject list".to_string())
+                })
+            ])
+        } else {
+            Ok(())
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/builder.rs b/rustc_deps/vendor/valico/src/json_schema/builder.rs
new file mode 100644
index 0000000..a4f6398
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/builder.rs
@@ -0,0 +1,297 @@
+use jsonway;
+use std::collections;
+use serde_json::value::{Value, to_value};
+use serde::{Serialize, Serializer};
+
+pub struct SchemaArray {
+    items: Vec<Value>
+}
+
+impl SchemaArray {
+    pub fn new() -> SchemaArray {
+        SchemaArray { items: vec![] }
+    }
+
+    pub fn push<F>(&mut self, build: F) where F: FnOnce(&mut Builder) {
+        self.items.push( Builder::build(build).into_json() )
+    }
+}
+
+pub struct SchemaHash {
+    items: collections::HashMap<String, Value>
+}
+
+impl SchemaHash {
+    pub fn new() -> SchemaHash {
+        SchemaHash { items: collections::HashMap::new() }
+    }
+
+    pub fn insert<F>(&mut self, key: &str, build: F) where F: FnOnce(&mut Builder) {
+        self.items.insert(key.to_string(), Builder::build(build).into_json());
+    }
+}
+
+pub struct Dependencies {
+    deps: collections::HashMap<String, Dependency>
+}
+
+impl Dependencies {
+    pub fn new() -> Dependencies {
+        Dependencies {
+            deps: collections::HashMap::new()
+        }
+    }
+
+    pub fn schema<F>(&mut self, property: &str, build: F) where F: FnOnce(&mut Builder) {
+        self.deps.insert(property.to_string(), Dependency::Schema( Builder::build(build).into_json() ));
+    }
+
+    pub fn property(&mut self, property: &str, properties: Vec<String>) {
+        self.deps.insert(property.to_string(), Dependency::Property(properties));
+    }
+
+    pub fn build<F>(build: F) -> Dependencies where F: FnOnce(&mut Dependencies) {
+        let mut deps = Dependencies::new();
+        build(&mut deps);
+        deps
+    }
+}
+
+impl Serialize for Dependencies {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+        self.deps.serialize(serializer)
+    }
+}
+
+pub enum Dependency {
+    Schema(Value),
+    Property(Vec<String>)
+}
+
+impl Serialize for Dependency {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+        match self {
+            &Dependency::Schema(ref json) => json.serialize(serializer),
+            &Dependency::Property(ref array) => array.serialize(serializer)
+        }
+    }
+}
+
+/// Builder provides simple DSL to build Schema. It allows you not to use
+/// strings and raw JSON manipulation. It also prevent some kinds of spelling
+/// and type errors.
+pub struct Builder {
+    obj_builder: jsonway::ObjectBuilder
+}
+
+impl Builder {
+    pub fn new() -> Builder {
+        Builder {
+            obj_builder: jsonway::ObjectBuilder::new()
+        }
+    }
+
+    pub fn id(&mut self, url: &str) {
+        self.obj_builder.set("id", url.to_string())
+    }
+
+    pub fn ref_(&mut self, url: &str) {
+        self.obj_builder.set("$ref", url.to_string())
+    }
+
+    pub fn schema(&mut self, url: &str) {
+        self.obj_builder.set("$schema", url.to_string())
+    }
+
+    pub fn desc(&mut self, text: &str) {
+        self.obj_builder.set("description", text.to_string())
+    }
+
+    pub fn title(&mut self, text: &str) {
+        self.obj_builder.set("title", text.to_string())
+    }
+
+    pub fn default<T>(&mut self, default: T) where T: Serialize {
+        self.obj_builder.set("default", default)
+    }
+
+    pub fn multiple_of(&mut self, number: f64) {
+        self.obj_builder.set("multipleOf", number)
+    }
+
+    pub fn maximum(&mut self, number: f64, exclusive: bool) {
+        self.obj_builder.set("maximum", number);
+        if exclusive {
+            self.obj_builder.set("exclusiveMaximum", exclusive)
+        }
+    }
+
+    pub fn minimum(&mut self, number: f64, exclusive: bool) {
+        self.obj_builder.set("minimum", number);
+        if exclusive {
+            self.obj_builder.set("exclusiveMinimum", exclusive)
+        }
+    }
+
+    pub fn max_length(&mut self, number: u64) {
+        self.obj_builder.set("maxLength", number)
+    }
+
+    pub fn min_length(&mut self, number: u64) {
+        self.obj_builder.set("minLength", number)
+    }
+
+    pub fn pattern(&mut self, pattern: &str) {
+        self.obj_builder.set("pattern", pattern.to_string())
+    }
+
+    pub fn format(&mut self, format: &str) {
+        self.obj_builder.set("format", format.to_string())
+    }
+
+    pub fn items_schema<F>(&mut self, build: F) where F: FnOnce(&mut Builder) {
+        self.obj_builder.set("items", Builder::build(build).into_json() )
+    }
+
+    pub fn items_array<F>(&mut self, build: F) where F: FnOnce(&mut SchemaArray) {
+        let mut items = SchemaArray::new();
+        build(&mut items);
+        self.obj_builder.set("items", items.items)
+    }
+
+    pub fn additional_items(&mut self, allow: bool) {
+        self.obj_builder.set("additionalItems", allow)
+    }
+
+    pub fn additional_items_schema<F>(&mut self, build: F) where F: FnOnce(&mut Builder) {
+        self.obj_builder.set("additionalItems", Builder::build(build).into_json())
+    }
+
+    pub fn max_items(&mut self, number: u64) {
+        self.obj_builder.set("maxItems", number)
+    }
+
+    pub fn min_items(&mut self, number: u64) {
+        self.obj_builder.set("minItems", number)
+    }
+
+    pub fn unique_items(&mut self, unique: bool) {
+        self.obj_builder.set("uniqueItems", unique)
+    }
+
+    pub fn max_properties(&mut self, number: u64) {
+        self.obj_builder.set("maxProperties", number)
+    }
+
+    pub fn min_properties(&mut self, number: u64) {
+        self.obj_builder.set("minProperties", number)
+    }
+
+    pub fn required(&mut self, items: Vec<String>) {
+        self.obj_builder.set("required", items)
+    }
+
+    pub fn properties<F>(&mut self, build: F) where F: FnOnce(&mut SchemaHash) {
+        let mut items = SchemaHash::new();
+        build(&mut items);
+        self.obj_builder.set("properties", items.items)
+    }
+
+    pub fn pattern_properties<F>(&mut self, build: F) where F: FnOnce(&mut SchemaHash) {
+        let mut items = SchemaHash::new();
+        build(&mut items);
+        self.obj_builder.set("patternProperties", items.items)
+    }
+
+    pub fn additional_properties(&mut self, allow: bool) {
+        self.obj_builder.set("additionalProperties", allow)
+    }
+
+    pub fn additional_properties_schema<F>(&mut self, build: F) where F: FnOnce(&mut Builder) {
+        self.obj_builder.set("additionalProperties", Builder::build(build).into_json())
+    }
+
+    pub fn dependencies<F>(&mut self, build: F) where F: FnOnce(&mut Dependencies) {
+        self.obj_builder.set("dependencies", Dependencies::build(build))
+    }
+
+    pub fn enum_<F>(&mut self, build: F) where F: FnOnce(&mut jsonway::ArrayBuilder) {
+        self.obj_builder.set("enum", jsonway::array(build).unwrap())
+    }
+
+    pub fn array(&mut self) {
+        self.obj_builder.set("type", super::PrimitiveType::Array.to_string())
+    }
+    pub fn boolean(&mut self) {
+        self.obj_builder.set("type", super::PrimitiveType::Boolean.to_string())
+    }
+    pub fn integer(&mut self) {
+        self.obj_builder.set("type", super::PrimitiveType::Integer.to_string())
+    }
+    pub fn number(&mut self) {
+        self.obj_builder.set("type", super::PrimitiveType::Number.to_string())
+    }
+    pub fn null(&mut self) {
+        self.obj_builder.set("type", super::PrimitiveType::Null.to_string())
+    }
+    pub fn object(&mut self) {
+        self.obj_builder.set("type", super::PrimitiveType::Object.to_string())
+    }
+    pub fn string(&mut self) {
+        self.obj_builder.set("type", super::PrimitiveType::String.to_string())
+    }
+    pub fn type_(&mut self, type_: super::PrimitiveType) {
+        self.obj_builder.set("type", type_.to_string())
+    }
+    pub fn types(&mut self, types: &[super::PrimitiveType]) {
+        self.obj_builder.set("type", to_value(&types.iter().map(|t| t.to_string()).collect::<Vec<String>>()).unwrap())
+    }
+
+    pub fn all_of<F>(&mut self, build: F) where F: FnOnce(&mut SchemaArray) {
+        let mut items = SchemaArray::new();
+        build(&mut items);
+        self.obj_builder.set("allOf", items.items)
+    }
+
+    pub fn any_of<F>(&mut self, build: F) where F: FnOnce(&mut SchemaArray) {
+        let mut items = SchemaArray::new();
+        build(&mut items);
+        self.obj_builder.set("anyOf", items.items)
+    }
+
+    pub fn one_of<F>(&mut self, build: F) where F: FnOnce(&mut SchemaArray) {
+        let mut items = SchemaArray::new();
+        build(&mut items);
+        self.obj_builder.set("oneOf", items.items)
+    }
+
+    pub fn not<F>(&mut self, build: F) where F: FnOnce(&mut Builder) {
+        self.obj_builder.set("not", Builder::build(build).into_json())
+    }
+
+    pub fn build<F>(build: F) -> Builder where F: FnOnce(&mut Builder) {
+        let mut builder = Builder::new();
+        build(&mut builder);
+        builder
+    }
+
+    pub fn into_json(self) -> Value {
+        self.obj_builder.unwrap()
+    }
+}
+
+impl Serialize for Builder {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+       self.obj_builder.serialize(serializer)
+    }
+}
+
+pub fn schema<F>(build: F) -> Builder where F: FnOnce(&mut Builder) {
+    Builder::build(build)
+}
+
+pub fn schema_box(build: Box<Fn(&mut Builder) + Send>) -> Builder {
+    let mut builder = Builder::new();
+    build(&mut builder);
+    builder
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/errors.rs b/rustc_deps/vendor/valico/src/json_schema/errors.rs
new file mode 100644
index 0000000..d0895ea
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/errors.rs
@@ -0,0 +1,175 @@
+use std::error::{Error};
+use super::super::common::error::ValicoError;
+use serde_json::{Value, to_value};
+use serde::{Serialize, Serializer};
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct WrongType {
+    pub path: String,
+    pub detail: String
+}
+impl_err!(WrongType, "wrong_type", "Type of the value is wrong", +detail);
+impl_serialize!(WrongType);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct MultipleOf {
+    pub path: String
+}
+impl_err!(MultipleOf, "multiple_of", "Wrong number of the value");
+impl_serialize!(MultipleOf);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct Maximum {
+    pub path: String
+}
+impl_err!(Maximum, "maximum", "Maximum condition is not met");
+impl_serialize!(Maximum);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct Minimum {
+    pub path: String
+}
+impl_err!(Minimum, "minimum", "Minimum condition is not met");
+impl_serialize!(Minimum);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct MaxLength {
+    pub path: String
+}
+impl_err!(MaxLength, "max_length", "MaxLength condition is not met");
+impl_serialize!(MaxLength);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct MinLength {
+    pub path: String
+}
+impl_err!(MinLength, "min_length", "MinLength condition is not met");
+impl_serialize!(MinLength);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct Pattern {
+    pub path: String
+}
+impl_err!(Pattern, "pattern", "Pattern condition is not met");
+impl_serialize!(Pattern);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct MaxItems {
+    pub path: String
+}
+impl_err!(MaxItems, "max_items", "MaxItems condition is not met");
+impl_serialize!(MaxItems);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct MinItems {
+    pub path: String
+}
+impl_err!(MinItems, "min_items", "MinItems condition is not met");
+impl_serialize!(MinItems);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct UniqueItems {
+    pub path: String
+}
+impl_err!(UniqueItems, "unique_items", "UniqueItems condition is not met");
+impl_serialize!(UniqueItems);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct Items {
+    pub path: String,
+    pub detail: String
+}
+impl_err!(Items, "items", "Items condition is not met", +detail);
+impl_serialize!(Items);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct MaxProperties {
+    pub path: String
+}
+impl_err!(MaxProperties, "max_properties", "MaxProperties condition is not met");
+impl_serialize!(MaxProperties);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct MinProperties {
+    pub path: String
+}
+impl_err!(MinProperties, "min_properties", "MinProperties condition is not met");
+impl_serialize!(MinProperties);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct Required {
+    pub path: String
+}
+impl_err!(Required, "required", "This property is required");
+impl_serialize!(Required);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct Properties {
+    pub path: String,
+    pub detail: String
+}
+impl_err!(Properties, "properties", "Property conditions are not met", +detail);
+impl_serialize!(Properties);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct Enum {
+    pub path: String
+}
+impl_err!(Enum, "enum", "Enum conditions are not met");
+impl_serialize!(Enum);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct AnyOf {
+    pub path: String,
+    pub states: Vec<super::validators::ValidationState>
+}
+impl_err!(AnyOf, "any_of", "AnyOf conditions are not met");
+impl_serialize!(AnyOf, |err: &AnyOf, map: &mut ::serde_json::Map<String, Value>| {
+    map.insert("states".to_string(), to_value(&err.states).unwrap())
+});
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct OneOf {
+    pub path: String,
+    pub states: Vec<super::validators::ValidationState>
+}
+impl_err!(OneOf, "one_of", "OneOf conditions are not met");
+impl_serialize!(OneOf, |err: &OneOf, map: &mut ::serde_json::Map<String, Value>| {
+    map.insert("states".to_string(), to_value(&err.states).unwrap())
+});
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct Not {
+    pub path: String
+}
+impl_err!(Not, "not", "Not condition is not met");
+impl_serialize!(Not);
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub struct Format {
+    pub path: String,
+    pub detail: String
+}
+impl_err!(Format, "format", "Format is wrong", +detail);
+impl_serialize!(Format);
+
diff --git a/rustc_deps/vendor/valico/src/json_schema/helpers.rs b/rustc_deps/vendor/valico/src/json_schema/helpers.rs
new file mode 100644
index 0000000..851534c
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/helpers.rs
@@ -0,0 +1,113 @@
+use serde_json::{Value};
+use url::{Url};
+use url::percent_encoding;
+use uuid::{Uuid};
+
+use super::schema;
+
+pub fn generate_id() -> Url {
+    let uuid = Uuid::new_v4();
+    Url::parse(&format!("json-schema://{}", uuid)).unwrap()
+}
+
+/// http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-07
+pub fn encode(string: &str) -> String {
+    percent_encoding::percent_encode(
+        string
+            .replace("~", "~0")
+            .replace("/", "~1")
+            .replace("%", "%25")
+            .as_bytes(),
+        percent_encoding::QUERY_ENCODE_SET
+    ).to_string()
+}
+
+/// Encode and connect
+pub fn connect(strings: &[&str]) -> String {
+    strings.iter().map(|s| encode(s)).collect::<Vec<String>>().join("/")
+}
+
+pub fn parse_url_key(key: &str, obj: &Value) -> Result<Option<Url>, schema::SchemaError> {
+    match obj.get(key) {
+        Some(value) => {
+            match value.as_str() {
+                Some(string) => Url::parse(string)
+                                .map(|url| Some(url))
+                                .map_err(|err| schema::SchemaError::UrlParseError(err)),
+                None => Ok(None)
+            }
+        },
+        None => Ok(None)
+    }
+}
+
+pub fn parse_url_key_with_base(key: &str, obj: &Value, base: &Url) -> Result<Option<Url>, schema::SchemaError> {
+    match obj.get(key) {
+        Some(value) => {
+            match value.as_str() {
+                Some(string) => Url::options()
+                                .base_url(Some(base))
+                                .parse(string)
+                                .map(|url| Some(url))
+                                .map_err(|err| schema::SchemaError::UrlParseError(err)),
+                None => Ok(None)
+            }
+        },
+        None => Ok(None)
+    }
+}
+
+pub fn alter_fragment_path(mut url: Url, new_fragment: String) -> Url {
+
+    let normalized_fragment = if new_fragment.starts_with("/") {
+        &new_fragment[1..]
+    } else {
+        new_fragment.as_ref()
+    };
+
+    let result_fragment = match url.fragment() {
+        Some(ref fragment) if fragment.len() > 0 => {
+            if !fragment.starts_with("/") {
+                let mut result_fragment = "".to_string();
+                let mut fragment_parts = fragment.split("/").map(|s| s.to_string());
+                result_fragment.push_str("#");
+                result_fragment.push_str(fragment_parts.next().unwrap().as_ref());
+                result_fragment.push_str("/");
+                result_fragment.push_str(normalized_fragment.as_ref());
+                result_fragment
+            } else {
+                "/".to_string() + normalized_fragment
+            }
+        },
+        _ => "/".to_string() + normalized_fragment
+    };
+
+    url.set_fragment(Some(&result_fragment));
+    url
+}
+
+pub fn serialize_schema_path(url: &Url) -> (String, Option<String>) {
+    let mut url_without_fragment = url.clone();
+    url_without_fragment.set_fragment(None);
+    let mut url_str = url_without_fragment.into_string();
+
+    match url.fragment().as_ref() {
+        Some(fragment) if fragment.len() > 0 => {
+            if !fragment.starts_with("/") {
+                let fragment_parts = fragment.split("/").map(|s| s.to_string()).collect::<Vec<String>>();
+                url_str.push_str("#");
+                url_str.push_str(fragment_parts[0].as_ref());
+                let fragment = if fragment_parts.len() > 1 {
+                    Some("/".to_string() + fragment_parts[1..].join("/").as_ref())
+                } else {
+                    None
+                };
+                (url_str, fragment)
+            } else {
+                (url_str, Some(fragment.to_string()))
+            }
+
+        },
+        _ => (url_str, None)
+    }
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/dependencies.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/dependencies.rs
new file mode 100644
index 0000000..9ba0285
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/dependencies.rs
@@ -0,0 +1,141 @@
+use serde_json::{Value};
+use std::collections;
+
+use super::super::schema;
+use super::super::validators;
+use super::super::helpers;
+
+#[allow(missing_copy_implementations)]
+pub struct Dependencies;
+impl super::Keyword for Dependencies {
+    fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+        let deps = keyword_key_exists!(def, "dependencies");
+
+        if !deps.is_object() {
+            return Err(schema::SchemaError::Malformed {
+                path: ctx.fragment.join("/"),
+                detail: "The value of this keyword MUST be an object.".to_string()
+            })
+        }
+
+        let deps = deps.as_object().unwrap();
+        let mut items = collections::HashMap::new();
+
+        for (key, item) in deps.iter() {
+            if item.is_object() {
+
+                items.insert(key.clone(), validators::dependencies::DepKind::Schema(
+                    helpers::alter_fragment_path(ctx.url.clone(), [
+                        ctx.escaped_fragment().as_ref(),
+                        "dependencies",
+                        helpers::encode(key).as_ref()
+                    ].join("/"))
+                ));
+
+            } else if item.is_array() {
+
+                let item = item.as_array().unwrap();
+
+                if item.len() == 0 {
+                    return Err(schema::SchemaError::Malformed {
+                        path: ctx.fragment.join("/"),
+                        detail: "If the value is an array, it MUST have at least one element.".to_string()
+                    })
+                }
+
+                let mut keys = vec![];
+
+                for key in item.iter() {
+                    if key.is_string() {
+                        keys.push(key.as_str().unwrap().to_string())
+                    } else {
+                        return Err(schema::SchemaError::Malformed {
+                            path: ctx.fragment.join("/"),
+                            detail: "Each element MUST be a string, and elements in the array MUST be unique.".to_string()
+                        })
+                    }
+                }
+
+                items.insert(key.clone(), validators::dependencies::DepKind::Property(
+                    keys
+                ));
+
+            } else {
+                return Err(schema::SchemaError::Malformed {
+                    path: ctx.fragment.join("/"),
+                    detail: "Each value of this object MUST be either an object or an array.".to_string()
+                })
+            }
+        }
+
+        Ok(Some(Box::new(validators::Dependencies {
+            items: items
+        })))
+
+    }
+}
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use jsonway;
+
+#[test]
+fn validate_dependencies() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.dependencies(|deps| {
+            deps.schema("isbn", |isbn| {
+                isbn.required(vec!["price".to_string()]);
+                isbn.properties(|props| {
+                    props.insert("price", |price| {
+                        price.multiple_of(5f64);
+                    })
+                })
+            });
+            deps.property("item_id", vec!["item_name".to_string()]);
+        });
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("isbn", "some_isbn".to_string());
+    }).unwrap()).is_valid(), false);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("isbn", "some_isbn".to_string());
+        obj.set("price", 773);
+    }).unwrap()).is_valid(), false);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("isbn", "some_isbn".to_string());
+        obj.set("price", 775);
+    }).unwrap()).is_valid(), true);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("item_id", "some_id".to_string());
+    }).unwrap()).is_valid(), false);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("item_id", "some_id".to_string());
+        obj.set("item_name", "some_name".to_string());
+    }).unwrap()).is_valid(), true);
+
+}
+
+#[test]
+fn malformed() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.object("dependencies", |deps| {
+            deps.set("isbn", 10);
+        });
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.object("dependencies", |deps| {
+            deps.array("item_id", |item_id| {
+                item_id.push(10)
+            });
+        });
+    }).unwrap(), true).is_err());
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/enum_.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/enum_.rs
new file mode 100644
index 0000000..6b6d1bc
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/enum_.rs
@@ -0,0 +1,66 @@
+use serde_json::{Value};
+
+use super::super::schema;
+use super::super::validators;
+
+#[allow(missing_copy_implementations)]
+pub struct Enum;
+impl super::Keyword for Enum {
+    fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+        let enum_ = keyword_key_exists!(def, "enum");
+
+        if enum_.is_array() {
+            let enum_ = enum_.as_array().unwrap();
+
+            if enum_.len() == 0 {
+                return Err(schema::SchemaError::Malformed {
+                    path: ctx.fragment.join("/"),
+                    detail: "This array MUST have at least one element.".to_string()
+                })
+            }
+
+            Ok(Some(Box::new(validators::Enum {
+                items: enum_.clone()
+            })))
+        } else {
+            Err(schema::SchemaError::Malformed {
+                path: ctx.fragment.join("/"),
+                detail: "The value of this keyword MUST be an array.".to_string()
+            })
+        }
+    }
+}
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use jsonway;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use serde_json::to_value;
+
+#[test]
+fn validate() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.enum_(|items| {
+            items.push("prop1".to_string());
+            items.push("prop2".to_string());
+        })
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&"prop1").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"prop2").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"prop3").unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&1).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn malformed() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.array("enum", |_| {});
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.object("enum", |_| {});
+    }).unwrap(), true).is_err());
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/format.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/format.rs
new file mode 100644
index 0000000..ef66383
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/format.rs
@@ -0,0 +1,151 @@
+use serde_json::{Value};
+use std::collections;
+use regex;
+
+use super::super::schema;
+use super::super::validators;
+
+pub type FormatBuilders = collections::HashMap<String, Box<super::Keyword + Send + Sync>>;
+
+lazy_static! {
+    static ref DATE_TIME_REGEX: regex::Regex = {
+       regex::Regex::new(r"^(?i)(\d\d\d\d)-(\d\d)-(\d\d)T(\d\d):(\d\d):(\d\d)(\.\d+)??([+-]\d\d:?\d\d|[A-Z]+)$").unwrap()
+    };
+}
+
+fn default_formats() -> FormatBuilders  {
+    let mut map: FormatBuilders = collections::HashMap::new();
+
+    let date_time_builder = Box::new(|_def: &Value, _ctx: &schema::WalkContext| {
+        Ok(Some(Box::new(validators::Pattern{ regex: DATE_TIME_REGEX.clone() }) as validators::BoxedValidator))
+    });
+    map.insert("date-time".to_string(), date_time_builder);
+
+    let ipv4_builder = Box::new(|_def: &Value, _ctx: &schema::WalkContext| {
+        Ok(Some(Box::new(validators::formats::Ipv4) as validators::BoxedValidator))
+    });
+    map.insert("ipv4".to_string(), ipv4_builder);
+
+    let ipv6_builder = Box::new(|_def: &Value, _ctx: &schema::WalkContext| {
+        Ok(Some(Box::new(validators::formats::Ipv6) as validators::BoxedValidator))
+    });
+    map.insert("ipv6".to_string(), ipv6_builder);
+
+    let uri_builder = Box::new(|_def: &Value, _ctx: &schema::WalkContext| {
+        Ok(Some(Box::new(validators::formats::Uri) as validators::BoxedValidator))
+    });
+    map.insert("uri".to_string(), uri_builder);
+
+    let uuid_builder = Box::new(|_def: &Value, _ctx: &schema::WalkContext| {
+        Ok(Some(Box::new(validators::formats::Uuid) as validators::BoxedValidator))
+    });
+    map.insert("uuid".to_string(), uuid_builder);
+
+    map
+}
+
+#[allow(missing_copy_implementations)]
+pub struct Format {
+    pub formats: FormatBuilders
+}
+
+impl Format {
+    pub fn new() -> Format {
+        Format {
+            formats: default_formats()
+        }
+    }
+
+    pub fn with<F>(build_formats: F) -> Format where F: FnOnce(&mut FormatBuilders) {
+        let mut formats = default_formats();
+        build_formats(&mut formats);
+        Format {
+            formats: formats
+        }
+    }
+}
+
+impl super::Keyword for Format {
+    fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+        let format = keyword_key_exists!(def, "format");
+
+        if format.is_string() {
+            let format = format.as_str().unwrap();
+            match self.formats.get(format) {
+                Some(keyword) => {
+                    keyword.compile(def, ctx)
+                },
+                None => {
+                    Ok(None)
+                }
+            }
+        } else {
+            Err(schema::SchemaError::Malformed {
+                path: ctx.fragment.join("/"),
+                detail: "The value of format MUST be a string".to_string()
+            })
+        }
+    }
+}
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use serde_json::to_value;
+
+#[test]
+fn validate_date_time() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.format("date-time");
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&"2015-01-20T17:35:20-0800").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"1944-06-06T04:04:00Z").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"Tue, 20 Jan 2015 17:35:20 -0800").unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_ipv4() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.format("ipv4");
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&"127.0.0.1").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"8.8.8.8").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"::::0.0.0.0").unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_ipv6() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.format("ipv6");
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&"FE80:0000:0000:0000:0202:B3FF:FE1E:8329").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"127.0.0.1").unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_uri() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.format("uri");
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&"http://example.com").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"some-wrong").unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_uuid() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.format("uuid");
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&"2f5a2593-7481-49e2-9911-8fe2ad069aac").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"2f5a2593748149e299118fe2ad069aac").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"2f5a2593-7481-49e2-9911-8fe2ad06").unwrap()).is_valid(), false);
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/items.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/items.rs
new file mode 100644
index 0000000..6224a90
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/items.rs
@@ -0,0 +1,182 @@
+use serde_json::{Value};
+
+use super::super::schema;
+use super::super::validators;
+use super::super::helpers;
+
+#[allow(missing_copy_implementations)]
+pub struct Items;
+impl super::Keyword for Items {
+    fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+        let maybe_items = def.get("items");
+        let maybe_additional = def.get("additionalItems");
+
+        if !(maybe_items.is_some() || maybe_additional.is_some()) {
+            return Ok(None)
+        }
+
+        let items = if maybe_items.is_some() {
+            let items_val = maybe_items.unwrap();
+            Some(if items_val.is_object() {
+
+                validators::items::ItemsKind::Schema(
+                    helpers::alter_fragment_path(ctx.url.clone(), [
+                        ctx.escaped_fragment().as_ref(),
+                        "items"
+                    ].join("/"))
+                )
+
+            } else if items_val.is_array() {
+
+                let mut schemas = vec![];
+                for (idx, item) in items_val.as_array().unwrap().iter().enumerate() {
+                    if item.is_object() {
+                        schemas.push(
+                            helpers::alter_fragment_path(ctx.url.clone(), [
+                                ctx.escaped_fragment().as_ref(),
+                                "items",
+                                idx.to_string().as_ref()
+                            ].join("/"))
+                        )
+                    } else {
+                        return Err(schema::SchemaError::Malformed {
+                            path: ctx.fragment.join("/"),
+                            detail: "Items of this array MUST be objects".to_string()
+                        })
+                    }
+                }
+
+                validators::items::ItemsKind::Array(schemas)
+
+            } else {
+
+                return Err(schema::SchemaError::Malformed {
+                    path: ctx.fragment.join("/"),
+                    detail: "`items` must be an object or an array".to_string()
+                })
+
+            })
+        } else {
+            None
+        };
+
+        let additional_items = if maybe_additional.is_some() {
+            let additional_val = maybe_additional.unwrap();
+            Some(if additional_val.is_boolean() {
+
+                validators::items::AdditionalKind::Boolean(additional_val.as_bool().unwrap())
+
+            } else if additional_val.is_object() {
+
+                validators::items::AdditionalKind::Schema(
+                    helpers::alter_fragment_path(ctx.url.clone(), [
+                        ctx.escaped_fragment().as_ref(),
+                        "additionalItems"
+                    ].join("/"))
+                )
+
+            } else {
+
+                return Err(schema::SchemaError::Malformed {
+                    path: ctx.fragment.join("/"),
+                    detail: "`additionalItems` must be a boolean or an object".to_string()
+                })
+
+            })
+        } else {
+            None
+        };
+
+        Ok(Some(Box::new(validators::Items {
+            items: items,
+            additional: additional_items
+        })))
+
+    }
+}
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use serde_json::to_value;
+
+#[test]
+fn validate_items_with_schema() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.items_schema(|items| {
+            items.minimum(5f64, false);
+            items.maximum(10f64, false);
+        });
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&[5,6,7,8,9,10]).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&[4,5,6,7,8,9,10]).unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&[5,6,7,8,9,10,11]).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_items_with_array_of_schemes() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.items_array(|items| {
+            items.push(|item| {
+                item.minimum(1f64, false);
+                item.maximum(3f64, false);
+            });
+            items.push(|item| {
+                item.minimum(3f64, false);
+                item.maximum(6f64, false);
+            });
+        })
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&[1]).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&[1,3]).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&[1,3,100]).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&[4,3]).unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&[1,7]).unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&[4,7]).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_items_with_array_of_schemes_with_additional_bool() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.items_array(|items| {
+            items.push(|item| {
+                item.minimum(1f64, false);
+                item.maximum(3f64, false);
+            });
+            items.push(|item| {
+                item.minimum(3f64, false);
+                item.maximum(6f64, false);
+            });
+        });
+        s.additional_items(false);
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&[1,3,100]).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_items_with_array_of_schemes_with_additional_schema() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.items_array(|items| {
+            items.push(|item| {
+                item.minimum(1f64, false);
+                item.maximum(3f64, false);
+            });
+            items.push(|item| {
+                item.minimum(3f64, false);
+                item.maximum(6f64, false);
+            });
+        });
+        s.additional_items_schema(|add| {
+           add.maximum(100f64, false)
+        });
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&[1,3,100]).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&[1,3,101]).unwrap()).is_valid(), false);
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/maxmin.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/maxmin.rs
new file mode 100644
index 0000000..4a05963
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/maxmin.rs
@@ -0,0 +1,154 @@
+use serde_json::{Value};
+
+use super::super::schema;
+use super::super::validators;
+
+macro_rules! kw_minmax{
+    ($name:ident, $keyword:expr, $exclusive:expr) => {
+        #[allow(missing_copy_implementations)]
+        pub struct $name;
+        impl super::Keyword for $name {
+            fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+                let maybe_value = def.get($keyword);
+                let exclusive = def.get($exclusive);
+
+                if exclusive.is_some() {
+                    if !maybe_value.is_some() {
+                        return Err(schema::SchemaError::Malformed {
+                            path: ctx.fragment.join("/"),
+                            detail: "`exclusiveMinimum/exclusiveMaximum` can't go without minimum/maximum".to_string()
+                        })
+                    }
+                }
+
+                if maybe_value.is_some() {
+                    let value = maybe_value.unwrap();
+                    if value.is_number() {
+                        let value = value.as_f64().unwrap();
+                        Ok(Some(Box::new(validators::$name {
+                            number: value,
+                            exclusive: exclusive.is_some() &&
+                                       try!(exclusive.unwrap()
+                                            .as_bool()
+                                            .ok_or_else(||
+                                                schema::SchemaError::Malformed {
+                                                    path: ctx.fragment.join("/"),
+                                                    detail: "`exclusiveMaximum/exclusiveMaximum` must be boolean".to_string()
+                                                }
+                                            ))
+                        })))
+                    } else {
+                        Err(schema::SchemaError::Malformed {
+                            path: ctx.fragment.join("/"),
+                            detail: "the `minimum/maximum` value must be a number".to_string()
+                        })
+                    }
+                } else {
+                    Ok(None)
+                }
+            }
+        }
+    }
+}
+
+kw_minmax!(Minimum, "minimum", "exclusiveMinimum");
+kw_minmax!(Maximum, "maximum", "exclusiveMaximum");
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use jsonway;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use serde_json::to_value;
+
+#[test]
+fn validate_maximum() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.maximum(10f64, false);
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&9).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&10).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&11).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_exclusive_maximum() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.maximum(10f64, true);
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&9).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&10).unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&11).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn mailformed_maximum() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("maximum", true);
+    }).unwrap(), true).is_err());
+}
+
+#[test]
+fn mailformed_exclusive_maximum() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("exclusiveMaximum", true);
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("maximum", 10);
+        schema.set("exclusiveMaximum", "".to_string());
+    }).unwrap(), true).is_err());
+}
+
+#[test]
+fn validate_minumum() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.minimum(10f64, false);
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&9).unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&10).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&11).unwrap()).is_valid(), true);
+}
+
+#[test]
+fn validate_exclusive_minimum() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.minimum(10f64, true);
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&9).unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&10).unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&11).unwrap()).is_valid(), true);
+}
+
+#[test]
+fn mailformed_minumum() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("minimum", true);
+    }).unwrap(), true).is_err());
+}
+
+#[test]
+fn mailformed_exclusive_minumum() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("exclusiveMinimum", true);
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("minimum", 10);
+        schema.set("exclusiveMinimum", "".to_string());
+    }).unwrap(), true).is_err());
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/maxmin_items.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/maxmin_items.rs
new file mode 100644
index 0000000..417e07c
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/maxmin_items.rs
@@ -0,0 +1,70 @@
+use serde_json::{Value};
+
+use super::super::schema;
+use super::super::validators;
+
+kw_minmax_integer!(MaxItems, "maxItems");
+kw_minmax_integer!(MinItems, "minItems");
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use jsonway;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use serde_json::to_value;
+
+#[test]
+fn validate_max_items() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.max_items(5u64);
+    }).into_json(), true).ok().unwrap();;
+
+    assert_eq!(schema.validate(&to_value(&[1,2,3,4]).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&[1,2,3,4,5]).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&[1,2,3,4,5,6]).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn malformed_max_items() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("maxItems", to_value(&-1).unwrap());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("maxItems", to_value(&"").unwrap());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("maxItems", to_value(&1.1).unwrap());
+    }).unwrap(), true).is_err());
+}
+
+#[test]
+fn validate_min_items() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.min_items(5u64);
+    }).into_json(), true).ok().unwrap();;
+
+    assert_eq!(schema.validate(&to_value(&[1,2,3,4]).unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&[1,2,3,4,5]).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&[1,2,3,4,5,6]).unwrap()).is_valid(), true);
+}
+
+#[test]
+fn malformed_min_items() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("minItems", to_value(&-1).unwrap());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("minItems", to_value(&"").unwrap());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("minItems", to_value(&1.1).unwrap());
+    }).unwrap(), true).is_err());
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/maxmin_length.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/maxmin_length.rs
new file mode 100644
index 0000000..520ef49
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/maxmin_length.rs
@@ -0,0 +1,101 @@
+use serde_json::{Value};
+
+use super::super::schema;
+use super::super::validators;
+
+macro_rules! kw_minmax_integer{
+    ($name:ident, $keyword:expr) => {
+        #[allow(missing_copy_implementations)]
+        pub struct $name;
+        impl super::Keyword for $name {
+            fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+                let length = keyword_key_exists!(def, $keyword);
+
+                if length.is_number() {
+                    let length_val = length.as_f64().unwrap();
+                    if length_val >= 0f64 && length_val.fract() == 0f64 {
+                        Ok(Some(Box::new(validators::$name {
+                            length: length_val as u64
+                        })))
+                    } else {
+                        Err(schema::SchemaError::Malformed {
+                            path: ctx.fragment.join("/"),
+                            detail: "The value MUST be a positive integer or zero".to_string()
+                        })
+                    }
+                } else {
+                    Err(schema::SchemaError::Malformed {
+                        path: ctx.fragment.join("/"),
+                        detail: "The value MUST be a positive integer or zero".to_string()
+                    })
+                }
+            }
+        }
+    }
+}
+
+kw_minmax_integer!(MaxLength, "maxLength");
+kw_minmax_integer!(MinLength, "minLength");
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use jsonway;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use serde_json::to_value;
+
+#[test]
+fn validate_max_length() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.max_length(5u64);
+    }).into_json(), true).ok().unwrap();;
+
+    assert_eq!(schema.validate(&to_value(&"1234").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"12345").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"123456").unwrap()).is_valid(), false);
+}
+
+#[test]
+fn malformed_max_length() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("maxLength", to_value(&-1).unwrap());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("maxLength", to_value(&"").unwrap());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("maxLength", to_value(&1.1).unwrap());
+    }).unwrap(), true).is_err());
+}
+
+#[test]
+fn validate_min_length() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.min_length(5u64);
+    }).into_json(), true).ok().unwrap();;
+
+    assert_eq!(schema.validate(&to_value(&"1234").unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&"12345").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"123456").unwrap()).is_valid(), true);
+}
+
+#[test]
+fn malformed_min_length() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("minLength", to_value(&-1).unwrap());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("minLength", to_value(&"").unwrap());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("minLength", to_value(&1.1).unwrap());
+    }).unwrap(), true).is_err());
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/maxmin_properties.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/maxmin_properties.rs
new file mode 100644
index 0000000..39a9905
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/maxmin_properties.rs
@@ -0,0 +1,92 @@
+use serde_json::{Value};
+
+use super::super::schema;
+use super::super::validators;
+
+kw_minmax_integer!(MaxProperties, "maxProperties");
+kw_minmax_integer!(MinProperties, "minProperties");
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use jsonway;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use serde_json::to_value;
+
+#[test]
+fn validate_max_properties() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.max_properties(2u64);
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("p1", 0);
+    }).unwrap()).is_valid(), true);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("p1", 0);
+        obj.set("p2", 0);
+    }).unwrap()).is_valid(), true);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("p1", 0);
+        obj.set("p2", 0);
+        obj.set("p3", 0);
+    }).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn malformed_max_properties() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("maxProperties", to_value(&-1).unwrap());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("maxProperties", to_value(&"").unwrap());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("maxProperties", to_value(&1.1).unwrap());
+    }).unwrap(), true).is_err());
+}
+
+#[test]
+fn validate_min_properties() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.min_properties(2u64);
+    }).into_json(), true).ok().unwrap();;
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("p1", 0);
+    }).unwrap()).is_valid(), false);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("p1", 0);
+        obj.set("p2", 0);
+    }).unwrap()).is_valid(), true);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("p1", 0);
+        obj.set("p2", 0);
+        obj.set("p3", 0);
+    }).unwrap()).is_valid(), true);
+}
+
+#[test]
+fn malformed_min_properties() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("minProperties", to_value(&-1).unwrap());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("minProperties", to_value(&"").unwrap());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("minProperties", to_value(&1.1).unwrap());
+    }).unwrap(), true).is_err());
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/mod.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/mod.rs
new file mode 100644
index 0000000..4402acd
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/mod.rs
@@ -0,0 +1,113 @@
+use serde_json::{Value};
+use std::fmt;
+use std::rc;
+use std::collections;
+use std::any;
+
+use super::schema;
+use super::validators;
+
+pub type KeywordResult = Result<Option<validators::BoxedValidator>, schema::SchemaError>;
+pub type KeywordPair = (Vec<&'static str>, Box<Keyword + 'static>);
+pub type KeywordPairs = Vec<KeywordPair>;
+pub type KeywordMap = collections::HashMap<&'static str, rc::Rc<KeywordConsumer>>;
+
+pub trait Keyword: Sync + any::Any {
+    fn compile(&self, &Value, &schema::WalkContext) -> KeywordResult;
+}
+
+impl<T: 'static + Send + Sync + any::Any> Keyword for T where T: Fn(&Value, &schema::WalkContext) -> KeywordResult {
+    fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> KeywordResult {
+        self(def, ctx)
+    }
+}
+
+impl fmt::Debug for Keyword + 'static {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.write_str("<keyword>")
+    }
+}
+
+macro_rules! keyword_key_exists {
+    ($val:expr, $key:expr) => {{
+        let maybe_val = $val.get($key);
+        if maybe_val.is_none() {
+            return Ok(None)
+        } else {
+           maybe_val.unwrap()
+        }
+    }}
+}
+
+pub mod multiple_of;
+pub mod maxmin;
+#[macro_use]
+pub mod maxmin_length;
+pub mod maxmin_items;
+pub mod pattern;
+pub mod unique_items;
+pub mod items;
+pub mod maxmin_properties;
+pub mod required;
+pub mod properties;
+pub mod dependencies;
+pub mod enum_;
+pub mod type_;
+pub mod of;
+pub mod ref_;
+pub mod not;
+pub mod format;
+
+pub fn default() -> KeywordMap {
+    let mut map = collections::HashMap::new();
+
+    decouple_keyword((vec!["multipleOf"], Box::new(multiple_of::MultipleOf)), &mut map);
+    decouple_keyword((vec!["maximum", "exclusiveMaximum"], Box::new(maxmin::Maximum)), &mut map);
+    decouple_keyword((vec!["minimum", "exclusiveMinimum"], Box::new(maxmin::Minimum)), &mut map);
+    decouple_keyword((vec!["maxLength"], Box::new(maxmin_length::MaxLength)), &mut map);
+    decouple_keyword((vec!["minLength"], Box::new(maxmin_length::MinLength)), &mut map);
+    decouple_keyword((vec!["pattern"], Box::new(pattern::Pattern)), &mut map);
+    decouple_keyword((vec!["maxItems"], Box::new(maxmin_items::MaxItems)), &mut map);
+    decouple_keyword((vec!["minItems"], Box::new(maxmin_items::MinItems)), &mut map);
+    decouple_keyword((vec!["uniqueItems"], Box::new(unique_items::UniqueItems)), &mut map);
+    decouple_keyword((vec!["items", "additionalItems"], Box::new(items::Items)), &mut map);
+    decouple_keyword((vec!["maxProperties"], Box::new(maxmin_properties::MaxProperties)), &mut map);
+    decouple_keyword((vec!["minProperties"], Box::new(maxmin_properties::MinProperties)), &mut map);
+    decouple_keyword((vec!["required"], Box::new(required::Required)), &mut map);
+    decouple_keyword((vec!["properties", "additionalProperties", "patternProperties"], Box::new(properties::Properties)), &mut map);
+    decouple_keyword((vec!["dependencies"], Box::new(dependencies::Dependencies)), &mut map);
+    decouple_keyword((vec!["enum"], Box::new(enum_::Enum)), &mut map);
+    decouple_keyword((vec!["type"], Box::new(type_::Type)), &mut map);
+    decouple_keyword((vec!["allOf"], Box::new(of::AllOf)), &mut map);
+    decouple_keyword((vec!["anyOf"], Box::new(of::AnyOf)), &mut map);
+    decouple_keyword((vec!["oneOf"], Box::new(of::OneOf)), &mut map);
+    decouple_keyword((vec!["$ref"], Box::new(ref_::Ref)), &mut map);
+    decouple_keyword((vec!["not"], Box::new(not::Not)), &mut map);
+
+    map
+}
+
+#[derive(Debug)]
+pub struct KeywordConsumer {
+    pub keys: Vec<&'static str>,
+    pub keyword: Box<Keyword + 'static>
+}
+
+impl KeywordConsumer {
+    pub fn consume(&self, set: &mut collections::HashSet<&str>) {
+        for key in self.keys.iter() {
+            if set.contains(key) {
+                set.remove(key);
+            }
+        }
+    }
+}
+
+pub fn decouple_keyword(keyword_pair: KeywordPair,
+                        map: &mut KeywordMap) {
+    let (keys, keyword) = keyword_pair;
+    let consumer = rc::Rc::new(KeywordConsumer { keys: keys.clone(), keyword: keyword });
+    for key in keys.iter() {
+        map.insert(key, consumer.clone());
+    }
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/multiple_of.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/multiple_of.rs
new file mode 100644
index 0000000..42d3322
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/multiple_of.rs
@@ -0,0 +1,65 @@
+use serde_json::{Value};
+
+use super::super::schema;
+use super::super::validators;
+
+#[allow(missing_copy_implementations)]
+pub struct MultipleOf;
+impl super::Keyword for MultipleOf {
+    fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+        let multiple_of = keyword_key_exists!(def, "multipleOf");
+
+        if multiple_of.is_number() {
+            let multiple_of = multiple_of.as_f64().unwrap();
+            if multiple_of > 0f64 {
+                Ok(Some(Box::new(validators::MultipleOf {
+                    number: multiple_of
+                })))
+            } else {
+                Err(schema::SchemaError::Malformed {
+                    path: ctx.fragment.join("/"),
+                    detail: "The value of multipleOf MUST be strictly greater than 0".to_string()
+                })
+            }
+        } else {
+            Err(schema::SchemaError::Malformed {
+                path: ctx.fragment.join("/"),
+                detail: "The value of multipleOf MUST be a JSON number".to_string()
+            })
+        }
+    }
+}
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use jsonway;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use serde_json::to_value;
+
+#[test]
+fn validate() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.multiple_of(3.5f64);
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&"").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&7).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&6).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn malformed() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("multipleOf", "".to_string());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("multipleOf", to_value(&0).unwrap());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("multipleOf", to_value(&-1).unwrap());
+    }).unwrap(), true).is_err());
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/not.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/not.rs
new file mode 100644
index 0000000..4146aa5
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/not.rs
@@ -0,0 +1,27 @@
+use serde_json::{Value};
+
+use super::super::schema;
+use super::super::validators;
+use super::super::helpers;
+
+#[allow(missing_copy_implementations)]
+pub struct Not;
+impl super::Keyword for Not {
+    fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+        let not = keyword_key_exists!(def, "not");
+
+        if not.is_object() {
+            Ok(Some(Box::new(validators::Not {
+                url: helpers::alter_fragment_path(ctx.url.clone(), [
+                        ctx.escaped_fragment().as_ref(),
+                        "not"
+                     ].join("/"))
+            })))
+        } else {
+            Err(schema::SchemaError::Malformed {
+                path: ctx.fragment.join("/"),
+                detail: "The value of `not` MUST be an object".to_string()
+            })
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/of.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/of.rs
new file mode 100644
index 0000000..966652f
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/of.rs
@@ -0,0 +1,122 @@
+use serde_json::{Value};
+
+use super::super::schema;
+use super::super::validators;
+use super::super::helpers;
+
+macro_rules! of_keyword{
+    ($name:ident, $kw:expr) => {
+
+        #[allow(missing_copy_implementations)]
+        pub struct $name;
+        impl super::Keyword for $name {
+            fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+                let of = keyword_key_exists!(def, $kw);
+
+                if of.is_array() {
+                    let of = of.as_array().unwrap();
+
+                    if of.len() == 0 {
+                        return Err(schema::SchemaError::Malformed {
+                            path: ctx.fragment.join("/"),
+                            detail: "This array MUST have at least one element.".to_string()
+                        })
+                    }
+
+                    let mut schemes = vec![];
+                    for (idx, scheme) in of.iter().enumerate() {
+                        if scheme.is_object() {
+                            schemes.push(
+                                helpers::alter_fragment_path(ctx.url.clone(), [
+                                    ctx.escaped_fragment().as_ref(),
+                                    $kw,
+                                    idx.to_string().as_ref()
+                                ].join("/"))
+                            )
+                        } else {
+                            return Err(schema::SchemaError::Malformed {
+                                path: ctx.fragment.join("/"),
+                                detail: "Elements of the array MUST be objects.".to_string()
+                            })
+                        }
+                    }
+
+                    Ok(Some(Box::new(validators::$name {
+                        schemes: schemes
+                    })))
+                } else {
+                    Err(schema::SchemaError::Malformed {
+                        path: ctx.fragment.join("/"),
+                        detail: "The value of this keyword MUST be an array.".to_string()
+                    })
+                }
+            }
+        }
+
+    }
+}
+
+of_keyword!(AllOf, "allOf");
+of_keyword!(AnyOf, "anyOf");
+of_keyword!(OneOf, "oneOf");
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use serde_json::to_value;
+
+#[test]
+fn validate_all_of() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.all_of(|all_of| {
+            all_of.push(|schema| {
+                schema.minimum(5f64, false);
+            });
+            all_of.push(|schema| {
+                schema.maximum(10f64, false);
+            });
+        });
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&7).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&4).unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&11).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_any_of() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.any_of(|all_of| {
+            all_of.push(|schema| {
+                schema.maximum(5f64, false);
+            });
+            all_of.push(|schema| {
+                schema.maximum(10f64, false);
+            });
+        });
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&5).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&10).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&11).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_one_of() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.one_of(|all_of| {
+            all_of.push(|schema| {
+                schema.maximum(5f64, false);
+            });
+            all_of.push(|schema| {
+                schema.maximum(10f64, false);
+            });
+        });
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&5).unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&6).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&11).unwrap()).is_valid(), false);
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/pattern.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/pattern.rs
new file mode 100644
index 0000000..af47f46
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/pattern.rs
@@ -0,0 +1,61 @@
+use serde_json::{Value};
+use regex;
+
+use super::super::schema;
+use super::super::validators;
+
+#[allow(missing_copy_implementations)]
+pub struct Pattern;
+impl super::Keyword for Pattern {
+    fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+        let pattern = keyword_key_exists!(def, "pattern");
+
+        if pattern.is_string() {
+            let pattern_val = pattern.as_str().unwrap();
+            match regex::Regex::new(pattern_val) {
+                Ok(re) => Ok(Some(Box::new(validators::Pattern {
+                    regex: re
+                }))),
+                Err(err) => Err(schema::SchemaError::Malformed {
+                    path: ctx.fragment.join("/"),
+                    detail: format!("The value of pattern MUST be a valid RegExp, but {:?}", err)
+                }),
+            }
+        } else {
+            Err(schema::SchemaError::Malformed {
+                path: ctx.fragment.join("/"),
+                detail: "The value of pattern MUST be a string".to_string()
+            })
+        }
+    }
+}
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use jsonway;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use serde_json::to_value;
+
+#[test]
+fn validate() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.pattern(r"abb.*");
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value("abb").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value("abbd").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value("abd").unwrap()).is_valid(), false);
+}
+
+#[test]
+fn mailformed() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("pattern", "([]".to_string());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("pattern", 2);
+    }).unwrap(), true).is_err());
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/properties.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/properties.rs
new file mode 100644
index 0000000..2da9dc7
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/properties.rs
@@ -0,0 +1,318 @@
+use std::collections;
+use regex;
+use serde_json::{Value};
+
+use super::super::schema;
+use super::super::validators;
+use super::super::helpers;
+
+#[allow(missing_copy_implementations)]
+pub struct Properties;
+impl super::Keyword for Properties {
+    fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+        let maybe_properties = def.get("properties");
+        let maybe_additional = def.get("additionalProperties");
+        let maybe_pattern = def.get("patternProperties");
+
+        if maybe_properties.is_none() && maybe_additional.is_none() && maybe_pattern.is_none() {
+            return Ok(None)
+        }
+
+        let properties = if maybe_properties.is_some() {
+            let properties = maybe_properties.unwrap();
+            if properties.is_object() {
+                let mut schemes = collections::HashMap::new();
+                let properties = properties.as_object().unwrap();
+                for (key, value) in properties.iter() {
+                    if value.is_object() {
+                        schemes.insert(key.to_string(),
+                            helpers::alter_fragment_path(ctx.url.clone(), [
+                                ctx.escaped_fragment().as_ref(),
+                                "properties",
+                                helpers::encode(key).as_ref()
+                            ].join("/"))
+                        );
+                    } else {
+                        return Err(schema::SchemaError::Malformed {
+                            path: ctx.fragment.join("/"),
+                            detail: "Each value of this object MUST be an object".to_string()
+                        })
+                    }
+                }
+                schemes
+            } else {
+                return Err(schema::SchemaError::Malformed {
+                    path: ctx.fragment.join("/"),
+                    detail: "The value of `properties` MUST be an object.".to_string()
+                })
+            }
+        } else {
+            collections::HashMap::new()
+        };
+
+        let additional_properties = if maybe_additional.is_some() {
+            let additional_val = maybe_additional.unwrap();
+            if additional_val.is_boolean() {
+
+                validators::properties::AdditionalKind::Boolean(additional_val.as_bool().unwrap())
+
+            } else if additional_val.is_object() {
+
+                validators::properties::AdditionalKind::Schema(
+                    helpers::alter_fragment_path(ctx.url.clone(), [
+                        ctx.escaped_fragment().as_ref(),
+                        "additionalProperties"
+                    ].join("/"))
+                )
+
+            } else {
+
+                return Err(schema::SchemaError::Malformed {
+                    path: ctx.fragment.join("/"),
+                    detail: "The value of `additionalProperties` MUST be a boolean or an object.".to_string()
+                })
+
+            }
+        } else {
+            validators::properties::AdditionalKind::Boolean(true)
+        };
+
+        let patterns = if maybe_pattern.is_some() {
+            let pattern = maybe_pattern.unwrap();
+            if pattern.is_object() {
+                let pattern = pattern.as_object().unwrap();
+                let mut patterns = vec![];
+
+                for (key, value) in pattern.iter() {
+                    if value.is_object() {
+
+                        match regex::Regex::new(key.as_ref()) {
+                            Ok(regex) => {
+                                let url = helpers::alter_fragment_path(ctx.url.clone(), [
+                                    ctx.escaped_fragment().as_ref(),
+                                    "patternProperties",
+                                    helpers::encode(key).as_ref()
+                                ].join("/"));
+                                patterns.push((regex, url));
+                            },
+                            Err(_) => {
+                                return Err(schema::SchemaError::Malformed {
+                                    path: ctx.fragment.join("/"),
+                                    detail: "Each property name of this object SHOULD be a valid regular expression.".to_string()
+                                })
+                            }
+                        }
+
+                    } else {
+                        return Err(schema::SchemaError::Malformed {
+                            path: ctx.fragment.join("/"),
+                            detail: "Each value of this object MUST be an object".to_string()
+                        })
+                    }
+                }
+
+                patterns
+
+            } else {
+                return Err(schema::SchemaError::Malformed {
+                    path: ctx.fragment.join("/"),
+                    detail: "The value of `patternProperties` MUST be an object".to_string()
+                })
+            }
+        } else { vec![] };
+
+        Ok(Some(Box::new(validators::Properties {
+            properties: properties,
+            additional: additional_properties,
+            patterns: patterns
+        })))
+
+    }
+}
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use jsonway;
+
+#[test]
+fn validate_properties() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.properties(|props| {
+            props.insert("prop1", |prop1| {
+                prop1.maximum(10f64, false);
+            });
+            props.insert("prop2", |prop2| {
+                prop2.minimum(11f64, false);
+            });
+        });
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop1", 10);
+        obj.set("prop2", 11);
+    }).unwrap()).is_valid(), true);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop1", 11);
+        obj.set("prop2", 11);
+    }).unwrap()).is_valid(), false);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop1", 10);
+        obj.set("prop2", 10);
+    }).unwrap()).is_valid(), false);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop1", 10);
+        obj.set("prop2", 11);
+        obj.set("prop3", 1000); // not validated
+    }).unwrap()).is_valid(), true);
+}
+
+#[test]
+fn validate_kw_properties() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.properties(|props| {
+            props.insert("id", |prop1| {
+                prop1.maximum(10f64, false);
+            });
+            props.insert("items", |prop2| {
+                prop2.minimum(11f64, false);
+            });
+        });
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("id", 10);
+        obj.set("items", 11);
+    }).unwrap()).is_valid(), true);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("id", 11);
+        obj.set("items", 11);
+    }).unwrap()).is_valid(), false);
+
+}
+
+#[test]
+fn validate_pattern_properties() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.properties(|properties| {
+            properties.insert("prop1", |prop1| {
+                prop1.maximum(10f64, false);
+            });
+        });
+        s.pattern_properties(|properties| {
+            properties.insert("prop.*", |prop| {
+                prop.maximum(1000f64, false);
+            });
+        });
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop1", 11);
+    }).unwrap()).is_valid(), false);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop1", 10);
+        obj.set("prop2", 1000);
+    }).unwrap()).is_valid(), true);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop1", 10);
+        obj.set("prop2", 1001);
+    }).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_additional_properties_false() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.properties(|properties| {
+            properties.insert("prop1", |prop1| {
+                prop1.maximum(10f64, false);
+            });
+        });
+        s.pattern_properties(|properties| {
+            properties.insert("prop.*", |prop| {
+                prop.maximum(1000f64, false);
+            });
+        });
+        s.additional_properties(false);
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop1", 10);
+        obj.set("prop2", 1000);
+    }).unwrap()).is_valid(), true);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop1", 10);
+        obj.set("prop2", 1000);
+        obj.set("some_other", 0);
+    }).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_additional_properties_schema() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.properties(|properties| {
+            properties.insert("prop1", |prop1| {
+                prop1.maximum(10f64, false);
+            });
+        });
+        s.pattern_properties(|properties| {
+            properties.insert("prop.*", |prop| {
+                prop.maximum(1000f64, false);
+            });
+        });
+        s.additional_properties_schema(|additional| {
+            additional.maximum(5f64, false)
+        });
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop1", 10);
+        obj.set("prop2", 1000);
+        obj.set("some_other", 5);
+    }).unwrap()).is_valid(), true);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop1", 10);
+        obj.set("prop2", 1000);
+        obj.set("some_other", 6);
+    }).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn malformed() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("properties", false);
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("patternProperties", false);
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.object("patternProperties", |pattern| {
+            pattern.set("test", 1)
+        });
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.object("patternProperties", |pattern| {
+            pattern.object("((", |_malformed| {})
+        });
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("additionalProperties", 10);
+    }).unwrap(), true).is_err());
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/ref_.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/ref_.rs
new file mode 100644
index 0000000..a8925af
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/ref_.rs
@@ -0,0 +1,61 @@
+use serde_json::{Value};
+use url::{Url};
+
+use super::super::schema;
+use super::super::validators;
+
+#[allow(missing_copy_implementations)]
+pub struct Ref;
+impl super::Keyword for Ref {
+    fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+        let ref_ = keyword_key_exists!(def, "$ref");
+
+        if ref_.is_string() {
+            let url = Url::options().base_url(Some(ctx.url)).parse(ref_.as_str().unwrap());
+            match url {
+                Ok(url) => {
+                    Ok(Some(Box::new(validators::Ref {
+                        url: url
+                    })))
+                },
+                Err(_) => {
+                    Err(schema::SchemaError::Malformed {
+                        path: ctx.fragment.join("/"),
+                        detail: "The value of $ref MUST be an URI-encoded JSON Pointer".to_string()
+                    })
+                }
+            }
+        } else {
+            Err(schema::SchemaError::Malformed {
+                path: ctx.fragment.join("/"),
+                detail: "The value of multipleOf MUST be a string".to_string()
+            })
+        }
+    }
+}
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use serde_json::to_value;
+
+#[test]
+fn validate() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.array();
+        s.max_items(2u64);
+        s.items_schema(|items| {
+            items.ref_("#");
+        })
+    }).into_json(), true).ok().unwrap();
+
+    let array: Vec<String> = vec![];
+    let array2: Vec<Vec<String>> = vec![vec![], vec![]];
+    let array3: Vec<Vec<String>> = vec![vec![], vec![], vec![]];
+
+    assert_eq!(schema.validate(&to_value(&array).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&array2).unwrap()).is_valid(), true);
+
+    assert_eq!(schema.validate(&to_value(&array3).unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&vec![1,2]).unwrap()).is_valid(), false);
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/required.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/required.rs
new file mode 100644
index 0000000..1612957
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/required.rs
@@ -0,0 +1,84 @@
+use serde_json::{Value};
+
+use super::super::schema;
+use super::super::validators;
+
+#[allow(missing_copy_implementations)]
+pub struct Required;
+impl super::Keyword for Required {
+    fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+        let required = keyword_key_exists!(def, "required");
+
+        if required.is_array() {
+            let required = required.as_array().unwrap();
+
+            if required.len() == 0 {
+                return Err(schema::SchemaError::Malformed {
+                    path: ctx.fragment.join("/"),
+                    detail: "This array MUST have at least one element.".to_string()
+                })
+            }
+
+            let mut items = vec![];
+            for item in required.iter() {
+                if item.is_string() {
+                    items.push(item.as_str().unwrap().to_string())
+                } else {
+                    return Err(schema::SchemaError::Malformed {
+                        path: ctx.fragment.join("/"),
+                        detail: "The values of `required` MUST be strings".to_string()
+                    })
+                }
+            }
+
+            Ok(Some(Box::new(validators::Required {
+                items: items
+            })))
+        } else {
+            Err(schema::SchemaError::Malformed {
+                path: ctx.fragment.join("/"),
+                detail: "The value of this keyword MUST be an array.".to_string()
+            })
+        }
+    }
+}
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use jsonway;
+#[cfg(test)] use super::super::builder;
+
+#[test]
+fn validate() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.required(vec!["prop1".to_string(), "prop2".to_string()]);
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop1", 0);
+    }).unwrap()).is_valid(), false);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop2", 0);
+    }).unwrap()).is_valid(), false);
+
+    assert_eq!(schema.validate(&jsonway::object(|obj| {
+        obj.set("prop1", 0);
+        obj.set("prop2", 0);
+    }).unwrap()).is_valid(), true);
+}
+
+#[test]
+fn malformed() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.array("required", |_| {});
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.array("required", |required| {
+            required.push(1)
+        });
+    }).unwrap(), true).is_err());
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/type_.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/type_.rs
new file mode 100644
index 0000000..66f630a
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/type_.rs
@@ -0,0 +1,209 @@
+use serde_json::{Value};
+
+use super::super::schema;
+use super::super::validators;
+
+#[allow(missing_copy_implementations)]
+pub struct Type;
+impl super::Keyword for Type {
+    fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+        let type_ = keyword_key_exists!(def, "type");
+
+        if type_.is_string() {
+            let ty = type_.as_str().unwrap().parse().ok();
+
+            if ty.is_some() {
+                Ok(Some(Box::new(validators::Type {
+                    item: validators::type_::TypeKind::Single(ty.unwrap())
+                })))
+            } else {
+                Err(schema::SchemaError::Malformed {
+                    path: ctx.fragment.join("/"),
+                    detail: format!(
+                        "String values MUST be one of the seven primitive types defined by the core specification. Unknown type: {}",
+                        type_.as_str().unwrap()
+                    )
+                })
+            }
+
+        } else if type_.is_array() {
+            let types = type_.as_array().unwrap();
+
+            if types.len() == 0 {
+                return Err(schema::SchemaError::Malformed {
+                    path: ctx.fragment.join("/"),
+                    detail: "This array MUST have at least one element.".to_string()
+                })
+            }
+
+            let mut converted_types = vec![];
+            for ty in types.iter() {
+                if ty.is_string() {
+                    let converted_ty = ty.as_str().unwrap().parse().ok();
+                    if converted_ty.is_some() {
+                        converted_types.push(converted_ty.unwrap());
+                    } else {
+                        return Err(schema::SchemaError::Malformed {
+                            path: ctx.fragment.join("/"),
+                            detail: format!("Unknown type: {}", ty.as_str().unwrap())
+                        })
+                    }
+                } else {
+                    return Err(schema::SchemaError::Malformed {
+                        path: ctx.fragment.join("/"),
+                        detail: "String values MUST be one of the seven primitive types defined by the core specification.".to_string()
+                    })
+                }
+            }
+
+            Ok(Some(Box::new(validators::Type {
+                item: validators::type_::TypeKind::Set(converted_types)
+            })))
+        } else {
+            Err(schema::SchemaError::Malformed {
+                path: ctx.fragment.join("/"),
+                detail: "The value of this keyword MUST be either a string or an array.".to_string()
+            })
+        }
+    }
+}
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use jsonway;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use serde_json::to_value;
+
+// pub enum PrimitiveType {
+//     Array,
+//     Boolean,
+//     Integer,
+//     Number,
+//     Null,
+//     Object,
+//     String,
+// }
+
+#[test]
+fn validate_array() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.array();
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&jsonway::array(|_arr| {}).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"string").unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_boolean() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.boolean();
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&true).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&false).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"string").unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_integer() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.integer();
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&10).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&-10).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&11.5).unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&to_value(&"string").unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_number() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.number();
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&10).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&-10).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&11.5).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"string").unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_null() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.null();
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&Value::Null).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"string").unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_object() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.object();
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&jsonway::object(|_arr| {}).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"string").unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_string() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.string();
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&"string").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&jsonway::object(|_arr| {}).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn validate_set() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.types(&[super::super::PrimitiveType::Integer, super::super::PrimitiveType::String]);
+    }).into_json(), true).ok().unwrap();
+
+    assert_eq!(schema.validate(&to_value(&10).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&-11).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&"string").unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&11.5).unwrap()).is_valid(), false);
+    assert_eq!(schema.validate(&jsonway::object(|_arr| {}).unwrap()).is_valid(), false);
+}
+
+#[test]
+fn malformed() {
+    let mut scope = scope::Scope::new();
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("type", 10);
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.object("type", |_type| {});
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.set("type", "unsigned".to_string());
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.array("type", |types| {
+            types.push(10);
+        });
+    }).unwrap(), true).is_err());
+
+    assert!(scope.compile_and_return(jsonway::object(|schema| {
+        schema.array("type", |types| {
+            types.push("unsigned".to_string());
+        });
+    }).unwrap(), true).is_err());
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/keywords/unique_items.rs b/rustc_deps/vendor/valico/src/json_schema/keywords/unique_items.rs
new file mode 100644
index 0000000..0b62071
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/keywords/unique_items.rs
@@ -0,0 +1,40 @@
+use serde_json::{Value};
+
+use super::super::schema;
+use super::super::validators;
+
+#[allow(missing_copy_implementations)]
+pub struct UniqueItems;
+impl super::Keyword for UniqueItems {
+    fn compile(&self, def: &Value, ctx: &schema::WalkContext) -> super::KeywordResult {
+        let uniq = keyword_key_exists!(def, "uniqueItems");
+
+        if uniq.is_boolean() {
+            if uniq.as_bool().unwrap() {
+                Ok(Some(Box::new(validators::UniqueItems)))
+            } else {
+                Ok(None)
+            }
+        } else {
+            Err(schema::SchemaError::Malformed {
+                path: ctx.fragment.join("/"),
+                detail: "The value of pattern MUST be boolean".to_string()
+            })
+        }
+    }
+}
+
+#[cfg(test)] use super::super::scope;
+#[cfg(test)] use super::super::builder;
+#[cfg(test)] use serde_json::to_value;
+
+#[test]
+fn validate_unique_items() {
+    let mut scope = scope::Scope::new();
+    let schema = scope.compile_and_return(builder::schema(|s| {
+        s.unique_items(true)
+    }).into_json(), true).ok().unwrap();;
+
+    assert_eq!(schema.validate(&to_value(&[1,2,3,4]).unwrap()).is_valid(), true);
+    assert_eq!(schema.validate(&to_value(&[1,1,3,4]).unwrap()).is_valid(), false);
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/mod.rs b/rustc_deps/vendor/valico/src/json_schema/mod.rs
new file mode 100644
index 0000000..bc5a6ac
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/mod.rs
@@ -0,0 +1,56 @@
+use std::str;
+use std::fmt;
+
+#[macro_use] pub mod helpers;
+#[macro_use] pub mod keywords;
+pub mod schema;
+pub mod scope;
+pub mod validators;
+pub mod errors;
+pub mod builder;
+
+pub use self::scope::{Scope};
+pub use self::schema::{Schema, SchemaError};
+pub use self::builder::{Builder, schema};
+pub use self::validators::{ValidationState};
+
+#[derive(Copy, Debug, Clone)]
+pub enum PrimitiveType {
+    Array,
+    Boolean,
+    Integer,
+    Number,
+    Null,
+    Object,
+    String,
+}
+
+impl str::FromStr for PrimitiveType {
+    type Err = ();
+    fn from_str(s: &str) -> Result<PrimitiveType, ()> {
+        match s {
+            "array" => Ok(PrimitiveType::Array),
+            "boolean" => Ok(PrimitiveType::Boolean),
+            "integer" => Ok(PrimitiveType::Integer),
+            "number" => Ok(PrimitiveType::Number),
+            "null" => Ok(PrimitiveType::Null),
+            "object" => Ok(PrimitiveType::Object),
+            "string" => Ok(PrimitiveType::String),
+            _ => Err(())
+        }
+    }
+}
+
+impl fmt::Display for PrimitiveType {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.write_str(match self {
+            &PrimitiveType::Array => "array",
+            &PrimitiveType::Boolean => "boolean",
+            &PrimitiveType::Integer => "integer",
+            &PrimitiveType::Number => "number",
+            &PrimitiveType::Null => "null",
+            &PrimitiveType::Object => "object",
+            &PrimitiveType::String => "string",
+        })
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/schema.rs b/rustc_deps/vendor/valico/src/json_schema/schema.rs
new file mode 100644
index 0000000..b10650c
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/schema.rs
@@ -0,0 +1,337 @@
+use url;
+use std::collections;
+use serde_json::{Value};
+use phf;
+use std::ops;
+
+use super::helpers;
+use super::scope;
+use super::keywords;
+use super::validators;
+
+#[derive(Debug)]
+pub struct WalkContext<'a> {
+    pub url: &'a url::Url,
+    pub fragment: Vec<String>,
+    pub scopes: &'a mut collections::HashMap<String, Vec<String>>
+}
+
+impl<'a> WalkContext<'a> {
+    pub fn escaped_fragment(&self) -> String {
+        helpers::connect(self.fragment.iter().map(|s| s.as_ref()).collect::<Vec<&str>>().as_ref())
+    }
+}
+
+#[derive(Debug)]
+#[allow(missing_copy_implementations)]
+pub enum SchemaError {
+    WrongId,
+    IdConflicts,
+    NotAnObject,
+    UrlParseError(url::ParseError),
+    UnknownKey(String),
+    Malformed {
+        path: String,
+        detail: String
+    }
+}
+
+#[derive(Debug)]
+pub struct ScopedSchema<'a> {
+    scope: &'a scope::Scope,
+    schema: &'a Schema
+}
+
+impl<'a> ops::Deref for ScopedSchema<'a> {
+    type Target = Schema;
+
+    fn deref(&self) -> &Schema {
+        &self.schema
+    }
+}
+
+impl<'a> ScopedSchema<'a> {
+    pub fn new(scope: &'a scope::Scope, schema: &'a Schema) -> ScopedSchema<'a> {
+        ScopedSchema {
+            scope: scope,
+            schema: schema
+        }
+    }
+
+    pub fn validate(&self, data: &Value) -> validators::ValidationState {
+        return self.schema.validate_in_scope(data, "", self.scope);
+    }
+
+    pub fn validate_in(&self, data: &Value, path: &str) -> validators::ValidationState {
+        return self.schema.validate_in_scope(data, path, self.scope);
+    }
+}
+
+#[derive(Debug)]
+#[allow(dead_code)]
+pub struct Schema {
+    pub id: Option<url::Url>,
+    schema: Option<url::Url>,
+    original: Value,
+    tree: collections::BTreeMap<String, Schema>,
+    validators: validators::Validators,
+    scopes: collections::HashMap<String, Vec<String>>
+}
+
+include!(concat!(env!("OUT_DIR"), "/codegen.rs"));
+
+pub struct CompilationSettings<'a> {
+    pub keywords: &'a keywords::KeywordMap,
+    pub ban_unknown_keywords: bool
+}
+
+impl<'a> CompilationSettings<'a> {
+    pub fn new(keywords: &'a keywords::KeywordMap, ban_unknown_keywords: bool) -> CompilationSettings<'a> {
+        CompilationSettings {
+            keywords: keywords,
+            ban_unknown_keywords: ban_unknown_keywords,
+        }
+    }
+}
+
+impl Schema {
+    fn compile(def: Value, external_id: Option<url::Url>, settings: CompilationSettings) -> Result<Schema, SchemaError> {
+        if !def.is_object() {
+            return Err(SchemaError::NotAnObject)
+        }
+
+        let id = if external_id.is_some() {
+            external_id.unwrap()
+        } else {
+            try!(helpers::parse_url_key("id", &def)).clone().unwrap_or_else(|| helpers::generate_id())
+        };
+
+        let schema = try!(helpers::parse_url_key("$schema", &def));
+
+        let (tree, mut scopes) = {
+            let mut tree = collections::BTreeMap::new();
+            let obj = def.as_object().unwrap();
+
+            let mut scopes = collections::HashMap::new();
+
+            for (key, value) in obj.iter() {
+                if !value.is_object() && !value.is_array() { continue; }
+                if FINAL_KEYS.contains(&key[..]) { continue; }
+
+                let mut context = WalkContext {
+                    url: &id,
+                    fragment: vec![key.clone()],
+                    scopes: &mut scopes
+                };
+
+                let scheme = try!(Schema::compile_sub(
+                    value.clone(),
+                    &mut context,
+                    &settings,
+                    !NON_SCHEMA_KEYS.contains(&key[..])
+                ));
+
+                tree.insert(helpers::encode(key), scheme);
+            }
+
+            (tree, scopes)
+        };
+
+        let validators = try!(Schema::compile_keywords(&def, &WalkContext {
+            url: &id,
+            fragment: vec![],
+            scopes: &mut scopes,
+        }, &settings));
+
+        let schema = Schema {
+            id: Some(id),
+            schema: schema,
+            original: def,
+            tree: tree,
+            validators: validators,
+            scopes: scopes
+        };
+
+        Ok(schema)
+    }
+
+    fn compile_keywords(def: &Value, context: &WalkContext, settings: &CompilationSettings) -> Result<validators::Validators, SchemaError> {
+        let mut validators = vec![];
+        let mut keys: collections::HashSet<&str> = def.as_object().unwrap().keys().map(|key| key.as_ref()).collect();
+        let mut not_consumed = collections::HashSet::new();
+
+        loop {
+            let key = keys.iter().next().cloned();
+            if key.is_some() {
+                let key = key.unwrap();
+                match settings.keywords.get(&key) {
+                    Some(keyword) => {
+                        keyword.consume(&mut keys);
+
+                        match try!(keyword.keyword.compile(def, context)) {
+                            Some(validator) => validators.push(validator),
+                            None => ()
+                        }
+                    },
+                    None => {
+                        keys.remove(&key);
+                        if settings.ban_unknown_keywords {
+                            not_consumed.insert(key);
+                        }
+                    }
+                }
+            } else {
+                break;
+            }
+        }
+
+        if settings.ban_unknown_keywords && not_consumed.len() > 0 {
+            for key in not_consumed.iter() {
+                if !ALLOW_NON_CONSUMED_KEYS.contains(&key[..]) {
+                    return Err(SchemaError::UnknownKey(key.to_string()))
+                }
+            }
+        }
+
+        Ok(validators)
+    }
+
+    fn compile_sub(def: Value, context: &mut WalkContext, keywords: &CompilationSettings, is_schema: bool) -> Result<Schema, SchemaError> {
+
+        let mut id = None;
+        let mut schema = None;
+
+        if is_schema {
+            id = try!(helpers::parse_url_key_with_base("id", &def, context.url));
+            schema = try!(helpers::parse_url_key("$schema", &def));
+        }
+
+        let tree = {
+            let mut tree = collections::BTreeMap::new();
+
+            if def.is_object() {
+                let obj = def.as_object().unwrap();
+                let parent_key = &context.fragment[context.fragment.len() - 1];
+
+                for (key, value) in obj.iter() {
+                    if !value.is_object() && !value.is_array() { continue; }
+                    if !PROPERTY_KEYS.contains(&parent_key[..]) && FINAL_KEYS.contains(&key[..]) { continue; }
+
+                    let mut current_fragment = context.fragment.clone();
+                    current_fragment.push(key.clone());
+
+                    let is_schema = PROPERTY_KEYS.contains(&parent_key[..]) || !NON_SCHEMA_KEYS.contains(&key[..]);
+
+                    let mut context = WalkContext {
+                        url: id.as_ref().unwrap_or(context.url),
+                        fragment: current_fragment,
+                        scopes: context.scopes
+                    };
+
+                    let scheme = try!(Schema::compile_sub(
+                        value.clone(),
+                        &mut context,
+                        keywords,
+                        is_schema
+                    ));
+
+                    tree.insert(helpers::encode(key), scheme);
+                }
+            } else if def.is_array() {
+                let array = def.as_array().unwrap();
+
+                for (idx, value) in array.iter().enumerate() {
+                    if !value.is_object() && !value.is_array() { continue; }
+
+                    let mut current_fragment = context.fragment.clone();
+                    current_fragment.push(idx.to_string().clone());
+
+                    let mut context = WalkContext {
+                        url: id.as_ref().unwrap_or(context.url),
+                        fragment: current_fragment,
+                        scopes: context.scopes
+                    };
+
+                    let scheme = try!(Schema::compile_sub(
+                        value.clone(),
+                        &mut context,
+                        keywords,
+                        true
+                    ));
+
+                    tree.insert(idx.to_string().clone(), scheme);
+                }
+            }
+
+            tree
+        };
+
+        if id.is_some() {
+            context.scopes.insert(id.clone().unwrap().into_string(), context.fragment.clone());
+        }
+
+        let validators = if is_schema && def.is_object() {
+            try!(Schema::compile_keywords(&def, context, keywords))
+        } else {
+            vec![]
+        };
+
+        let schema = Schema {
+            id: id,
+            schema: schema,
+            original: def,
+            tree: tree,
+            validators: validators,
+            scopes: collections::HashMap::new()
+        };
+
+        Ok(schema)
+    }
+
+    pub fn resolve(&self, id: &str) -> Option<&Schema> {
+        let path = self.scopes.get(id);
+        path.map(|path| {
+            let mut schema = self;
+            for item in path.iter() {
+                schema = schema.tree.get(item).unwrap()
+            }
+            schema
+        })
+    }
+
+    pub fn resolve_fragment(&self, fragment: &str) -> Option<&Schema> {
+        assert!(fragment.starts_with("/"), "Can't resolve id fragments");
+
+        let parts = fragment[1..].split("/");
+        let mut schema = self;
+        for part in parts {
+            match schema.tree.get(part) {
+                Some(sch) => schema = sch,
+                None => return None
+            }
+        }
+
+        Some(schema)
+    }
+}
+
+impl Schema {
+    fn validate_in_scope(&self, data: &Value, path: &str, scope: &scope::Scope) -> validators::ValidationState {
+        let mut state = validators::ValidationState::new();
+
+        for validator in self.validators.iter() {
+            state.append(validator.validate(data, path, scope))
+        }
+
+        state
+    }
+}
+
+pub fn compile(def: Value, external_id: Option<url::Url>, settings: CompilationSettings) -> Result<Schema, SchemaError> {
+    Schema::compile(def, external_id, settings)
+}
+
+#[test]
+fn schema_doesnt_compile_not_object() {
+    assert!(Schema::compile(Value::Bool(true), None, CompilationSettings::new(&keywords::default(), true)).is_err());
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/scope.rs b/rustc_deps/vendor/valico/src/json_schema/scope.rs
new file mode 100644
index 0000000..8a05ff5
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/scope.rs
@@ -0,0 +1,161 @@
+use url;
+use std::collections;
+use serde_json::{Value};
+
+use super::schema;
+use super::keywords;
+use super::helpers;
+
+#[allow(dead_code)]
+#[derive(Debug)]
+pub struct Scope {
+    keywords: keywords::KeywordMap,
+    schemes: collections::HashMap<String, schema::Schema>,
+}
+
+#[allow(dead_code)]
+impl Scope {
+    pub fn new() -> Scope {
+        let mut scope = Scope {
+            keywords: keywords::default(),
+            schemes: collections::HashMap::new()
+        };
+
+        scope.add_keyword(vec!["format"], keywords::format::Format::new());
+        scope
+    }
+
+    pub fn without_formats() -> Scope {
+        Scope {
+            keywords: keywords::default(),
+            schemes: collections::HashMap::new()
+        }
+    }
+
+    pub fn with_formats<F>(build_formats: F) -> Scope where F: FnOnce(&mut keywords::format::FormatBuilders) {
+        let mut scope = Scope {
+            keywords: keywords::default(),
+            schemes: collections::HashMap::new()
+        };
+
+        scope.add_keyword(vec!["format"], keywords::format::Format::with(build_formats));
+        scope
+    }
+
+    pub fn compile(&mut self, def: Value, ban_unknown: bool) -> Result<url::Url, schema::SchemaError> {
+        let schema = try!(schema::compile(def, None, schema::CompilationSettings::new(&self.keywords, ban_unknown)));
+        let id = schema.id.clone().unwrap();
+        try!(self.add(&id, schema));
+        Ok(id)
+    }
+
+    pub fn compile_with_id(&mut self, id: &url::Url, def: Value, ban_unknown: bool)
+        -> Result<(), schema::SchemaError>
+    {
+        let schema = try!(schema::compile(def, Some(id.clone()), schema::CompilationSettings::new(&self.keywords, ban_unknown)));
+        self.add(id, schema)
+    }
+
+    pub fn compile_and_return<'a>(&'a mut self, def: Value, ban_unknown: bool)
+        -> Result<schema::ScopedSchema<'a>, schema::SchemaError>
+    {
+        let schema = try!(schema::compile(def, None, schema::CompilationSettings::new(&self.keywords, ban_unknown)));
+        self.add_and_return(schema.id.clone().as_ref().unwrap(), schema)
+    }
+
+    pub fn compile_and_return_with_id<'a>(&'a mut self, id: &url::Url, def: Value, ban_unknown: bool)
+        -> Result<schema::ScopedSchema<'a>, schema::SchemaError>
+    {
+        let schema = try!(schema::compile(def, Some(id.clone()), schema::CompilationSettings::new(&self.keywords, ban_unknown)));
+        self.add_and_return(id, schema)
+    }
+
+    pub fn add_keyword<T>(&mut self, keys: Vec<&'static str>, keyword: T) where T: keywords::Keyword + 'static {
+        keywords::decouple_keyword((keys, Box::new(keyword)), &mut self.keywords);
+    }
+
+    fn add(&mut self, id: &url::Url, schema: schema::Schema) -> Result<(), schema::SchemaError> {
+        let (id_str, fragment) = helpers::serialize_schema_path(id);
+
+        match fragment {
+            Some(_) => return Err(schema::SchemaError::WrongId),
+            None => ()
+        }
+
+        if !self.schemes.contains_key(&id_str) {
+            self.schemes.insert(id_str, schema);
+            Ok(())
+        } else {
+            Err(schema::SchemaError::IdConflicts)
+        }
+    }
+
+    fn add_and_return<'a>(&'a mut self, id: &url::Url, schema: schema::Schema)
+        -> Result<schema::ScopedSchema<'a>, schema::SchemaError>
+    {
+        let (id_str, fragment) = helpers::serialize_schema_path(id);
+
+        match fragment {
+            Some(_) => return Err(schema::SchemaError::WrongId),
+            None => ()
+        }
+
+        if !self.schemes.contains_key(&id_str) {
+            self.schemes.insert(id_str.clone(), schema);
+            Ok(schema::ScopedSchema::new(self, self.schemes.get(&id_str).unwrap()))
+        } else {
+            Err(schema::SchemaError::IdConflicts)
+        }
+    }
+
+    pub fn resolve<'a>(&'a self, id: &url::Url) -> Option<schema::ScopedSchema<'a>> {
+        let (schema_path, fragment) = helpers::serialize_schema_path(id);
+
+        let schema = self.schemes.get(&schema_path).or_else(|| {
+            // Searching for inline schema in O(N)
+            for (_, schema) in self.schemes.iter() {
+                let internal_schema = schema.resolve(schema_path.as_ref());
+                if internal_schema.is_some() {
+                    return internal_schema
+                }
+            }
+
+            None
+        });
+
+        schema.and_then(|schema| {
+            match fragment {
+                Some(ref fragment) => {
+                    schema.resolve_fragment(fragment.as_ref()).map(|schema| {
+                        schema::ScopedSchema::new(self, schema)
+                    })
+                },
+                None => Some(schema::ScopedSchema::new(self, schema))
+            }
+        })
+    }
+}
+
+#[cfg(test)]
+use jsonway;
+
+#[test]
+fn lookup() {
+    let mut scope = Scope::new();
+
+    scope.compile(jsonway::object(|schema| {
+        schema.set("id", "http://example.com/schema".to_string())
+    }).unwrap(), false).ok().unwrap();
+
+    scope.compile(jsonway::object(|schema| {
+        schema.set("id", "http://example.com/schema#sub".to_string());
+        schema.object("subschema", |subschema| {
+            subschema.set("id", "#subschema".to_string());
+        })
+    }).unwrap(), false).ok().unwrap();
+
+    assert!(scope.resolve(&url::Url::parse("http://example.com/schema").ok().unwrap()).is_some());
+    assert!(scope.resolve(&url::Url::parse("http://example.com/schema#sub").ok().unwrap()).is_some());
+    assert!(scope.resolve(&url::Url::parse("http://example.com/schema#sub/subschema").ok().unwrap()).is_some());
+    assert!(scope.resolve(&url::Url::parse("http://example.com/schema#subschema").ok().unwrap()).is_some());
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/dependencies.rs b/rustc_deps/vendor/valico/src/json_schema/validators/dependencies.rs
new file mode 100644
index 0000000..4e9468e
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/dependencies.rs
@@ -0,0 +1,55 @@
+use std::collections;
+use serde_json::{Value};
+use url;
+
+use super::super::errors;
+use super::super::scope;
+
+#[derive(Debug)]
+pub enum DepKind {
+    Schema(url::Url),
+    Property(Vec<String>)
+}
+
+#[allow(missing_copy_implementations)]
+pub struct Dependencies {
+    pub items: collections::HashMap<String, DepKind>
+}
+
+impl super::Validator for Dependencies {
+    fn validate(&self, object: &Value, path: &str, scope: &scope::Scope) -> super::ValidationState {
+        if !object.is_object() {
+            return super::ValidationState::new()
+        }
+
+        let mut state = super::ValidationState::new();
+
+        for (key, dep) in self.items.iter() {
+            if object.get(&key).is_some() {
+                match dep {
+                    &DepKind::Schema(ref url) => {
+                        let schema = scope.resolve(url);
+                        if schema.is_some() {
+                            state.append(schema.unwrap().validate_in(object, path));
+                        } else {
+                            state.missing.push(url.clone())
+                        }
+                    },
+                    &DepKind::Property(ref keys) => {
+                        for key in keys.iter() {
+                            if !object.get(&key).is_some() {
+                                state.errors.push(Box::new(
+                                    errors::Required {
+                                        path: [path, key.as_ref()].join("/")
+                                    }
+                                ))
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        state
+    }
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/enum_.rs b/rustc_deps/vendor/valico/src/json_schema/validators/enum_.rs
new file mode 100644
index 0000000..0e8869e
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/enum_.rs
@@ -0,0 +1,33 @@
+use serde_json::{Value};
+
+use super::super::errors;
+use super::super::scope;
+
+#[allow(missing_copy_implementations)]
+pub struct Enum {
+    pub items: Vec<Value>
+}
+
+impl super::Validator for Enum {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let mut state = super::ValidationState::new();
+
+        let mut contains = false;
+        for value in self.items.iter() {
+            if val == value {
+                contains = true;
+                break;
+            }
+        }
+
+        if !contains {
+            state.errors.push(Box::new(
+                errors::Enum {
+                    path: path.to_string()
+                }
+            ))
+        }
+
+        state
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/formats.rs b/rustc_deps/vendor/valico/src/json_schema/validators/formats.rs
new file mode 100644
index 0000000..3d70737
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/formats.rs
@@ -0,0 +1,91 @@
+use serde_json::{Value};
+use std::net;
+use uuid;
+use url;
+
+use super::super::errors;
+use super::super::scope;
+
+#[allow(missing_copy_implementations)]
+pub struct Ipv4;
+
+impl super::Validator for Ipv4 {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let string = nonstrict_process!(val.as_str(), path);
+
+        match string.parse::<net::Ipv4Addr>() {
+            Ok(_) => super::ValidationState::new(),
+            Err(_) => {
+                val_error!(
+                    errors::Format {
+                        path: path.to_string(),
+                        detail: "Wrong IP address".to_string()
+                    }
+                )
+            }
+        }
+    }
+}
+
+#[allow(missing_copy_implementations)]
+pub struct Ipv6;
+
+impl super::Validator for Ipv6 {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let string = nonstrict_process!(val.as_str(), path);
+
+        match string.parse::<net::Ipv6Addr>() {
+            Ok(_) => super::ValidationState::new(),
+            Err(_) => {
+                val_error!(
+                    errors::Format {
+                        path: path.to_string(),
+                        detail: "Wrong IP address".to_string()
+                    }
+                )
+            }
+        }
+    }
+}
+
+#[allow(missing_copy_implementations)]
+pub struct Uuid;
+
+impl super::Validator for Uuid {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let string = nonstrict_process!(val.as_str(), path);
+
+        match string.parse::<uuid::Uuid>() {
+            Ok(_) => super::ValidationState::new(),
+            Err(err) => {
+                val_error!(
+                    errors::Format {
+                        path: path.to_string(),
+                        detail: format!("Malformed UUID: {:?}", err)
+                    }
+                )
+            }
+        }
+    }
+}
+
+#[allow(missing_copy_implementations)]
+pub struct Uri;
+
+impl super::Validator for Uri {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let string = nonstrict_process!(val.as_str(), path);
+
+        match url::Url::parse(string) {
+            Ok(_) => super::ValidationState::new(),
+            Err(err) => {
+                val_error!(
+                    errors::Format {
+                        path: path.to_string(),
+                        detail: format!("Malformed URI: {}", err)
+                    }
+                )
+            }
+        }
+    }
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/items.rs b/rustc_deps/vendor/valico/src/json_schema/validators/items.rs
new file mode 100644
index 0000000..8108c02
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/items.rs
@@ -0,0 +1,95 @@
+use serde_json::{Value};
+use std::cmp;
+use url;
+
+use super::super::errors;
+use super::super::scope;
+
+#[derive(Debug)]
+pub enum ItemsKind {
+    Schema(url::Url),
+    Array(Vec<url::Url>)
+}
+
+#[derive(Debug)]
+pub enum AdditionalKind {
+    Boolean(bool),
+    Schema(url::Url)
+}
+
+#[allow(missing_copy_implementations)]
+pub struct Items {
+    pub items: Option<ItemsKind>,
+    pub additional: Option<AdditionalKind>
+}
+
+impl super::Validator for Items {
+    fn validate(&self, val: &Value, path: &str, scope: &scope::Scope) -> super::ValidationState {
+        let array = nonstrict_process!(val.as_array(), path);
+
+        let mut state = super::ValidationState::new();
+
+        match self.items {
+            Some(ItemsKind::Schema(ref url)) => {
+                // Just validate all items against the schema
+
+                let schema = scope.resolve(url);
+                if schema.is_some() {
+                    let schema = schema.unwrap();
+                    for (idx, item) in array.iter().enumerate() {
+                        let item_path = [path, idx.to_string().as_ref()].join("/");
+                        state.append(schema.validate_in(item, item_path.as_ref()));
+                    }
+                } else {
+                    state.missing.push(url.clone());
+                }
+            },
+            Some(ItemsKind::Array(ref urls)) => {
+                let min = cmp::min(urls.len(), array.len());
+
+                // Validate against schemas
+                for idx in 0..min {
+                    let schema = scope.resolve(&urls[idx]);
+                    let item = &array[idx];
+
+                    if schema.is_some() {
+                        let item_path = [path, idx.to_string().as_ref()].join("/");
+                        state.append(schema.unwrap().validate_in(item, item_path.as_ref()))
+                    } else {
+                        state.missing.push(urls[idx].clone())
+                    }
+                }
+
+                // Validate agains additional items
+                if array.len() > urls.len() {
+                    match self.additional {
+                        Some(AdditionalKind::Boolean(allow)) if allow == false => {
+                            state.errors.push(Box::new(
+                                errors::Items {
+                                    path: path.to_string(),
+                                    detail: "Additional items are not allowed".to_string()
+                                }
+                            ))
+                        },
+                        Some(AdditionalKind::Schema(ref url)) => {
+                            let schema = scope.resolve(url);
+                            if schema.is_some() {
+                                let schema = schema.unwrap();
+                                for (idx, item) in array[urls.len()..].iter().enumerate() {
+                                    let item_path = [path, idx.to_string().as_ref()].join("/");
+                                    state.append(schema.validate_in(item, item_path.as_ref()))
+                                }
+                            } else {
+                                state.missing.push(url.clone())
+                            }
+                        },
+                        _ => ()
+                    }
+                }
+            }
+            _ => ()
+        }
+
+        state
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/maxmin.rs b/rustc_deps/vendor/valico/src/json_schema/validators/maxmin.rs
new file mode 100644
index 0000000..c01dd63
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/maxmin.rs
@@ -0,0 +1,60 @@
+use serde_json::{Value};
+
+use super::super::errors;
+use super::super::scope;
+
+#[allow(missing_copy_implementations)]
+pub struct Maximum {
+    pub number: f64,
+    pub exclusive: bool
+}
+
+impl super::Validator for Maximum {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let number = nonstrict_process!(val.as_f64(), path);
+
+        let valid = if self.exclusive {
+            number < self.number
+        } else {
+            number <= self.number
+        };
+
+        if valid {
+            super::ValidationState::new()
+        } else {
+            val_error!(
+                errors::Maximum {
+                    path: path.to_string()
+                }
+            )
+        }
+    }
+}
+
+#[allow(missing_copy_implementations)]
+pub struct Minimum {
+    pub number: f64,
+    pub exclusive: bool
+}
+
+impl super::Validator for Minimum {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let number = nonstrict_process!(val.as_f64(), path);
+
+        let valid = if self.exclusive {
+            number > self.number
+        } else {
+            number >= self.number
+        };
+
+        if valid {
+            super::ValidationState::new()
+        } else {
+            val_error!(
+                errors::Minimum {
+                    path: path.to_string()
+                }
+            )
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/maxmin_items.rs b/rustc_deps/vendor/valico/src/json_schema/validators/maxmin_items.rs
new file mode 100644
index 0000000..33abf06
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/maxmin_items.rs
@@ -0,0 +1,46 @@
+use serde_json::{Value};
+
+use super::super::errors;
+use super::super::scope;
+
+#[allow(missing_copy_implementations)]
+pub struct MaxItems {
+    pub length: u64
+}
+
+impl super::Validator for MaxItems {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let array = nonstrict_process!(val.as_array(), path);
+
+        if (array.len() as u64) <= self.length {
+            super::ValidationState::new()
+        } else {
+            val_error!(
+                errors::MaxItems {
+                    path: path.to_string()
+                }
+            )
+        }
+    }
+}
+
+#[allow(missing_copy_implementations)]
+pub struct MinItems {
+    pub length: u64
+}
+
+impl super::Validator for MinItems {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let array = nonstrict_process!(val.as_array(), path);
+
+        if (array.len() as u64) >= self.length {
+            super::ValidationState::new()
+        } else {
+            val_error!(
+                errors::MinItems {
+                    path: path.to_string()
+                }
+            )
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/maxmin_length.rs b/rustc_deps/vendor/valico/src/json_schema/validators/maxmin_length.rs
new file mode 100644
index 0000000..69d6f87
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/maxmin_length.rs
@@ -0,0 +1,46 @@
+use serde_json::{Value};
+
+use super::super::errors;
+use super::super::scope;
+
+#[allow(missing_copy_implementations)]
+pub struct MaxLength {
+    pub length: u64
+}
+
+impl super::Validator for MaxLength {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let string = nonstrict_process!(val.as_str(), path);
+
+        if (string.len() as u64) <= self.length {
+            super::ValidationState::new()
+        } else {
+            val_error!(
+                errors::MaxLength {
+                    path: path.to_string()
+                }
+            )
+        }
+    }
+}
+
+#[allow(missing_copy_implementations)]
+pub struct MinLength {
+    pub length: u64
+}
+
+impl super::Validator for MinLength {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let string = nonstrict_process!(val.as_str(), path);
+
+        if (string.len() as u64) >= self.length {
+            super::ValidationState::new()
+        } else {
+            val_error!(
+                errors::MinLength {
+                    path: path.to_string()
+                }
+            )
+        }
+    }
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/maxmin_properties.rs b/rustc_deps/vendor/valico/src/json_schema/validators/maxmin_properties.rs
new file mode 100644
index 0000000..a4b8b61
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/maxmin_properties.rs
@@ -0,0 +1,46 @@
+use serde_json::{Value};
+
+use super::super::errors;
+use super::super::scope;
+
+#[allow(missing_copy_implementations)]
+pub struct MaxProperties {
+    pub length: u64
+}
+
+impl super::Validator for MaxProperties {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let object = nonstrict_process!(val.as_object(), path);
+
+        if (object.len() as u64) <= self.length {
+            super::ValidationState::new()
+        } else {
+            val_error!(
+                errors::MaxProperties {
+                    path: path.to_string()
+                }
+            )
+        }
+    }
+}
+
+#[allow(missing_copy_implementations)]
+pub struct MinProperties {
+    pub length: u64
+}
+
+impl super::Validator for MinProperties {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let object = nonstrict_process!(val.as_object(), path);
+
+        if (object.len() as u64) >= self.length {
+            super::ValidationState::new()
+        } else {
+            val_error!(
+                errors::MinProperties {
+                    path: path.to_string()
+                }
+            )
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/mod.rs b/rustc_deps/vendor/valico/src/json_schema/validators/mod.rs
new file mode 100644
index 0000000..4664386
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/mod.rs
@@ -0,0 +1,140 @@
+use serde_json::{Value, to_value};
+use serde::{Serialize, Serializer};
+use std::fmt;
+use url;
+
+use super::scope;
+
+#[macro_export]
+macro_rules! strict_process {
+    ($val:expr, $path:ident, $err:expr) => {{
+        let maybe_val = $val;
+        if maybe_val.is_none() {
+            return val_error!(
+                $crate::json_schema::errors::WrongType {
+                    path: $path.to_string(),
+                    detail: $err.to_string()
+                }
+            )
+        }
+
+        maybe_val.unwrap()
+    }}
+}
+
+macro_rules! nonstrict_process {
+    ($val:expr, $path:ident) => {{
+        let maybe_val = $val;
+        if maybe_val.is_none() {
+            return $crate::json_schema::validators::ValidationState::new()
+        }
+
+        maybe_val.unwrap()
+    }}
+}
+
+macro_rules! val_error{
+    ($err:expr) => (
+        $crate::json_schema::validators::ValidationState{
+            errors: vec![
+                Box::new($err)
+            ],
+            missing: vec![]
+        }
+    )
+}
+
+pub use self::multiple_of::{MultipleOf};
+pub use self::maxmin::{Maximum, Minimum};
+pub use self::maxmin_length::{MaxLength, MinLength};
+pub use self::pattern::{Pattern};
+pub use self::maxmin_items::{MaxItems, MinItems};
+pub use self::unique_items::{UniqueItems};
+pub use self::items::{Items};
+pub use self::maxmin_properties::{MaxProperties, MinProperties};
+pub use self::required::{Required};
+pub use self::properties::{Properties};
+pub use self::dependencies::{Dependencies};
+pub use self::enum_::{Enum};
+pub use self::type_::{Type};
+pub use self::of::{AllOf, AnyOf, OneOf};
+pub use self::ref_::{Ref};
+pub use self::not::{Not};
+
+mod multiple_of;
+mod maxmin;
+mod maxmin_length;
+mod pattern;
+mod maxmin_items;
+mod unique_items;
+pub mod items;
+mod maxmin_properties;
+mod required;
+pub mod properties;
+pub mod dependencies;
+mod enum_;
+pub mod type_;
+mod of;
+mod ref_;
+mod not;
+pub mod formats;
+
+#[derive(Debug)]
+pub struct ValidationState {
+    pub errors: super::super::common::error::ValicoErrors,
+    pub missing: Vec<url::Url>
+}
+
+impl ValidationState {
+    pub fn new() -> ValidationState {
+        ValidationState {
+            errors: vec![],
+            missing: vec![]
+        }
+    }
+
+    pub fn is_valid(&self) -> bool {
+        self.errors.len() == 0
+    }
+
+    pub fn is_strictly_valid(&self) -> bool {
+        self.errors.len() == 0 && self.missing.len() == 0
+    }
+
+    pub fn append(&mut self, second: ValidationState) {
+        self.errors.extend(second.errors);
+        self.missing.extend(second.missing);
+    }
+}
+
+impl Serialize for ValidationState {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
+        let mut map = ::serde_json::Map::new();
+        map.insert("errors".to_string(), Value::Array(
+            self.errors.iter().map(|err| to_value(err).unwrap()).collect::<Vec<Value>>()
+        ));
+        map.insert("missing".to_string(), Value::Array(
+            self.missing.iter().map(|url| to_value(&url.to_string()).unwrap()).collect::<Vec<Value>>()
+        ));
+        Value::Object(map).serialize(serializer)
+    }
+}
+
+pub trait Validator {
+    fn validate(&self, item: &Value, &str, &scope::Scope) -> ValidationState;
+}
+
+impl fmt::Debug for Validator + 'static + Send + Sync {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        fmt.write_str("<validator>")
+    }
+}
+
+pub type BoxedValidator = Box<Validator + 'static + Send + Sync>;
+pub type Validators = Vec<BoxedValidator>;
+
+impl<T> Validator for T where T: Fn(&Value, &str, &scope::Scope) -> ValidationState {
+    fn validate(&self, val: &Value, path: &str, scope: &scope::Scope) -> ValidationState {
+        self(val, path, scope)
+    }
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/multiple_of.rs b/rustc_deps/vendor/valico/src/json_schema/validators/multiple_of.rs
new file mode 100644
index 0000000..3626c5a
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/multiple_of.rs
@@ -0,0 +1,33 @@
+use serde_json::{Value};
+
+use super::super::errors;
+use super::super::scope;
+use std::f64;
+
+#[allow(missing_copy_implementations)]
+pub struct MultipleOf {
+    pub number: f64
+}
+
+impl super::Validator for MultipleOf {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let number = nonstrict_process!(val.as_f64(), path);
+
+        let valid = if (number.fract() == 0f64) && (self.number.fract() == 0f64) {
+            (number % self.number) == 0f64
+        } else {
+            let remainder: f64 = (number/self.number) % 1f64;
+            !(remainder >= f64::EPSILON) && (remainder < (1f64 - f64::EPSILON))
+        };
+
+        if valid {
+            super::ValidationState::new()
+        } else {
+            val_error!(
+                errors::MultipleOf {
+                    path: path.to_string()
+                }
+            )
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/not.rs b/rustc_deps/vendor/valico/src/json_schema/validators/not.rs
new file mode 100644
index 0000000..4c0017b
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/not.rs
@@ -0,0 +1,31 @@
+use serde_json::{Value};
+use url;
+
+use super::super::errors;
+use super::super::scope;
+
+#[allow(missing_copy_implementations)]
+pub struct Not {
+    pub url: url::Url
+}
+
+impl super::Validator for Not {
+    fn validate(&self, val: &Value, path: &str, scope: &scope::Scope) -> super::ValidationState {
+        let schema = scope.resolve(&self.url);
+        let mut state = super::ValidationState::new();
+
+        if schema.is_some() {
+            if schema.unwrap().validate_in(val, path).is_valid() {
+                state.errors.push(Box::new(
+                    errors::Not {
+                        path: path.to_string()
+                    }
+                ))
+            }
+        } else {
+            state.missing.push(self.url.clone());
+        }
+
+        state
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/of.rs b/rustc_deps/vendor/valico/src/json_schema/validators/of.rs
new file mode 100644
index 0000000..0cf1216
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/of.rs
@@ -0,0 +1,115 @@
+use serde_json::{Value};
+use url;
+
+use super::super::errors;
+use super::super::scope;
+
+#[allow(missing_copy_implementations)]
+pub struct AllOf {
+    pub schemes: Vec<url::Url>,
+}
+
+impl super::Validator for AllOf {
+    fn validate(&self, val: &Value, path: &str, scope: &scope::Scope) -> super::ValidationState {
+        let mut state = super::ValidationState::new();
+
+        for url in self.schemes.iter() {
+            let schema = scope.resolve(url);
+
+            if schema.is_some() {
+                state.append(schema.unwrap().validate_in(val, path))
+            } else {
+                state.missing.push(url.clone())
+            }
+        }
+
+        state
+    }
+}
+
+#[allow(missing_copy_implementations)]
+pub struct AnyOf {
+    pub schemes: Vec<url::Url>,
+}
+
+impl super::Validator for AnyOf {
+    fn validate(&self, val: &Value, path: &str, scope: &scope::Scope) -> super::ValidationState {
+        let mut state = super::ValidationState::new();
+
+        let mut states = vec![];
+        let mut valid = false;
+        for url in self.schemes.iter() {
+            let schema = scope.resolve(url);
+
+            if schema.is_some() {
+                let current_state = schema.unwrap().validate_in(val, path);
+
+                state.missing.extend(current_state.missing.clone());
+
+                if current_state.is_valid() {
+                    valid = true;
+                    break;
+                } else {
+                   states.push(current_state)
+                }
+            } else {
+                state.missing.push(url.clone())
+            }
+        }
+
+        if !valid {
+            state.errors.push(Box::new(
+                errors::AnyOf {
+                    path: path.to_string(),
+                    states: states
+                }
+            ))
+        }
+
+
+        state
+    }
+}
+
+#[allow(missing_copy_implementations)]
+pub struct OneOf {
+    pub schemes: Vec<url::Url>,
+}
+
+impl super::Validator for OneOf {
+    fn validate(&self, val: &Value, path: &str, scope: &scope::Scope) -> super::ValidationState {
+        let mut state = super::ValidationState::new();
+
+        let mut states = vec![];
+        let mut valid = 0;
+        for url in self.schemes.iter() {
+            let schema = scope.resolve(url);
+
+            if schema.is_some() {
+                let current_state = schema.unwrap().validate_in(val, path);
+
+                state.missing.extend(current_state.missing.clone());
+
+                if current_state.is_valid() {
+                    valid += 1;
+                } else {
+                   states.push(current_state)
+                }
+            } else {
+                state.missing.push(url.clone())
+            }
+        }
+
+        if valid != 1 {
+            state.errors.push(Box::new(
+                errors::OneOf {
+                    path: path.to_string(),
+                    states: states
+                }
+            ))
+        }
+
+
+        state
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/pattern.rs b/rustc_deps/vendor/valico/src/json_schema/validators/pattern.rs
new file mode 100644
index 0000000..8f692a8
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/pattern.rs
@@ -0,0 +1,26 @@
+use regex;
+use serde_json::{Value};
+
+use super::super::errors;
+use super::super::scope;
+
+#[allow(missing_copy_implementations)]
+pub struct Pattern {
+    pub regex: regex::Regex
+}
+
+impl super::Validator for Pattern {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let string = nonstrict_process!(val.as_str(), path);
+
+        if self.regex.is_match(string) {
+            super::ValidationState::new()
+        } else {
+            val_error!(
+                errors::Pattern {
+                    path: path.to_string()
+                }
+            )
+        }
+    }
+}
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/properties.rs b/rustc_deps/vendor/valico/src/json_schema/validators/properties.rs
new file mode 100644
index 0000000..b1dc3d9
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/properties.rs
@@ -0,0 +1,86 @@
+use serde_json::{Value};
+use regex;
+use std::collections;
+use url;
+
+use super::super::errors;
+use super::super::scope;
+
+#[derive(Debug)]
+pub enum AdditionalKind {
+    Boolean(bool),
+    Schema(url::Url)
+}
+
+#[allow(missing_copy_implementations)]
+pub struct Properties {
+    pub properties: collections::HashMap<String, url::Url>,
+    pub additional: AdditionalKind,
+    pub patterns: Vec<(regex::Regex, url::Url)>
+}
+
+impl super::Validator for Properties {
+    fn validate(&self, val: &Value, path: &str, scope: &scope::Scope) -> super::ValidationState {
+        let object = nonstrict_process!(val.as_object(), path);
+        let mut state = super::ValidationState::new();
+
+        'main: for (key, value) in object.iter() {
+            let mut is_property_passed = false;
+            if self.properties.contains_key(key) {
+                let url = self.properties.get(key).unwrap();
+                let schema = scope.resolve(url);
+                if schema.is_some() {
+                    let value_path = [path, key.as_ref()].join("/");
+                    state.append(schema.unwrap().validate_in(value, value_path.as_ref()))
+                } else {
+                    state.missing.push(url.clone())
+                }
+
+               is_property_passed = true;
+            }
+
+            let mut is_pattern_passed = false;
+            for &(ref regex, ref url) in self.patterns.iter() {
+                if regex.is_match(key.as_ref()) {
+                    let schema = scope.resolve(url);
+                    if schema.is_some() {
+                        let value_path = [path, key.as_ref()].join("/");
+                        state.append(schema.unwrap().validate_in(value, value_path.as_ref()));
+                        is_pattern_passed = true;
+                    } else {
+                        state.missing.push(url.clone())
+                    }
+                }
+            }
+
+            if is_property_passed || is_pattern_passed {
+                continue 'main;
+            }
+
+            match self.additional {
+                AdditionalKind::Boolean(allowed) if allowed == false => {
+                    state.errors.push(Box::new(
+                        errors::Properties {
+                            path: path.to_string(),
+                            detail: "Additional properties are not allowed".to_string()
+                        }
+                    ))
+                },
+                AdditionalKind::Schema(ref url) => {
+                    let schema = scope.resolve(url);
+
+                    if schema.is_some() {
+                        let value_path = [path, key.as_ref()].join("/");
+                        state.append(schema.unwrap().validate_in(value, value_path.as_ref()))
+                    } else {
+                        state.missing.push(url.clone())
+                    }
+                },
+                // Additional are allowed here
+                _ => ()
+            }
+        }
+
+        state
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/ref_.rs b/rustc_deps/vendor/valico/src/json_schema/validators/ref_.rs
new file mode 100644
index 0000000..bb89f6c
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/ref_.rs
@@ -0,0 +1,23 @@
+use serde_json::{Value};
+use url;
+
+use super::super::scope;
+
+#[allow(missing_copy_implementations)]
+pub struct Ref {
+    pub url: url::Url
+}
+
+impl super::Validator for Ref {
+    fn validate(&self, val: &Value, path: &str, scope: &scope::Scope) -> super::ValidationState {
+        let schema = scope.resolve(&self.url);
+
+        if schema.is_some() {
+            schema.unwrap().validate_in(val, path)
+        } else {
+            let mut state = super::ValidationState::new();
+            state.missing.push(self.url.clone());
+            state
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/required.rs b/rustc_deps/vendor/valico/src/json_schema/validators/required.rs
new file mode 100644
index 0000000..a40d9d9
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/required.rs
@@ -0,0 +1,28 @@
+use serde_json::{Value};
+
+use super::super::errors;
+use super::super::scope;
+
+#[allow(missing_copy_implementations)]
+pub struct Required {
+    pub items: Vec<String>
+}
+
+impl super::Validator for Required {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let object = nonstrict_process!(val.as_object(), path);
+        let mut state = super::ValidationState::new();
+
+        for key in self.items.iter() {
+            if !object.contains_key(key) {
+                state.errors.push(Box::new(
+                    errors::Required {
+                        path: [path, key.as_ref()].join("/")
+                    }
+                ))
+            }
+        }
+
+        state
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/type_.rs b/rustc_deps/vendor/valico/src/json_schema/validators/type_.rs
new file mode 100644
index 0000000..3ce6860
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/type_.rs
@@ -0,0 +1,68 @@
+use serde_json::{Value};
+
+use super::super::errors;
+use super::super::scope;
+
+use json_schema;
+
+#[derive(Debug)]
+pub enum TypeKind {
+    Single(json_schema::PrimitiveType),
+    Set(Vec<json_schema::PrimitiveType>)
+}
+
+#[allow(missing_copy_implementations)]
+pub struct Type {
+    pub item: TypeKind
+}
+
+fn check_type(val: &Value, ty: &json_schema::PrimitiveType) -> bool {
+    match ty {
+        &json_schema::PrimitiveType::Array => val.is_array(),
+        &json_schema::PrimitiveType::Boolean => val.is_boolean(),
+        &json_schema::PrimitiveType::Integer => val.is_u64() || val.is_i64(),
+        &json_schema::PrimitiveType::Number => val.is_number(),
+        &json_schema::PrimitiveType::Null => val.is_null(),
+        &json_schema::PrimitiveType::Object => val.is_object(),
+        &json_schema::PrimitiveType::String => val.is_string(),
+    }
+}
+
+impl super::Validator for Type {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let mut state = super::ValidationState::new();
+
+        match self.item {
+            TypeKind::Single(ref t) => {
+                if !check_type(val, t) {
+                    state.errors.push(Box::new(
+                        errors::WrongType {
+                            path: path.to_string(),
+                            detail: format!("The value must be {}", t)
+                        }
+                    ))
+                }
+            },
+            TypeKind::Set(ref set) => {
+                let mut is_type_match = false;
+                for ty in set.iter() {
+                    if check_type(val, ty) {
+                        is_type_match = true;
+                        break;
+                    }
+                }
+
+                if !is_type_match {
+                    state.errors.push(Box::new(
+                        errors::WrongType {
+                            path: path.to_string(),
+                            detail: format!("The value must be any of: {}", set.iter().map(|ty| ty.to_string()).collect::<Vec<String>>().join(", "))
+                        }
+                    ))
+                }
+            }
+        }
+
+        state
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/json_schema/validators/unique_items.rs b/rustc_deps/vendor/valico/src/json_schema/validators/unique_items.rs
new file mode 100644
index 0000000..a0a5099
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/json_schema/validators/unique_items.rs
@@ -0,0 +1,41 @@
+use serde_json::{Value};
+
+use super::super::errors;
+use super::super::scope;
+
+#[allow(missing_copy_implementations)]
+pub struct UniqueItems;
+impl super::Validator for UniqueItems {
+    fn validate(&self, val: &Value, path: &str, _scope: &scope::Scope) -> super::ValidationState {
+        let array = nonstrict_process!(val.as_array(), path);
+
+        // TODO we need some quicker algorithm for this
+
+        let mut unique = true;
+        'main: for (idx, item_i) in array.iter().enumerate() {
+            for item_j in array[..idx].iter() {
+                if item_i == item_j {
+                    unique = false;
+                    break 'main;
+                }
+            }
+
+            for item_j in array[(idx + 1)..].iter() {
+                if item_i == item_j {
+                    unique = false;
+                    break 'main;
+                }
+            }
+        }
+
+        if unique {
+            super::ValidationState::new()
+        } else {
+            val_error!(
+                errors::UniqueItems {
+                    path: path.to_string()
+                }
+            )
+        }
+    }
+}
\ No newline at end of file
diff --git a/rustc_deps/vendor/valico/src/lib.rs b/rustc_deps/vendor/valico/src/lib.rs
new file mode 100644
index 0000000..b1e587e
--- /dev/null
+++ b/rustc_deps/vendor/valico/src/lib.rs
@@ -0,0 +1,14 @@
+extern crate regex;
+extern crate url;
+extern crate jsonway;
+extern crate uuid;
+extern crate phf;
+#[macro_use] extern crate lazy_static;
+extern crate serde;
+extern crate serde_json;
+
+#[macro_use] pub mod common;
+pub mod json_dsl;
+pub mod json_schema;
+
+pub use common::error::{ValicoErrors};
diff --git a/rustc_deps/vendor/valico/tests/dsl/helpers.rs b/rustc_deps/vendor/valico/tests/dsl/helpers.rs
new file mode 100644
index 0000000..65e42cf
--- /dev/null
+++ b/rustc_deps/vendor/valico/tests/dsl/helpers.rs
@@ -0,0 +1,61 @@
+use serde_json::{Value, from_str, to_string};
+use valico::json_dsl;
+use valico::json_schema;
+use valico::common::error;
+
+pub fn test_result(params: &json_dsl::Builder, scope: Option<&json_schema::Scope>, body: &str) -> Value {
+    let obj = from_str(body);
+    match obj {
+        Ok(mut json) => {
+            let state = params.process(&mut json, &scope);
+            if state.is_strictly_valid() {
+                return json;
+            } else {
+                panic!("Errors during process: {:?}", state);
+            }
+        },
+        Err(_) => {
+            panic!("Invalid JSON");
+        }
+    }
+}
+
+pub fn get_errors(params: &json_dsl::Builder, scope: Option<&json_schema::Scope>, body: &str) -> Vec<Box<error::ValicoError>> {
+    let obj = from_str(body);
+    match obj {
+        Ok(mut json) => {
+            let state = params.process(&mut json, &scope);
+            if state.is_strictly_valid() {
+                panic!("Success response when we await some errors");
+            } else {
+                return state.errors;
+            }
+        },
+        Err(_) => {
+            panic!("Invalid JSON");
+        }
+    }
+}
+
+pub fn assert_str_eq_with_scope(params: &json_dsl::Builder, scope: Option<&json_schema::Scope>, body: &str, res: &str) {
+    assert_eq!(to_string(&test_result(params, scope, body)).unwrap(), res.to_string());
+}
+
+pub fn assert_error_with_scope<T: error::ValicoError + 'static>(params: &json_dsl::Builder, scope: Option<&json_schema::Scope>, body: &str, path: &str) {
+    let errors = get_errors(params, scope, body);
+    println!("{:?}", errors);
+    let error = errors.iter().find(|error| {
+        let err = error.downcast::<T>();
+        err.is_some() && err.unwrap().get_path() == path
+    });
+
+    assert!(error.is_some(), "Can't find error in {}. Errors: {:?}", path, errors)
+}
+
+pub fn assert_str_eq(params: &json_dsl::Builder, body: &str, res: &str) {
+    assert_str_eq_with_scope(params, None, body, res);
+}
+
+pub fn assert_error<T: error::ValicoError + 'static>(params: &json_dsl::Builder, body: &str, path: &str) {
+    assert_error_with_scope::<T>(params, None, body, path);
+}
diff --git a/rustc_deps/vendor/valico/tests/dsl/mod.rs b/rustc_deps/vendor/valico/tests/dsl/mod.rs
new file mode 100644
index 0000000..09dc052
--- /dev/null
+++ b/rustc_deps/vendor/valico/tests/dsl/mod.rs
@@ -0,0 +1,470 @@
+use serde_json::{Value};
+use valico::json_dsl;
+use valico::json_schema;
+use valico::json_schema::errors as schema_errors;
+use valico::json_dsl::errors;
+use regex;
+
+use self::helpers::{
+    assert_str_eq_with_scope,
+    assert_error_with_scope,
+    assert_str_eq,
+    assert_error
+};
+
+mod helpers;
+
+#[test]
+fn is_process_empty_builder() {
+    let params = json_dsl::Builder::build(|_params| { });
+    assert_str_eq(&params, r#"{"a":1}"#, r#"{"a":1}"#);
+}
+
+#[test]
+fn is_process_simple_require() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req_defined("a");
+    });
+
+    assert_str_eq(&params, r#"{"a":1}"#, r#"{"a":1}"#);
+    assert_error::<errors::Required>(&params, r#"{}"#, "/a");
+}
+
+#[test]
+fn is_process_i64_require() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req_typed("a", json_dsl::i64());
+    });
+
+    assert_str_eq(&params, r#"{"a":"1"}"#, r#"{"a":1}"#);
+
+    // truncate!
+    assert_str_eq(&params, r#"{"a": 1.112}"#, r#"{"a":1}"#);
+
+    // error because "a" is string that we can't convert
+    assert_error::<errors::WrongType>(&params, r#"{"a": "not-int"}"#, "/a");
+
+    // error because "a" is object
+    assert_error::<errors::WrongType>(&params, r#"{"a": {"a": 1}}"#, "/a");
+}
+
+#[test]
+fn is_process_string_require() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req_typed("a", json_dsl::string());
+    });
+
+    assert_str_eq(&params, r#"{"a":"1"}"#, r#"{"a":"1"}"#);
+    assert_str_eq(&params, r#"{"a":1}"#, r#"{"a":"1"}"#);
+    assert_str_eq(&params, r#"{"a":1.112}"#, r#"{"a":"1.112"}"#);
+
+    // error because "a" is object
+    assert_error::<errors::WrongType>(&params, r#"{"a": {}}"#, "/a");
+
+    // error because "a" is null
+    assert_error::<errors::WrongType>(&params, r#"{"a": null}"#, "/a");
+}
+
+#[test]
+fn is_process_boolean_require() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req_typed("a", json_dsl::boolean());
+    });
+
+    assert_str_eq(&params, r#"{"a":true}"#, r#"{"a":true}"#);
+    assert_str_eq(&params, r#"{"a":false}"#, r#"{"a":false}"#);
+    assert_str_eq(&params, r#"{"a":"true"}"#, r#"{"a":true}"#);
+    assert_str_eq(&params, r#"{"a":"false"}"#, r#"{"a":false}"#);
+
+    assert_error::<errors::WrongType>(&params, r#"{"a": null}"#, "/a");
+    assert_error::<errors::WrongType>(&params, r#"{"a": 1}"#, "/a");
+    assert_error::<errors::WrongType>(&params, r#"{"a": "not-bool"}"#, "/a");
+}
+
+#[test]
+fn is_process_simple_array_require() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req_typed("a", json_dsl::array());
+    });
+
+    assert_str_eq(&params, r#"{"a":[1,"2",[3]]}"#, r#"{"a":[1,"2",[3]]}"#);
+
+    // error because "a" is object
+    assert_error::<errors::WrongType>(&params, r#"{"a": {}}"#, "/a");
+
+    // error because "a" is string
+    assert_error::<errors::WrongType>(&params, r#"{"a": "test"}"#, "/a");
+}
+
+#[test]
+fn is_process_typed_array_require() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req_typed("a", json_dsl::array_of(json_dsl::string()));
+    });
+
+    // convert all to string
+    assert_str_eq(&params, r#"{"a":[1,"2",3.1]}"#, r#"{"a":["1","2","3.1"]}"#);
+
+    // error because "a" is object
+    assert_error::<errors::WrongType>(&params, r#"{"a": {}}"#, "/a");
+
+    // error because element at index(2) is not coersible to string
+    assert_error::<errors::WrongType>(&params, r#"{"a": [1,2,{}]}"#, "/a/2");
+
+}
+
+#[test]
+fn is_process_array_with_nested_require() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req_nested("a", json_dsl::array(), |params| {
+            params.req_typed("b", json_dsl::string());
+            params.req_typed("c", json_dsl::array_of(json_dsl::u64()))
+        });
+    });
+
+    assert_str_eq(&params, r#"{"a":[{"b":1,"c":["1"]}]}"#, r#"{"a":[{"b":"1","c":[1]}]}"#);
+
+    // error because element in "a" at index(0) is not coersible to string
+    assert_error::<errors::WrongType>(&params, r#"{"a":[{"b":{},"c":["1"]}]}"#, "/a/0/b");
+
+    // error because element in "a":0:"c":0 is not coersible to string
+    assert_error::<errors::WrongType>(&params, r#"{"a":[{"b":1,"c":[{}]}]}"#, "/a/0/c/0");
+
+}
+
+#[test]
+fn it_process_encoded_array() {
+    let params = json_dsl::Builder::build(|params| {
+        params.req_typed("a", json_dsl::encoded_array(","));
+    });
+
+    assert_str_eq(&params, r#"{"a":"a,b,c"}"#, r#"{"a":["a","b","c"]}"#);
+}
+
+#[test]
+fn it_process_encoded_array_of_type() {
+    let params = json_dsl::Builder::build(|params| {
+        params.req_typed("a", json_dsl::encoded_array_of(",", json_dsl::u64()));
+    });
+
+    assert_str_eq(&params, r#"{"a":"1,2,3"}"#, r#"{"a":[1,2,3]}"#);
+}
+
+#[test]
+fn is_process_object_require() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req_typed("a", json_dsl::object());
+    });
+
+    assert_str_eq(&params, r#"{"a":{}}"#, r#"{"a":{}}"#);
+
+    // error because "a" is array, not object
+    assert_error::<errors::WrongType>(&params, r#"{"a":[]}"#, "/a");
+
+    // error because "a" is string, not object
+    assert_error::<errors::WrongType>(&params, r#"{"a":""}"#, "/a");
+
+}
+
+#[test]
+fn is_process_object_with_nested_require() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req_nested("a", json_dsl::object(), |params| {
+            params.req_typed("b", json_dsl::f64());
+            params.req_typed("c", json_dsl::array_of(json_dsl::string()));
+        });
+    });
+
+    assert_str_eq(&params, r#"{"a":{"b":"1.22","c":[1.112,""]}}"#, r#"{"a":{"b":1.22,"c":["1.112",""]}}"#);
+
+    // error because "a":"b" is not a f64
+    assert_error::<errors::WrongType>(&params, r#"{"a":{"b":"not-f64"},"c":[1.112,""]}"#, "/a/b");
+
+    // error because "a":"c":"1" is object and can't be coerced to string
+    assert_error::<errors::WrongType>(&params, r#"{"a":{"b":"1.22","c":[1.112,{}]}}"#, "/a/c/1");
+
+}
+
+#[test]
+fn is_process_require_allows_null() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req("a", |a| {
+            a.coerce(json_dsl::string());
+        })
+    });
+
+    // error because a is not allow null explicitly
+    assert_error::<errors::WrongType>(&params, r#"{"a":null}"#, "/a");
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req("a", |a| {
+            a.coerce(json_dsl::string());
+            a.allow_null();
+        })
+    });
+
+    // ok because "a" allows null explicitly
+    assert_str_eq(&params, r#"{"a":null}"#, r#"{"a":null}"#);
+}
+
+
+#[test]
+fn is_validates_allow_values() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req("a", |a| {
+            a.coerce(json_dsl::string());
+            a.allow_values(&["allowed1".to_string(), "allowed2".to_string()])
+        })
+    });
+
+    assert_str_eq(&params, r#"{"a":"allowed1"}"#, r#"{"a":"allowed1"}"#);
+    assert_str_eq(&params, r#"{"a":"allowed2"}"#, r#"{"a":"allowed2"}"#);
+
+    // error because "a" is not in allowed list
+    assert_error::<errors::WrongValue>(&params, r#"{"a":"not in allowed"}"#, "/a");
+
+}
+
+#[test]
+fn is_validates_reject_values() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req("a", |a| {
+            a.coerce(json_dsl::string());
+            a.reject_values(&["rejected1".to_string(), "rejected2".to_string()])
+        })
+    });
+
+    assert_str_eq(&params, r#"{"a":"some"}"#, r#"{"a":"some"}"#);
+
+    // errors because "a" is in reject list
+    assert_error::<errors::WrongValue>(&params, r#"{"a":"rejected1"}"#, "/a");
+    assert_error::<errors::WrongValue>(&params, r#"{"a":"rejected2"}"#, "/a");
+
+}
+
+#[test]
+fn is_validates_with_function_validator() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req("a", |a| {
+            a.coerce(json_dsl::u64());
+            a.validate_with(|val: &Value, path: &str| {
+                if *val == Value::Number(::serde_json::Number::from(2u64)) {
+                    Ok(())
+                } else {
+                    Err(vec![
+                        Box::new(errors::WrongType {
+                            path: path.to_string(),
+                            detail: "Value is not exactly 2".to_string()
+                        })
+                    ])
+                }
+            });
+        })
+    });
+
+    assert_str_eq(&params, r#"{"a":"2"}"#, r#"{"a":2}"#);
+    assert_error::<errors::WrongType>(&params, r#"{"a":3}"#, "/a");
+    assert_error::<errors::WrongType>(&params, r#"{"a":"3"}"#, "/a");
+
+}
+
+#[test]
+fn is_validates_with_regex() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req("a", |a| {
+            a.coerce(json_dsl::string());
+            a.regex(regex::Regex::new("^test$").unwrap());
+        })
+    });
+
+    assert_str_eq(&params, r#"{"a":"test"}"#, r#"{"a":"test"}"#);
+
+    // error because "a" is not match regex
+    assert_error::<errors::WrongValue>(&params, r#"{"a":"2"}"#, "/a");
+    assert_error::<errors::WrongValue>(&params, r#"{"a":"test "}"#, "/a");
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req("a", |a| {
+            // regex can't be applied to list, so it will never be valid
+            a.coerce(json_dsl::array());
+            a.regex(regex::Regex::new("^test$").unwrap());
+        })
+    });
+
+    // "a" is valid list but it can't pass regex validation
+    assert_error::<errors::WrongType>(&params, r#"{"a":[]}"#, "/a");
+
+}
+
+#[test]
+fn is_validates_opt() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.req_defined("a");
+        params.opt_typed("b", json_dsl::u64());
+    });
+
+    // ok because a is optional
+    assert_str_eq(&params, r#"{"a":"test"}"#, r#"{"a":"test"}"#);
+    assert_str_eq(&params, r#"{"a":"test","b":"1"}"#, r#"{"a":"test","b":1}"#);
+
+}
+
+#[test]
+fn is_validates_opt_with_default() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.opt("a", |a| {
+            a.default("default".to_string());
+        });
+    });
+
+    assert_str_eq(&params, r#"{"a":"test"}"#, r#"{"a":"test"}"#);
+    assert_str_eq(&params, r#"{}"#, r#"{"a":"default"}"#);
+
+}
+
+#[test]
+fn is_validates_mutually_exclusive() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.opt_defined("a");
+        params.opt_defined("b");
+
+        params.mutually_exclusive(&["a", "b"])
+    });
+
+    assert_str_eq(&params, r#"{"a":1}"#, r#"{"a":1}"#);
+    assert_str_eq(&params, r#"{"b":1}"#, r#"{"b":1}"#);
+    assert_str_eq(&params, r#"{}"#, r#"{}"#);
+
+    assert_error::<errors::MutuallyExclusive>(&params, r#"{"a":1,"b":1}"#, "/");
+
+}
+
+#[test]
+fn is_validates_exactly_one_of() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.opt_defined("a");
+        params.opt_defined("b");
+
+        params.exactly_one_of(&["a", "b"])
+    });
+
+    assert_str_eq(&params, r#"{"a":1}"#, r#"{"a":1}"#);
+    assert_str_eq(&params, r#"{"b":1}"#, r#"{"b":1}"#);
+
+    assert_error::<errors::ExactlyOne>(&params, r#"{}"#, "/");
+    assert_error::<errors::ExactlyOne>(&params, r#"{"a":1,"b":1}"#, "/");
+
+}
+
+#[test]
+fn is_validates_at_least_one_of() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.opt_defined("a");
+        params.opt_defined("b");
+
+        params.at_least_one_of(&["a", "b"])
+    });
+
+    assert_str_eq(&params, r#"{"a":1}"#, r#"{"a":1}"#);
+    assert_str_eq(&params, r#"{"b":1}"#, r#"{"b":1}"#);
+    assert_str_eq(&params, r#"{"a":1,"b":1}"#, r#"{"a":1,"b":1}"#);
+
+    assert_error::<errors::AtLeastOne>(&params, r#"{}"#, "/");
+
+}
+
+#[test]
+fn is_validates_with_function() {
+
+    let params = json_dsl::Builder::build(|params| {
+        params.opt_defined("a");
+        params.opt_defined("b");
+
+        params.validate_with(|_: &Value, path: &str| {
+            Err(vec![
+                Box::new(errors::WrongType{
+                    path: path.to_string(),
+                    detail: "You shall not pass!".to_string()
+                })
+            ])
+        });
+    });
+
+    assert_error::<errors::WrongType>(&params, r#"{}"#, "/");
+
+}
+
+#[test]
+fn it_validates_with_schema() {
+    let mut params = json_dsl::Builder::build(|params| {
+        params.opt_typed("a", json_dsl::u64());
+        params.opt_typed("b", json_dsl::u64());
+        params.schema(|schema| {
+            schema.max_properties(2);
+        })
+    });
+
+    let mut scope = json_schema::Scope::new();
+    params.build_schemes(&mut scope).unwrap();
+
+    assert_str_eq_with_scope(&params, Some(&scope), r#"{"a":1, "b": 1}"#, r#"{"a":1,"b":1}"#);
+    assert_error_with_scope::<schema_errors::MaxProperties>(&params, Some(&scope), r#"{"a":1, "b": 1, "c": 1}"#, "/");
+}
+
+#[test]
+fn it_validates_params_with_schema() {
+    let mut params = json_dsl::Builder::build(|params| {
+        params.req("a", |a| {
+            a.schema(|schema| {
+                schema.integer();
+                schema.maximum(10f64, false);
+            })
+        });
+    });
+
+    let mut scope = json_schema::Scope::new();
+    params.build_schemes(&mut scope).unwrap();
+
+    assert_str_eq_with_scope(&params, Some(&scope), r#"{"a":1}"#, r#"{"a":1}"#);
+    assert_error_with_scope::<schema_errors::Maximum>(&params, Some(&scope), r#"{"a":11}"#, "/a");
+    assert_error_with_scope::<schema_errors::WrongType>(&params, Some(&scope), r#"{"a":"test"}"#, "/a");
+}
+
+#[test]
+fn it_validates_params_with_schema_and_coercion() {
+    let mut params = json_dsl::Builder::build(|params| {
+        params.req("a", |a| {
+            a.coerce(json_dsl::u64());
+            a.schema(|schema| {
+                schema.maximum(10f64, false);
+            })
+        });
+    });
+
+    let mut scope = json_schema::Scope::new();
+    params.build_schemes(&mut scope).unwrap();
+
+    assert_str_eq_with_scope(&params, Some(&scope), r#"{"a":1}"#, r#"{"a":1}"#);
+    assert_str_eq_with_scope(&params, Some(&scope), r#"{"a":"10"}"#, r#"{"a":10}"#);
+    assert_error_with_scope::<schema_errors::Maximum>(&params, Some(&scope), r#"{"a":"11"}"#, "/a");
+    assert_error_with_scope::<errors::WrongType>(&params, Some(&scope), r#"{"a":"test"}"#, "/a");
+}
diff --git a/rustc_deps/vendor/valico/tests/schema/JSON-Schema-Test-Suite/LICENSE b/rustc_deps/vendor/valico/tests/schema/JSON-Schema-Test-Suite/LICENSE
new file mode 100644
index 0000000..c28adba
--- /dev/null
+++ b/rustc_deps/vendor/valico/tests/schema/JSON-Schema-Test-Suite/LICENSE
@@ -0,0 +1,19 @@
+Copyright (c) 2012 Julian Berman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/rustc_deps/vendor/valico/tests/schema/JSON-Schema-Test-Suite/README.md b/rustc_deps/vendor/valico/tests/schema/JSON-Schema-Test-Suite/README.md
new file mode 100644
index 0000000..6d9da94
--- /dev/null
+++ b/rustc_deps/vendor/valico/tests/schema/JSON-Schema-Test-Suite/README.md
@@ -0,0 +1,148 @@
+JSON Schema Test Suite [![Build Status](https://travis-ci.org/json-schema/JSON-Schema-Test-Suite.png?branch=develop)](https://travis-ci.org/json-schema/JSON-Schema-Test-Suite)
+======================
+
+This repository contains a set of JSON objects that implementors of JSON Schema
+validation libraries can use to test their validators.
+
+It is meant to be language agnostic and should require only a JSON parser.
+
+The conversion of the JSON objects into tests within your test framework of
+choice is still the job of the validator implementor.
+
+Structure of a Test
+-------------------
+
+If you're going to use this suite, you need to know how tests are laid out. The
+tests are contained in the `tests` directory at the root of this repository.
+
+Inside that directory is a subdirectory for each draft or version of the
+schema. We'll use `draft3` as an example.
+
+If you look inside the draft directory, there are a number of `.json` files,
+which logically group a set of test cases together. Often the grouping is by
+property under test, but not always, especially within optional test files
+(discussed below).
+
+Inside each `.json` file is a single array containing objects. It's easiest to
+illustrate the structure of these with an example:
+
+```json
+    {
+        "description": "the description of the test case",
+        "schema": {"the schema that should" : "be validated against"},
+        "tests": [
+            {
+                "description": "a specific test of a valid instance",
+                "data": "the instance",
+                "valid": true
+            },
+            {
+                "description": "another specific test this time, invalid",
+                "data": 15,
+                "valid": false
+            }
+        ]
+    }
+```
+
+So a description, a schema, and some tests, where tests is an array containing
+one or more objects with descriptions, data, and a boolean indicating whether
+they should be valid or invalid.
+
+Coverage
+--------
+
+Draft 3 and 4 should have full coverage. If you see anything missing or think
+there is a useful test missing, please send a pull request or open an issue.
+
+Who Uses the Test Suite
+-----------------------
+
+This suite is being used by:
+
+### Coffeescript ###
+
+* [jsck](https://github.com/pandastrike/jsck)
+
+### Dart ###
+
+* [json_schema](https://github.com/patefacio/json_schema) 
+
+### Erlang ###
+
+* [jesse](https://github.com/klarna/jesse)
+
+### Go ###
+
+* [gojsonschema](https://github.com/sigu-399/gojsonschema) 
+* [validate-json](https://github.com/cesanta/validate-json)
+
+### Haskell ###
+
+* [aeson-schema](https://github.com/timjb/aeson-schema)
+* [hjsonschema](https://github.com/seagreen/hjsonschema)
+
+### Java ###
+
+* [json-schema-validator](https://github.com/fge/json-schema-validator)
+
+### JavaScript ###
+
+* [json-schema-benchmark](https://github.com/Muscula/json-schema-benchmark)
+* [direct-schema](https://github.com/IreneKnapp/direct-schema)
+* [is-my-json-valid](https://github.com/mafintosh/is-my-json-valid)