[rust] add memchr and utf8parse. remove encode_unicode

memchr and utf8parse are required by rustyline
encode_unicode is no longer required by rustyline

OSRB: https://fuchsia.atlassian.net/browse/OSRB-75

Testing: Built Fuchsia with these crate changes made.
Change-Id: I3487da878ea1aa94ee28d4181277d056ff70bb0b
diff --git a/rustc_deps/Cargo.lock b/rustc_deps/Cargo.lock
index 3404a3c..500e0d2 100644
--- a/rustc_deps/Cargo.lock
+++ b/rustc_deps/Cargo.lock
@@ -247,11 +247,6 @@
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
-name = "encode_unicode"
-version = "0.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
 name = "encoding"
 version = "0.2.33"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -382,7 +377,6 @@
  "chrono 0.4.6 (registry+https://github.com/rust-lang/crates.io-index)",
  "clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "crossbeam 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)",
- "encode_unicode 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "euclid 0.19.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "failure 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
  "font-rs 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -393,6 +387,7 @@
  "lazy_static 0.1.16 (registry+https://github.com/rust-lang/crates.io-index)",
  "libc 0.2.43 (registry+https://github.com/rust-lang/crates.io-index)",
  "log 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
+ "memchr 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "net2 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)",
  "nom 3.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "num 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -417,6 +412,7 @@
  "unicode-segmentation 1.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
  "url 1.7.1 (registry+https://github.com/rust-lang/crates.io-index)",
+ "utf8parse 0.1.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",
@@ -1496,7 +1492,6 @@
 "checksum deflate 0.7.19 (registry+https://github.com/rust-lang/crates.io-index)" = "8a6abb26e16e8d419b5c78662aa9f82857c2386a073da266840e474d5055ec86"
 "checksum digest 0.7.6 (registry+https://github.com/rust-lang/crates.io-index)" = "03b072242a8cbaf9c145665af9d250c59af3b958f83ed6824e13533cf76d5b90"
 "checksum either 1.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "3be565ca5c557d7f59e7cfcf1844f9e3033650c929c6566f511e8005f205c1d0"
-"checksum encode_unicode 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "28d65f1f5841ef7c6792861294b72beda34c664deb8be27970f36c306b7da1ce"
 "checksum encoding 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)" = "6b0d943856b990d12d3b55b359144ff341533e516d94098b1d3fc1ac666d36ec"
 "checksum encoding-index-japanese 1.20141219.5 (registry+https://github.com/rust-lang/crates.io-index)" = "04e8b2ff42e9a05335dbf8b5c6f7567e5591d0d916ccef4e0b1710d32a0d0c91"
 "checksum encoding-index-korean 1.20141219.5 (registry+https://github.com/rust-lang/crates.io-index)" = "4dc33fb8e6bcba213fe2f14275f0963fd16f0a02c878e3095ecfdf5bee529d81"
diff --git a/rustc_deps/Cargo.toml b/rustc_deps/Cargo.toml
index ddf71d7..95e7233 100644
--- a/rustc_deps/Cargo.toml
+++ b/rustc_deps/Cargo.toml
@@ -18,7 +18,6 @@
 chrono = "0.4.2"
 clap = "2.29"
 crossbeam = "0.3.2"
-encode_unicode = "0.1.3"
 euclid = "0.19"
 failure = "0.1.1"
 font-rs = "0.1.3"
@@ -29,6 +28,7 @@
 lazy_static = "0.1"
 libc = "0.2"
 log = { version = "0.4.4", features = ["std"] }
+memchr = "2.0"
 net2 = "0.2"
 nom = "3.2"
 num = "0.1"
@@ -52,6 +52,7 @@
 unicase = "2.2.0"
 unicode-segmentation = "1.0"
 unicode-width = "0.1.3"
+utf8parse = "0.1"
 url = "1.7.0"
 vte = "0.3"
 xi-core-lib = { version = "0.2.0", default-features = false } # disable "notify" crate
diff --git a/rustc_deps/vendor/encode_unicode/.cargo-checksum.json b/rustc_deps/vendor/encode_unicode/.cargo-checksum.json
deleted file mode 100644
index a7388c5..0000000
--- a/rustc_deps/vendor/encode_unicode/.cargo-checksum.json
+++ /dev/null
@@ -1 +0,0 @@
-{"files":{"Cargo.toml":"7a332159e56fb478b9a35e403ca494dd230e4c239b449f293b73c5c582ce6587","LICENSE-APACHE":"cfc7749b96f63bd31c3c42b5c471bf756814053e847c10f3eb003417bc523d30","LICENSE-MIT":"629c4212f7b7d7669a2356639903720f661d9ee890fee70f18663862e045fa42","README.md":"ea27d350eec0d77fdc6ad52ec9de3f8c3f48bd00c705fdb8bb3bf59a4c7ce79e","src/errors.rs":"1e05de4001b98131d0a0b5e441a660445e338b12b6af3aa991397987df427dc4","src/lib.rs":"193453714154c122f33e1eb65fdee67cef0e10dff9f316fb5245fc48a233095e","src/traits.rs":"3ce2a4340454483e2b3ea52a4abe2dbe4a5c1d4a31ebdf286b62de5e6bbcd3a6","src/utf16_char.rs":"78fe2d79e160ebba6621f2206c0c972ed07e0ae72e93bad59e7164df62a61d5e","src/utf16_iterator.rs":"9e727543b40a9bf85f4ccc293de449b02dc7a992b2978da08cee7a98d9045d8e","src/utf8_char.rs":"c4bc3b27ef1d9de65a29e3f5329bf61adfcf2ce78f07c1cb869a389ffa450390","src/utf8_iterator.rs":"ba2ffe56040db7f06044ddf7325144756f54ceb799f6f2921a8d07af2fcdac3e","tests/fail_tests.rs":"e12930ca7097eb2ece5037e9b4e9c7ff25b862cc57453a92ffd008462df6b273","tests/iterator_tests.rs":"ede7c8cf2ae0f331653c218f061b920bcd7429b5ab9169c3be92ebfa6699a1b0","tests/pass_tests.rs":"a9e9ad99750fb88fead790b71e8a0dd3466b75dd14dc3949169320f9bc467328"},"package":"28d65f1f5841ef7c6792861294b72beda34c664deb8be27970f36c306b7da1ce"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/encode_unicode/Cargo.toml b/rustc_deps/vendor/encode_unicode/Cargo.toml
deleted file mode 100644
index 7d0c7ce..0000000
--- a/rustc_deps/vendor/encode_unicode/Cargo.toml
+++ /dev/null
@@ -1,16 +0,0 @@
-[package]
-name = "encode_unicode"
-keywords = ["unicode"]
-description = """
-Alternative and extension to the unstable `char.encode_utf8()` and char.encode_utf16()` methods.
-"""
-readme = "README.md"
-version = "0.1.3"
-license = "MIT/Apache-2.0"
-repository = "https://github.com/tormol/encode_unicode"
-documentation = "http://tormol.github.io/rustdoc/encode_unicode"
-authors = ["Torbjørn Birch Moltu <t.b.moltu@lyse.net>"]
-
-[dependencies]
-ascii = {optional=true, version="0.6"}
-clippy = {optional=true, version="0.*"}# wildest wildcard crates.io will allow.
diff --git a/rustc_deps/vendor/encode_unicode/LICENSE-APACHE b/rustc_deps/vendor/encode_unicode/LICENSE-APACHE
deleted file mode 100644
index d645695..0000000
--- a/rustc_deps/vendor/encode_unicode/LICENSE-APACHE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 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/encode_unicode/LICENSE-MIT b/rustc_deps/vendor/encode_unicode/LICENSE-MIT
deleted file mode 100644
index be5235a..0000000
--- a/rustc_deps/vendor/encode_unicode/LICENSE-MIT
+++ /dev/null
@@ -1,19 +0,0 @@
-+Copyright (c) 2016 encode-unicode 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/encode_unicode/README.md b/rustc_deps/vendor/encode_unicode/README.md
deleted file mode 100644
index 8ac8f52..0000000
--- a/rustc_deps/vendor/encode_unicode/README.md
+++ /dev/null
@@ -1,38 +0,0 @@
-# encode_unicode
-Alternative and extension to to the unstable `char.encode_utf8()` and `char.encode_utf16()`.
-
-The goal was to fill in those methods for stable via a trait,
-but that didn't work since the methods already exist; they're just un-callable.
-
-## Contains:
-* **Utf8Char**: A `char` stored as UTF-8. Can be borrowed as a `str`.
-* **Utf8Iterator**: Iterate over or read the bytes of an UTF-8 codepoint.
-* **Utf16Char**: A `char` stored as UTF-16. Can be borrowed as a `u16` slice.
-* **Utf8Iterator**: Iterate over the units of an UTF-16 codepoint.
-* **Conversion methods on `char`**:
-  * to UTF-8 as `[u8; 4]` or into `&mut[u8]`. and vice versa.
-  * to UTF-16 as `(u16, Option<u16>)` or into `&mut[u16]`. and vice versa.
-* **Precise errors when decoding a char from UTF-8, UTF-16 or `u32` fails.**
-
-## Feature flags:
-(both require nightly)
-* **ascii**: Implement `AsciiExt` and integrate with [ascii](https://tomprogrammer.github.io/rust-ascii/ascii/index.html)::`Ascii`.
-* **clippy**: Get extra warnings, see lib.rs for why I haven't fixed or `allow()`ed them.
-
-The unit tests only work on nightly since they use encode_utf{8,16}() as a reference.
-
-## 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/encode_unicode/src/errors.rs b/rustc_deps/vendor/encode_unicode/src/errors.rs
deleted file mode 100644
index fa129d2..0000000
--- a/rustc_deps/vendor/encode_unicode/src/errors.rs
+++ /dev/null
@@ -1,241 +0,0 @@
-/* Copyright 2016 Torbjørn Birch Moltu
- *
- * 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.
- */
-
-
-//! Boilerplatey error enums
-
-
-extern crate std;
-use std::fmt::{self,Display,Formatter};
-use std::error::Error;
-
-
-
-/// Reason why Utf8Char::from_str() failed.
-#[derive(Clone,Copy, Debug, PartialEq,Eq)]
-pub enum FromStrError {
-    /// Utf8Char cannot store more than a single codepoint.
-    SeveralCodePoints,
-    /// Utf8Char cannot be empty.
-    Empty,
-}
-use self::FromStrError::*;
-impl Error for FromStrError {
-    fn description(&self) -> &'static str {match *self {
-        SeveralCodePoints => "has more than one codepoint",
-        Empty => "is empty",
-    }}
-}
-impl Display for FromStrError {
-    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
-        write!(fmtr, "{}", self.description())
-    }
-}
-
-
-
-/// Reasons why an u32 is not a valid utf codepoint.
-#[derive(Clone,Copy, Debug, PartialEq,Eq)]
-pub enum InvalidCodePoint {
-    /// It's reserved for utf-16 surrogate pairs.
-    Utf16Reserved,
-    /// It's higher than the highest codepoint of 0x10ffff.
-    TooHigh,
-}
-use self::InvalidCodePoint::*;
-impl InvalidCodePoint {
-    /// Get the range of values for which this error would be given.
-    pub fn error_range(self) -> (u32,u32) {match self {
-        Utf16Reserved => (0xd8_00, 0xdf_ff),
-        TooHigh => (0x00_10_ff_ff, 0xff_ff_ff_ff),
-    }}
-}
-impl Error for InvalidCodePoint {
-    fn description(&self) -> &'static str {match *self {
-        Utf16Reserved => "is reserved for utf-16 surrogate pairs",
-        TooHigh => "is higher than the highest codepoint of 0x10ffff",
-    }}
-}
-impl Display for InvalidCodePoint {
-    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
-        write!(fmtr, "{}", self.description())
-    }
-}
-
-
-
-/// Reasons why a byte is not the start of a UTF-8 codepoint.
-#[derive(Clone,Copy, Debug, PartialEq,Eq)]
-pub enum InvalidUtf8FirstByte {
-    /// Sequences cannot be longer than 4 bytes. Is given for bytes >= 240.
-    TooLongSeqence,
-    /// This byte belongs to a previous seqence. Is given for values between 128 and 192 (exclusive).
-    ContinuationByte,
-}
-use self::InvalidUtf8FirstByte::*;
-impl Error for InvalidUtf8FirstByte {
-    fn description(&self) -> &'static str {match *self {
-        TooLongSeqence => "is greater than 239 (UTF-8 seqences cannot be longer than four bytes)",
-        ContinuationByte => "is a continuation of a previous sequence",
-    }}
-}
-impl Display for InvalidUtf8FirstByte {
-    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
-        write!(fmtr, "{}", self.description())
-    }
-}
-
-
-/// Reasons why a byte sequence is not valid UTF-8, excluding invalid codepoint.
-/// In sinking precedence.
-#[derive(Clone,Copy, Debug, PartialEq,Eq)]
-pub enum InvalidUtf8 {
-    /// Something is certainly wrong with the first byte.
-    FirstByte(InvalidUtf8FirstByte),
-    /// One of the continuation bytes doesnt fit the pattern 0b10xx_xxxx.
-    NotAContinuationByte(usize),
-    /// There are too many leading zeros; it could be a byte shorter.
-    OverLong,
-}
-use self::InvalidUtf8::*;
-impl Error for InvalidUtf8 {
-    fn description(&self) -> &'static str {match *self {
-        FirstByte(TooLongSeqence) => "the first byte is greater than 239 (UTF-8 seqences cannot be longer than four bytes)",
-        FirstByte(ContinuationByte) => "the first byte is a continuation of a previous sequence",
-        OverLong => "the seqence contains too many zeros and could be shorter",
-        NotAContinuationByte(_) => "the sequence is too short",
-    }}
-    /// When `Some` is returned, the `Error` is a `InvalidUtf8FirstByte`.
-    fn cause(&self) -> Option<&Error> {match *self {
-        FirstByte(ref cause) => Some(cause),
-        _ => None,
-    }}
-}
-impl Display for InvalidUtf8 {
-    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
-        write!(fmtr, "{}", self.description())
-    }
-}
-
-
-/// Reasons why a byte array is not valid UTF-8, in sinking precedence.
-#[derive(Clone,Copy, Debug, PartialEq,Eq)]
-pub enum InvalidUtf8Array {
-    /// Something is certainly wrong with the first byte.
-    Utf8(InvalidUtf8),
-    /// The encoded codepoint is invalid:
-    CodePoint(InvalidCodePoint),
-}
-impl Error for InvalidUtf8Array {
-    fn description(&self) -> &'static str {match *self {
-        InvalidUtf8Array::Utf8(_) => "the seqence is invalid UTF-8",
-        InvalidUtf8Array::CodePoint(_) => "the encoded codepoint is invalid",
-    }}
-    /// Always returns `Some`.
-    fn cause(&self) -> Option<&Error> {match *self {
-        InvalidUtf8Array::Utf8(ref u) => Some(u),
-        InvalidUtf8Array::CodePoint(ref c) => Some(c),
-    }}
-}
-impl Display for InvalidUtf8Array {
-    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
-        write!(fmtr, "{}: {}", self.description(), self.cause().unwrap().description())
-    }
-}
-
-
-/// Reasons why a byte slice is not valid UTF-8, in sinking precedence.
-#[derive(Clone,Copy, Debug, PartialEq,Eq)]
-pub enum InvalidUtf8Slice {
-    /// Something is certainly wrong with the first byte.
-    Utf8(InvalidUtf8),
-    /// The encoded codepoint is invalid:
-    CodePoint(InvalidCodePoint),
-    /// The slice is too short; n bytes was required.
-    TooShort(usize),
-}
-impl Error for InvalidUtf8Slice {
-    fn description(&self) -> &'static str {match *self {
-        InvalidUtf8Slice::Utf8(_) => "the seqence is invalid UTF-8",
-        InvalidUtf8Slice::CodePoint(_) => "the encoded codepoint is invalid",
-        InvalidUtf8Slice::TooShort(0) => "the slice is empty",
-        InvalidUtf8Slice::TooShort(_) => "the slice is shorter than the seqence",
-    }}
-    fn cause(&self) -> Option<&Error> {match *self {
-        InvalidUtf8Slice::Utf8(ref u) => Some(u),
-        InvalidUtf8Slice::CodePoint(ref c) => Some(c),
-        InvalidUtf8Slice::TooShort(_) => None,
-    }}
-}
-impl Display for InvalidUtf8Slice {
-    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
-        match self.cause() {
-            Some(d) => write!(fmtr, "{}: {}", self.description(), d),
-            None    => write!(fmtr, "{}", self.description()),
-        }
-    }
-}
-
-
-
-/// Reasons why one or two `u16`s are not valid UTF-16, in sinking precedence.
-#[derive(Clone,Copy, Debug, PartialEq,Eq)]
-pub enum InvalidUtf16Tuple {
-    /// The first unit is a trailing/low surrogate, which is never valid.
-    ///
-    /// Note that the value of a low surrogate is actually higher than a high surrogate.
-    FirstIsTrailingSurrogate,
-    /// You provided a second unit, but the first one stands on its own.
-    SuperfluousSecond,
-    /// The first and only unit requires a second unit.
-    MissingSecond,
-    /// The first unit requires a second unit, but it's not a trailing/low surrogate.
-    ///
-    /// Note that the value of a low surrogate is actually higher than a high surrogate.
-    InvalidSecond,
-}
-impl Error for InvalidUtf16Tuple {
-    fn description(&self) -> &'static str {match *self {
-        InvalidUtf16Tuple::FirstIsTrailingSurrogate => "the first unit is a trailing / low surrogate, which is never valid",
-        InvalidUtf16Tuple::SuperfluousSecond => "the second unit is superfluous",
-        InvalidUtf16Tuple::MissingSecond => "the first unit requires a second unit",
-        InvalidUtf16Tuple::InvalidSecond => "the required second unit is not a trailing / low surrogate",
-    }}
-}
-impl Display for InvalidUtf16Tuple {
-    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
-        write!(fmtr, "{}", self.description())
-    }
-}
-
-
-/// Reasons why a slice of `u16`s doesn't start with valid UTF-16.
-#[derive(Clone,Copy, Debug, PartialEq,Eq)]
-pub enum InvalidUtf16Slice {
-    /// The slice is empty.
-    EmptySlice,
-    /// The first unit is a low surrogate.
-    FirstLowSurrogate,
-    /// The first and only unit requires a second unit.
-    MissingSecond,
-    /// The first unit requires a second one, but it's not a low surrogate.
-    SecondNotLowSurrogate,
-}
-impl Error for InvalidUtf16Slice {
-    fn description(&self) -> &'static str {match *self {
-        InvalidUtf16Slice::EmptySlice => "the slice is empty",
-        InvalidUtf16Slice::FirstLowSurrogate => "the first unit is a low surrogate",
-        InvalidUtf16Slice::MissingSecond => "the first and only unit requires a second one",
-        InvalidUtf16Slice::SecondNotLowSurrogate => "the required second unit is not a low surrogate",
-    }}
-}
-impl Display for InvalidUtf16Slice {
-    fn fmt(&self,  fmtr: &mut Formatter) -> fmt::Result {
-        write!(fmtr, "{}", self.description())
-    }
-}
diff --git a/rustc_deps/vendor/encode_unicode/src/lib.rs b/rustc_deps/vendor/encode_unicode/src/lib.rs
deleted file mode 100644
index ceada56..0000000
--- a/rustc_deps/vendor/encode_unicode/src/lib.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-/* Copyright 2016 Torbjørn Birch Moltu
- *
- * 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.
- */
-
-
-//! Alternative and extension to the unstable `char.encode_utf8()` and `char.encode_utf16()`.
-
-
-// warnings
-#![warn(missing_docs)]
-#![cfg_attr(feature="clippy", feature(plugin))]
-#![cfg_attr(feature="clippy", plugin(clippy))]
-#![cfg_attr(feature="clippy", allow(len_without_is_empty))]// UtfxChar is never empty
-#![cfg_attr(feature="clippy", allow(match_same_arms))]
-#![cfg_attr(feature="clippy", allow(derive_hash_xor_eq))]// tested
-// precedence: I prefer spaces to parentheses, but it's nice to recheck.
-
-#![cfg_attr(feature="ascii", feature(ascii))]// one is a crate, the other is a std feature
-
-mod errors;
-mod traits;
-mod utf8_char;
-mod utf8_iterator;
-mod utf16_char;
-mod utf16_iterator;
-
-pub use traits::CharExt;
-pub use utf8_char::Utf8Char;
-pub use utf16_char::Utf16Char;
-pub use utf8_iterator::Utf8Iterator;
-pub use utf16_iterator::Utf16Iterator;
-pub use traits::U8UtfExt;
-pub use traits::U16UtfExt;
-
-pub mod error {// keeping the public interface in one file
-    //! Errors returned by various conversion methods in this crate.
-    pub use utf8_char::FromStrError;
-    pub use errors::{InvalidCodePoint};
-    pub use errors::{InvalidUtf8FirstByte,InvalidUtf8};
-    pub use errors::{InvalidUtf8Slice,InvalidUtf16Slice};
-    pub use errors::{InvalidUtf8Array,InvalidUtf16Tuple};
-}
diff --git a/rustc_deps/vendor/encode_unicode/src/traits.rs b/rustc_deps/vendor/encode_unicode/src/traits.rs
deleted file mode 100644
index 3850e52..0000000
--- a/rustc_deps/vendor/encode_unicode/src/traits.rs
+++ /dev/null
@@ -1,370 +0,0 @@
-/* Copyright 2016 Torbjørn Birch Moltu
- *
- * 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.
- */
-
-#![allow(unused_unsafe)]// explicit unsafe{} blocks in unsafe functions are a good thing.
-
-use Utf8Char;
-use Utf16Char;
-use Utf8Iterator;
-use Utf16Iterator;
-use error::*;
-extern crate std;
-use std::{char,u32, mem};
-use std::ops::Not;
-
-// TODO better docs and tests
-
-/// Methods for working with `u8`s UTF-8.
-pub trait U8UtfExt {
-    /// How many more bytes will you need to complete this codepoint?
-    /// Failures:
-    ///
-    /// * `128..192`: ContinuationByte
-    /// * `240..`: TooLongSequence
-    fn extra_utf8_bytes(self) -> Result<usize,InvalidUtf8FirstByte>;
-
-    /// How many more bytes will you need to complete this codepoint?
-    /// Assumes that self is a valid UTF-8 start.
-    /// Returns `self.not().leading_zeros().saturating_sub(1)`
-    fn extra_utf8_bytes_unchecked(self) -> usize;
-}
-
-impl U8UtfExt for u8 {
-    fn extra_utf8_bytes(self) -> Result<usize,InvalidUtf8FirstByte> {
-        use error::InvalidUtf8FirstByte::{ContinuationByte,TooLongSeqence};
-        match self.not().leading_zeros() {
-            0           =>  Ok(0),// ascii
-            1           =>  Err(ContinuationByte),// following byte
-            n if n < 5  =>  Ok(n as usize-1),// start of multibyte
-            _           =>  Err(TooLongSeqence),// too big
-        }
-    }
-    fn extra_utf8_bytes_unchecked(self) -> usize {
-        (self.not().leading_zeros()as usize).saturating_sub(1)
-    }
-}
-
-
-/// Methods for working with `u16`s as UTF-16 units.
-pub trait U16UtfExt {
-    /// Will you need an extra unit to complete this codepoint?
-    ///
-    /// # Failures:
-    ///
-    /// 0xdc00..0xe000
-    fn utf16_needs_extra_unit(self) -> Option<bool>;
-
-    /// Does this `u16` need another `u16` to complete a codepoint?
-    /// Returns `(self & 0xfc00) == 0xd800`
-    fn utf16_is_leading_surrogate(self) -> bool;
-}
-impl U16UtfExt for u16 {
-    fn utf16_needs_extra_unit(self) -> Option<bool> {match self {
-        // https://en.wikipedia.org/wiki/UTF-16#U.2B10000_to_U.2B10FFFF
-        0x_dc_00...0x_df_ff => None,
-        0x_d8_00...0x_db_ff => Some(true),
-        _                   => Some(false),
-    }}
-
-    fn utf16_is_leading_surrogate(self) -> bool {
-        (self & 0xfc00) == 0xd800// Clear the ten content bytes of a surrogate,
-                                 // and see if it's a leading surrogate.
-    }
-}
-
-
-
-
-/// Extension trait for `char` that adds methods for converting to and from UTF-8 or UTF-16.
-pub trait CharExt: Sized {
-    /// Get the UTF-8 representation of this codepoint.
-    ///
-    /// `Utf8Char` is to `[u8;4]` what `char` is to `u32`:
-    /// a restricted type that cannot be mutated internally.
-    fn to_utf8(self) -> Utf8Char;
-
-    /// Get the UTF-16 representation of this codepoint.
-    ///
-    /// `Utf16Char` is to `(u16,Option<u16>)` what `char` is to `u32`:
-    /// a restricted type that cannot be mutated internally.
-    fn to_utf16(self) -> Utf16Char;
-
-    /// Iterate over or [read](https://doc.rust-lang.org/std/io/trait.Read.html)
-    /// the one to four bytes in the UTF-8 representation of this codepoint.
-    fn iter_utf8_bytes(self) -> Utf8Iterator;
-
-    /// Iterate over the one or two units in the UTF-16 representation of this codepoint.
-    fn iter_utf16_units(self) -> Utf16Iterator;
-
-
-    /// Convert this char to UTF-8, and then
-    /// returns the number of bytes written.
-    ///
-    /// `None` is returned if the buffer is too small; then the buffer is left unmodified.
-    /// A buffer of length four is always large enough.
-    ///
-    /// Similar to the unstable `.encode_utf8()`,
-    /// but that method somehow still exist on stable, so I have to use a different name.
-    fn to_utf8_slice(self,  dst: &mut[u8]) -> Option<usize>;
-
-    /// Convert this char to UTF-16, and then
-    /// returns the number of units written.
-    ///
-    /// `None` is returned if the buffer is too small; then the buffer is left unmodified.
-    /// A buffer of length two is always large enough.
-    ///
-    /// Similar to the unstable `.encode_utf16()`,
-    /// but that method somehow still exist on stable, so I have to use a different name.
-    fn to_utf16_slice(self,  dst: &mut[u16]) -> Option<usize>;
-
-
-    /// Convert this char to an UTF-8 array and lenght,
-    /// The returned array is left-aligned, and the usize is how many bytes are used.
-    /// The unused bytes are zero.
-    fn to_utf8_array(self) -> ([u8; 4], usize);
-
-    /// Convert this char to UTF-16.
-    /// The second `u16` is `Some` if a surrogate pair is required.
-    fn to_utf16_tuple(self) -> (u16, Option<u16>);
-
-
-
-    /// Create a `char` from the start of a slice intepreted as UTF-8, and return how many bytes were needed.
-    fn from_utf8_slice(src: &[u8]) -> Result<(Self,usize),InvalidUtf8Slice>;
-
-    /// Read one or two UTF-16 units into a `char`, and also return how many units were needed.
-    fn from_utf16_slice(src: &[u16]) -> Result<(Self,usize), InvalidUtf16Slice>;
-
-
-    /// Convert an UTF-8 sequence as returned from `.to_utf8_array()` into a `char`
-    fn from_utf8_array(utf8: [u8; 4]) -> Result<Self,InvalidUtf8Array>;
-
-    /// Convert a UTF-16 pair as returned from `.to_utf16_tuple()` into a `char`.
-    fn from_utf16_tuple(utf16: (u16, Option<u16>)) -> Result<Self, InvalidUtf16Tuple>;
-
-
-    /// Convert an UTF-8 sequence into a char.
-    /// The length of the slice is the length of the sequence, should be 1,2,3 or 4.
-    ///
-    /// # Panics:
-    ///
-    /// If the slice is empty
-    unsafe fn from_utf8_exact_slice_unchecked(src: &[u8]) -> Self;
-
-    /// Convert a UTF-16 tuple as returned from `.to_utf16_tuple()` into a `char`.
-    unsafe fn from_utf16_tuple_unchecked(utf16: (u16, Option<u16>)) -> Self;
-
-
-    /// Perform some extra validations compared to `char::from_u32_unchecked()`
-    ///
-    /// # Failures:
-    ///
-    /// * the value is greater than 0x10ffff
-    /// * the value is between 0xd800 and 0xdfff (inclusive)
-    fn from_u32_detailed(c: u32) -> Result<Self,InvalidCodePoint>;
-}
-
-
-
-impl CharExt for char {
-      /////////
-     //UTF-8//
-    /////////
-
-    fn to_utf8(self) -> Utf8Char {
-        self.into()
-    }
-    fn iter_utf8_bytes(self) -> Utf8Iterator {
-        self.to_utf8().into_iter()
-    }
-    fn to_utf8_slice(self,  dst: &mut[u8]) -> Option<usize> {
-        self.to_utf8().to_slice(dst)
-    }
-
-    fn to_utf8_array(self) -> ([u8; 4], usize) {
-        let len = self.len_utf8();
-        let mut c = self as u32;
-        if len == 1 {// ASCII, the common case
-            ([c as u8, 0, 0, 0],  1)
-        } else {
-            let mut parts = 0;// convert to 6-bit bytes
-                        parts |= c & 0x3f;  c>>=6;
-            parts<<=8;  parts |= c & 0x3f;  c>>=6;
-            parts<<=8;  parts |= c & 0x3f;  c>>=6;
-            parts<<=8;  parts |= c & 0x3f;
-            parts |= 0x80_80_80_80;// set the most significant bit
-            parts >>= 8*(4-len);// right-align bytes
-            // Now, unused bytes are zero, (which matters for Utf8Char.eq()) and the rest are 0b10xx_xxxx
-
-            // set header on first byte
-            parts |= (0xff_00u32 >> len)  &  0xff;// store length
-            parts &= Not::not(1u32 << 7-len);// clear the next bit after it
-
-            let bytes: [u8; 4] = unsafe{ mem::transmute(u32::from_le(parts)) };
-            (bytes, len)
-        }
-    }
-
-
-    fn from_utf8_slice(src: &[u8]) -> Result<(Self,usize),InvalidUtf8Slice> {
-        use errors::InvalidUtf8::*;
-        use errors::InvalidUtf8Slice::*;
-        let first = *try!(src.first().ok_or(TooShort(1)));
-        let extra = try!(first.extra_utf8_bytes().map_err(|e| Utf8(FirstByte(e)) ));
-        if extra == 0 {
-            return Ok((first as char, 1));
-        } else if src.len() <= extra {
-            return Err(TooShort(extra+1))
-        }
-        let src = &src[..1+extra];
-        for (i, &b) in src.iter().enumerate().skip(1) {
-            if b < 0b1000_0000  ||  b > 0b1011_1111 {
-                return Err(Utf8(NotAContinuationByte(i)));
-            }
-        }
-        if overlong(src[0], src[1]) {
-            return Err(Utf8(OverLong));
-        }
-        let c = unsafe{ char::from_utf8_exact_slice_unchecked(src) };
-        char::from_u32_detailed(c as u32).map(|c| (c,src.len()) ).map_err( CodePoint )
-    }
-
-    fn from_utf8_array(utf8: [u8; 4]) -> Result<Self,InvalidUtf8Array> {
-        use errors::InvalidUtf8::*;
-        use errors::InvalidUtf8Array::*;
-        let len = match utf8[0].extra_utf8_bytes() {
-            Ok(0)     =>  return Ok(utf8[0] as char),
-            Ok(l)     =>  l+1,
-            Err(err)  =>  return Err(Utf8(FirstByte(err))),
-        };
-        for (i, &b) in utf8[..len].iter().enumerate().skip(1) {
-            if b < 0b1000_0000  ||  b > 0b1011_1111 {
-                return Err(Utf8(NotAContinuationByte(i)));
-            }
-        }
-
-        if overlong(utf8[0], utf8[1]) {
-            return Err(Utf8(OverLong));
-        }
-        let c = unsafe{ char::from_utf8_exact_slice_unchecked(&utf8[..len]) };
-        char::from_u32_detailed(c as u32).map_err( CodePoint )
-    }
-
-    unsafe fn from_utf8_exact_slice_unchecked(src: &[u8]) -> Self {
-        if src.len() == 1 {
-            src[0] as char
-        } else {
-            let mut c = src[0] as u32 & (0xff >> 2+src.len()-1);
-            for b in &src[1..] {
-                c = (c << 6)  |  (b & 0b00111111) as u32;
-            }
-            unsafe{ char::from_u32_unchecked(c) }
-        }
-    }
-
-
-
-      //////////
-     //UTF-16//
-    //////////
-
-    fn to_utf16(self) -> Utf16Char {
-        Utf16Char::from(self)
-    }
-    fn iter_utf16_units(self) -> Utf16Iterator {
-        self.to_utf16().into_iter()
-    }
-
-    fn to_utf16_slice(self,  dst: &mut[u16]) -> Option<usize> {
-        let (first, second) = self.to_utf16_tuple();
-        match (dst.len(), second) {
-            (0, _)            =>  None,
-            (1, Some(_))      =>  None,
-            (_, Some(second)) => {dst[0] = first;
-                                  dst[1] = second;
-                                  Some(2)
-                                 },
-            (_, None)         => {dst[0] = first;
-                                  Some(1)
-                                 },
-        }
-    }
-
-    fn to_utf16_tuple(self) -> (u16, Option<u16>) {
-        let c = self as u32;
-        if c <= 0x_ff_ff {// single (or reserved, which we ignore)
-            (c as u16, None)
-        } else {// double (or too high, which we ignore)
-            let c = c - 0x_01_00_00;
-            let high = 0x_d8_00 + (c >> 10);
-            let low = 0x_dc_00 + (c & 0x_03_ff);
-            (high as u16,  Some(low as u16))
-        }
-    }
-
-
-    fn from_utf16_slice(src: &[u16]) -> Result<(Self,usize), InvalidUtf16Slice> {
-        use errors::InvalidUtf16Slice::*;
-        let first = *try!(src.first().ok_or(EmptySlice));
-        match (first.utf16_needs_extra_unit(), src.get(1).cloned()) {
-            (Some(false),              _            )  =>  Ok((1, None)),
-            (Some(true) ,  Some(0x_dc_00...0x_df_ff))  =>  Ok((2, Some(src[1]))),
-            (Some(true) ,  Some(         _         ))  =>  Err(SecondNotLowSurrogate),
-            (Some(true) ,  None                     )  =>  Err(MissingSecond),
-            (None       ,              _            )  =>  Err(FirstLowSurrogate),
-        }.map(|(len,second)| (unsafe{ char::from_utf16_tuple_unchecked((first,second)) }, len) )
-    }
-
-    fn from_utf16_tuple(utf16: (u16, Option<u16>)) -> Result<Self, InvalidUtf16Tuple> {
-        use errors::InvalidUtf16Tuple::*;
-        match utf16 {
-            (0x_00_00...0x_d7_ff, None) => Ok(()),// single
-            (0x_e0_00...0x_ff_ff, None) => Ok(()),// single
-            (0x_d8_00...0x_db_ff, Some(0x_dc_00...0x_df_ff)) => Ok(()),// correct surrogate pair
-            (0x_d8_00...0x_db_ff, Some(_)) => Err(InvalidSecond),
-            (0x_d8_00...0x_db_ff, None) => Err(MissingSecond),
-            (0x_dc_00...0x_df_ff, _) => Err(FirstIsTrailingSurrogate),
-            (_, Some(_)) => Err(SuperfluousSecond),// should be no second
-            (_, _) => unreachable!()
-        }.map(|_| unsafe{ char::from_utf16_tuple_unchecked(utf16) } )
-    }
-
-    unsafe fn from_utf16_tuple_unchecked(utf16: (u16, Option<u16>)) -> Self {
-        let mut c = utf16.0 as u32;
-        if let Some(second) = utf16.1 {
-            let high = (c-0x_d8_00) << 10;
-            let low = second as u32 - 0x_dc_00;
-            c = high | low;
-            c += 0x_01_00_00;
-        }
-        unsafe{ char::from_u32_unchecked(c) }
-    }
-
-
-    fn from_u32_detailed(c: u32) -> Result<Self,InvalidCodePoint> {
-        use errors::InvalidCodePoint::*;
-        match c {
-            // reserved for UTF-16 surrogate pairs
-            0xd8_00...0xdf_ff => Err(Utf16Reserved),
-            // too big
-            0x11_00_00...u32::MAX => Err(TooHigh),
-            _ => Ok(unsafe{ char::from_u32_unchecked(c) }),
-        }
-    }
-}
-
-
-// If all the data bits in the first byte are zero, the sequence might be longer than necessary
-// When you go up one byte, you gain 6-1 data bits, so if the five first are zero it's too long.
-// The first byte has 3 + (4-len) data bits, which we know are zero.
-// The first two bits in the second byte are 10, which gets shifted out.
-fn overlong(first: u8,  second: u8) -> bool {
-    let both = ((first as u16) << 8)  |  (second << 2) as u16;
-    let both = both << 1+both.not().leading_zeros();
-    both.leading_zeros() >= 5
-}
diff --git a/rustc_deps/vendor/encode_unicode/src/utf16_char.rs b/rustc_deps/vendor/encode_unicode/src/utf16_char.rs
deleted file mode 100644
index fd5446c..0000000
--- a/rustc_deps/vendor/encode_unicode/src/utf16_char.rs
+++ /dev/null
@@ -1,206 +0,0 @@
-/* Copyright 2016 Torbjørn Birch Moltu
- *
- * 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.
- */
-
-use Utf16Iterator;
-use CharExt;
-use errors::{InvalidUtf16Slice,InvalidUtf16Tuple};
-extern crate std;
-use std::{hash,fmt,cmp};
-use std::borrow::Borrow;
-use std::ops::Deref;
-
-#[cfg(feature="ascii")]
-use std::ascii::AsciiExt;
-#[cfg(feature="ascii")]
-extern crate ascii;
-#[cfg(feature="ascii")]
-use self::ascii::{Ascii,AsciiCast};
-
-
-// I don't think there is any good default value for char, but char does.
-#[derive(Default)]
-// char doesn't do anything more advanced than u32 for Eq/Ord, so we shouldn't either.
-// When it's a single unit, the second is zero, so Eq works.
-// Ord however, breaks on surrogate pairs.
-#[derive(PartialEq,Eq)]
-#[derive(Clone,Copy)]
-
-
-/// Store a `char` as UTF-16 so it can be borrowed as a slice
-///
-/// Size is identical to `char`.
-/// Cannot represent all 2^32-1 possible values, but can do all valid ones.
-pub struct Utf16Char {
-    units: [u16; 2],
-}
-
-
-  /////////////////////
- //conversion traits//
-/////////////////////
-
-impl From<char> for Utf16Char {
-    fn from(c: char) -> Self {
-        let (first, second) = c.to_utf16_tuple();
-        Utf16Char{ units: [first, second.unwrap_or(0)] }
-    }
-}
-impl From<Utf16Char> for char {
-    fn from(uc: Utf16Char) -> char {
-        unsafe{ char::from_utf16_tuple_unchecked(uc.to_tuple()) }
-    }
-}
-impl IntoIterator for Utf16Char {
-    type Item=u16;
-    type IntoIter=Utf16Iterator;
-    /// Iterate over the units.
-    fn into_iter(self) -> Utf16Iterator {
-        Utf16Iterator::from(self)
-    }
-}
-
-
-  /////////////////
- //getter traits//
-/////////////////
-impl AsRef<[u16]> for Utf16Char {
-    fn as_ref(&self) -> &[u16] {
-        &self.units[..self.len()]
-    }
-}
-impl Borrow<[u16]> for Utf16Char {
-    fn borrow(&self) -> &[u16] {
-        self.as_ref()
-    }
-}
-impl Deref for Utf16Char {
-    type Target = [u16];
-    fn deref(&self) -> &[u16] {
-        self.as_ref()
-    }
-}
-
-
-  ////////////////
- //ascii traits//
-////////////////
-#[cfg(feature="ascii")]
-/// Requires feature "ascii".
-impl AsciiExt for Utf16Char {
-    type Owned = Self;
-    fn is_ascii(&self) -> bool {
-        self.units[0] < 0x80
-    }
-    fn eq_ignore_ascii_case(&self,  other: &Self) -> bool {
-        self.to_char().eq_ignore_ascii_case(&other.to_char())
-    }
-    fn to_ascii_uppercase(&self) -> Self {
-        self.to_char().to_ascii_uppercase().to_utf16()
-    }
-    fn to_ascii_lowercase(&self) -> Self {
-        self.to_char().to_ascii_lowercase().to_utf16()
-    }
-    // Theese methods are what prevents this from becoming stable
-    fn make_ascii_uppercase(&mut self) {
-        *self = self.to_ascii_uppercase()
-    }
-    fn make_ascii_lowercase(&mut self) {
-        *self = self.to_ascii_lowercase();
-    }
-}
-#[cfg(feature="ascii")]
-/// Requires feature "ascii".
-impl From<Ascii> for Utf16Char {
-    fn from(ac: Ascii) -> Self {
-        Utf16Char{ units: [ac.as_byte() as u16,0] }
-    }
-}
-#[cfg(feature="ascii")]
-/// Requires feature "ascii".
-impl<'a> AsciiCast<'a> for Utf16Char {
-    type Target = Ascii;
-    unsafe fn to_ascii_nocheck(&'a self) -> Ascii {
-        (self.units[0] as u8).to_ascii_nocheck()
-    }
-}
-
-
-  /////////////////////////////////////////////////////////
- //Genaral traits that cannot be derived to emulate char//
-/////////////////////////////////////////////////////////
-impl hash::Hash for Utf16Char {
-    fn hash<H : hash::Hasher>(&self,  state: &mut H) {
-        self.to_char().hash(state);
-    }
-}
-impl fmt::Debug for Utf16Char {
-    fn fmt(&self,  fmtr: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self.to_char(), fmtr)
-    }
-}
-impl cmp::PartialOrd for Utf16Char {
-    fn partial_cmp(&self,  rhs: &Self) -> Option<cmp::Ordering> {
-        self.to_char().partial_cmp(&rhs.to_char())
-    }
-}
-impl cmp::Ord for Utf16Char {
-    fn cmp(&self,  rhs: &Self) -> cmp::Ordering {
-        self.to_char().cmp(&rhs.to_char())
-    }
-}
-
-
-  ///////////////////////////////////////////////////////
- //pub impls that should be together for nicer rustdoc//
-///////////////////////////////////////////////////////
-impl Utf16Char {
-    /// Validate and store the first UTF-16 codepoint in the slice.
-    /// Also return how many units were needed.
-    pub fn from_slice(src: &[u16]) -> Result<(Self,usize),InvalidUtf16Slice> {
-        char::from_utf16_slice(src).map(
-            |(_,len)|  (Utf16Char{ units: [src[0], if len==2 {src[1]} else {0}] }, len)
-        )
-    }
-    /// Validate and store a UTF-16 pair as returned from `char.to_utf16_tuple()`.
-    pub fn from_tuple(utf16: (u16,Option<u16>)) -> Result<Self,InvalidUtf16Tuple> {
-        char::from_utf16_tuple(utf16).map(
-            |_| Utf16Char{ units: [utf16.0, utf16.1.unwrap_or(0)] }
-        )
-    }
-
-    /// Returns 1 or 2.
-    /// There is no `.is_emty()` because it would always return false.
-    pub fn len(self) -> usize {
-        if self.units[1] == 0 {1} else {2}
-    }
-
-    /// Convert from UTF-16 to UTF-32
-    pub fn to_char(self) -> char {
-        self.into()
-    }
-    /// Write the internal representation to a slice,
-    /// and then returns the number of `u16`s written.
-    ///
-    /// `None` is returned if the buffer is too small; then the buffer is left unmodified.
-    /// A buffer of length two is always large enough.
-    pub fn to_slice(self,  dst: &mut[u16]) -> Option<usize> {
-        if self.len() <= dst.len() {
-            dst[0] = self.units[0];
-            if self.len() == 2 {
-                dst[1] = self.units[1];
-            }
-            Some(self.len())
-        } else {
-            None
-        }
-    }
-    /// The second `u16` is used for surrogate pairs.
-    pub fn to_tuple(self) -> (u16,Option<u16>) {
-        (self.units[0],  if self.len()==2 {Some(self.units[1])} else {None})
-    }
-}
diff --git a/rustc_deps/vendor/encode_unicode/src/utf16_iterator.rs b/rustc_deps/vendor/encode_unicode/src/utf16_iterator.rs
deleted file mode 100644
index 5354a27..0000000
--- a/rustc_deps/vendor/encode_unicode/src/utf16_iterator.rs
+++ /dev/null
@@ -1,61 +0,0 @@
-/* Copyright 2016 Torbjørn Birch Moltu
- *
- * 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.
- */
-
-use CharExt;
-use Utf16Char;
-extern crate std;
-use std::fmt;
-
-
-/// Iterate over the units in an UTF-16 representation of a codepoint.
-#[derive(Clone,Copy)]
-pub struct Utf16Iterator {
-    first: Option<u16>,
-    second: Option<u16>,
-}
-impl From<char> for Utf16Iterator {
-    fn from(c: char) -> Self {
-        let (first, second) = c.to_utf16_tuple();
-        Utf16Iterator{ first: Some(first),  second: second }
-    }
-}
-impl From<Utf16Char> for Utf16Iterator {
-    fn from(uc: Utf16Char) -> Self {
-        let (first, second) = uc.to_tuple();
-        Utf16Iterator{ first: Some(first),  second: second }
-    }
-}
-impl Iterator for Utf16Iterator {
-    type Item=u16;
-    fn next(&mut self) -> Option<u16> {
-        match (self.first, self.second) {
-            (Some(first), _)     => {self.first = None;   Some(first) },
-            (None, Some(second)) => {self.second = None;  Some(second)},
-            (None, None)         => {                     None        },
-        }
-    }
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len(), Some(self.len()))
-    }
-}
-impl ExactSizeIterator for Utf16Iterator {
-    fn len(&self) -> usize {
-        match (self.first, self.second) {
-            (None   ,  None   )  =>  0,
-            (Some(_),  None   )  =>  1,
-            (None   ,  Some(_))  =>  1,
-            (Some(_),  Some(_))  =>  2,
-        }
-    }
-}
-impl fmt::Debug for Utf16Iterator {
-    fn fmt(&self,  fmtr: &mut fmt::Formatter) -> fmt::Result {
-        let v: Vec<u16> = self.collect();
-        write!(fmtr, "{:?}", v)
-    }
-}
diff --git a/rustc_deps/vendor/encode_unicode/src/utf8_char.rs b/rustc_deps/vendor/encode_unicode/src/utf8_char.rs
deleted file mode 100644
index 7624562..0000000
--- a/rustc_deps/vendor/encode_unicode/src/utf8_char.rs
+++ /dev/null
@@ -1,234 +0,0 @@
-/* Copyright 2016 Torbjørn Birch Moltu
- *
- * 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.
- */
-
-pub use errors::FromStrError;
-use error::{InvalidUtf8Slice,InvalidUtf8Array};
-use Utf8Iterator;
-use CharExt;
-use U8UtfExt;
-extern crate std;
-use std::{hash,fmt, str};
-use std::borrow::Borrow;
-use std::ops::Deref;
-use std::mem::transmute;
-
-#[cfg(feature="ascii")]
-use std::ascii::AsciiExt;
-#[cfg(feature="ascii")]
-extern crate ascii;
-#[cfg(feature="ascii")]
-use self::ascii::{Ascii,AsciiCast};
-
-
-// I don't think there is any good default value for char, but char does.
-#[derive(Default)]
-// char doesn't do anything more advanced than u32 for Eq/Ord, so we shouldn't either.
-// The default impl of Ord for arrays works out because longer codepoints
-//     start with more ones, so if they're equal, the length is the same,
-// breaks down for values above 0x1f_ff_ff but those can only be created by unsafe code.
-#[derive(PartialEq,Eq, PartialOrd,Ord)]
-
-#[derive(Clone,Copy)]
-
-
-/// Store a `char` as UTF-8 so it can be borrowed as a `str`
-///
-/// Has the same size as `char`, and is a `[u8;4]`
-/// with the invariant that the first nth bytes are valid UTF-8, and the remaining are zero.
-pub struct Utf8Char {
-    bytes: [u8; 4],
-}
-
-
-  /////////////////////
- //conversion traits//
-/////////////////////
-impl str::FromStr for Utf8Char {
-    type Err = FromStrError;
-    /// The string must contain exactly one codepoint
-    fn from_str(s: &str) -> Result<Self, FromStrError> {
-        let mut uc = Utf8Char::default();
-        for (src, dst) in s.as_bytes().iter().zip(uc.bytes.iter_mut()) {
-            *dst = *src;// happens min(s.len(), 4) times
-        }
-        if uc.len() == s.len() {Ok(uc)}
-        else if s.is_empty()   {Err(FromStrError::Empty)}
-        else                   {Err(FromStrError::SeveralCodePoints)}
-    }
-}
-impl From<char> for Utf8Char {
-    fn from(c: char) -> Self {
-        Utf8Char{ bytes: c.to_utf8_array().0 }
-    }
-}
-impl From<Utf8Char> for char {
-    fn from(uc: Utf8Char) -> char {
-        unsafe{ char::from_utf8_exact_slice_unchecked(&uc.bytes[..uc.len()]) }
-    }
-}
-impl IntoIterator for Utf8Char {
-    type Item=u8;
-    type IntoIter=Utf8Iterator;
-    /// Iterate over the byte values.
-    fn into_iter(self) -> Utf8Iterator {
-        Utf8Iterator::from(self)
-    }
-}
-
-
-  /////////////////
- //getter traits//
-/////////////////
-impl AsRef<[u8]> for Utf8Char {
-    fn as_ref(&self) -> &[u8] {
-        &self.bytes[..self.len()]
-    }
-}
-impl AsRef<str> for Utf8Char {
-    fn as_ref(&self) -> &str {
-        unsafe{ std::str::from_utf8_unchecked( self.as_ref() ) }
-    }
-}
-impl Borrow<[u8]> for Utf8Char {
-    fn borrow(&self) -> &[u8] {
-        self.as_ref()
-    }
-}
-impl Borrow<str> for Utf8Char {
-    fn borrow(&self) -> &str {
-        self.as_ref()
-    }
-}
-impl Deref for Utf8Char {
-    type Target = str;
-    fn deref(&self) -> &Self::Target {
-        self.as_ref()
-    }
-}
-
-
-  ////////////////
- //ascii traits//
-////////////////
-#[cfg(feature="ascii")]
-/// Requires feature "ascii".
-impl AsciiExt for Utf8Char {
-    type Owned = Utf8Char;
-    fn is_ascii(&self) -> bool {
-        self.bytes[0].is_ascii()
-    }
-    fn eq_ignore_ascii_case(&self,  other: &Self) -> bool {
-        self.to_char().eq_ignore_ascii_case(&other.to_char())
-    }
-    fn to_ascii_uppercase(&self) -> Self::Owned {
-        let ascii = self.bytes[0].to_ascii_uppercase();
-        if ascii == self.bytes[0] {*self}
-        else {Utf8Char{ bytes: [ascii,0,0,0] }}
-    }
-    fn to_ascii_lowercase(&self) -> Self::Owned {
-        let ascii = self.bytes[0].to_ascii_lowercase();
-        if ascii == self.bytes[0] {*self}// unchanged
-        else {Utf8Char{ bytes: [ascii,0,0,0] }}// is ascii
-    }
-    // Theese methods are what prevents this from becoming stable
-    fn make_ascii_uppercase(&mut self) {
-        *self = self.to_ascii_uppercase()
-    }
-    fn make_ascii_lowercase(&mut self) {
-        *self = self.to_ascii_lowercase();
-    }
-}
-#[cfg(feature="ascii")]
-/// Requires feature "ascii".
-impl From<Ascii> for Utf8Char {
-    fn from(ac: Ascii) -> Self {
-        Utf8Char{ bytes: [ac.as_byte(),0,0,0] }
-    }
-}
-#[cfg(feature="ascii")]
-/// Requires feature "ascii".
-impl<'a> AsciiCast<'a> for Utf8Char {
-    type Target = Ascii;
-    unsafe fn to_ascii_nocheck(&'a self) -> Ascii {
-        self.bytes[0].to_ascii_nocheck()
-    }
-}
-
-
-  /////////////////////////////////////////////////////////
- //Genaral traits that cannot be derived to emulate char//
-/////////////////////////////////////////////////////////
-impl hash::Hash for Utf8Char {
-    fn hash<H : hash::Hasher>(&self,  state: &mut H) {
-        self.to_char().hash(state);
-    }
-}
-impl fmt::Debug for Utf8Char {
-    fn fmt(&self,  fmtr: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&self.to_char(), fmtr)
-    }
-}
-
-
-  ///////////////////////////////////////////////////////
- //pub impls that should be together for nicer rustdoc//
-///////////////////////////////////////////////////////
-impl Utf8Char {
-    /// Validate the start of a UTF-8 slice and store it.
-    /// Also returns how many bytes were needed.
-    ///
-    /// If it's a str and you know it contains only one codepoint,
-    /// use `.from_str()` to skip the validation.
-    pub fn from_slice_start(src: &[u8]) -> Result<(Self,usize),InvalidUtf8Slice> {
-        // need to convert to char to check codepoint, but not convert back.
-        let len = try!(char::from_utf8_slice(src)).1;
-        let mut uc = Self::default();
-        for (dst, src) in uc.bytes.iter_mut().zip(src).take(len) {
-            *dst = *src;
-        }
-        Ok((uc,len))
-    }
-    /// Validate the array and store it.
-    pub fn from_array(utf8: [u8;4]) -> Result<Self,InvalidUtf8Array> {
-        try!(char::from_utf8_array(utf8));
-        let len = Utf8Char{ bytes: utf8 }.len() as u32;
-        let mask = u32::from_le(0xff_ff_ff_ff >> 8*(4-len));
-        let unused_zeroed = mask  &  unsafe{ transmute::<_,u32>(utf8) };
-        Ok(unsafe{ transmute(unused_zeroed) })
-    }
-
-    /// Result is 1...4 and identical to `.as_ref().len()` or `.as_char().len_utf8()`.
-    /// There is no .is_emty() because it would always return false.
-    pub fn len(self) -> usize {
-        self.bytes[0].extra_utf8_bytes_unchecked() + 1
-    }
-
-    /// Convert from UTF-8 to UTF-32
-    pub fn to_char(self) -> char {
-        self.into()
-    }
-    /// Write the internal representation to a slice,
-    /// and then returns the number of bytes written.
-    ///
-    /// `None` is returned if the buffer is too small; then the buffer is left unmodified.
-    /// A buffer of length four is always large enough.
-    pub fn to_slice(self,  dst: &mut[u8]) -> Option<usize> {
-        if self.len() <= dst.len() {
-            for (dst, src) in dst.iter_mut().zip(self.bytes.iter()) {
-                *dst  = *src;
-            }
-            Some(self.len())
-        } else {
-            None
-        }
-    }
-    /// Expose the internal array and the number of used bytes.
-    pub fn to_array(self) -> ([u8;4],usize) {
-        (self.bytes, self.len())
-    }
-}
diff --git a/rustc_deps/vendor/encode_unicode/src/utf8_iterator.rs b/rustc_deps/vendor/encode_unicode/src/utf8_iterator.rs
deleted file mode 100644
index 5be3fd8..0000000
--- a/rustc_deps/vendor/encode_unicode/src/utf8_iterator.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-/* Copyright 2016 Torbjørn Birch Moltu
- *
- * 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.
- */
-
-use Utf8Char;
-extern crate std;
-use std::{fmt,mem,u32,u64};
-use std::ops::Not;
-use std::io::{Read, Error as ioError};
-
-
-
-/// Read or iterate over the bytes in the UTF-8 representation of a codepoint.
-#[derive(Clone,Copy)]
-pub struct Utf8Iterator (u32);
-
-impl From<Utf8Char> for Utf8Iterator {
-    fn from(uc: Utf8Char) -> Self {
-        let used = u32::from_le(unsafe{ mem::transmute(uc) });
-        // uses u64 because shifting an u32 by 32 bits is a no-op.
-        let unused_set = (u64::MAX  <<  uc.len() as u64*8) as u32;
-        Utf8Iterator(used | unused_set)
-    }
-}
-impl From<char> for Utf8Iterator {
-    fn from(c: char) -> Self {
-        Self::from(Utf8Char::from(c))
-    }
-}
-impl Iterator for Utf8Iterator {
-    type Item=u8;
-    fn next(&mut self) -> Option<u8> {
-        let next = self.0 as u8;
-        if next == 0xff {
-            None
-        } else {
-            self.0 = (self.0 >> 8)  |  0xff_00_00_00;
-            Some(next)
-        }
-    }
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len(),  Some(self.len()))
-    }
-}
-impl ExactSizeIterator for Utf8Iterator {
-    fn len(&self) -> usize {// not straightforward, but possible
-        let unused_bytes = self.0.not().leading_zeros() / 8;
-        4 - unused_bytes as usize
-    }
-}
-impl Read for Utf8Iterator {
-    /// Always returns Ok
-    fn read(&mut self,  buf: &mut[u8]) -> Result<usize, ioError> {
-        let mut wrote = 0;
-        while let Some(ptr) = buf.get_mut(wrote) {// while loop because I need the counter afterwards
-            if let Some(b) = self.next() {// don't call self.next() untill I know I can write the result.
-                *ptr = b;
-                wrote += 1;
-            } else {
-                 break;
-            }
-        }
-        Ok(wrote)
-    }
-}
-impl fmt::Debug for Utf8Iterator {
-    fn fmt(&self,  fmtr: &mut fmt::Formatter) -> fmt::Result {
-        let content: Vec<u8> = self.collect();
-        write!(fmtr, "bytes left: {:?}, content: {:x}", content, self.0)
-    }
-}
diff --git a/rustc_deps/vendor/encode_unicode/tests/fail_tests.rs b/rustc_deps/vendor/encode_unicode/tests/fail_tests.rs
deleted file mode 100644
index 735e75a..0000000
--- a/rustc_deps/vendor/encode_unicode/tests/fail_tests.rs
+++ /dev/null
@@ -1,97 +0,0 @@
-/* Copyright 2016 Torbjørn Birch Moltu
- *
- * 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.
- */
-
-#![feature(step_by)]
-//! Test that methods gives the correct error.
-//! Some also test a bit more because it's easy.
-
-use std::char;
-extern crate encode_unicode;
-use encode_unicode::*;
-use encode_unicode::error::*;
-
-
-#[test]
-fn from_u32() {
-    use encode_unicode::error::InvalidCodePoint::*;
-    for c in 0xd800..0xe000 {
-        assert_eq!(char::from_u32_detailed(c),  Err(Utf16Reserved));
-    }
-    for c in (0x110000..0xffffffff).step_by(0xfff) {
-        assert_eq!(char::from_u32_detailed(c),  Err(TooHigh));
-    }
-}
-
-#[test]
-fn utf8_extra_bytes() {
-    use encode_unicode::error::InvalidUtf8FirstByte::*;
-    for c in 0..256 {
-        assert_eq!( (c as u8).extra_utf8_bytes(), match c {
-            0b_1000_0000...0b_1011_1111 => Err(ContinuationByte),
-            0b_1111_1000...0b_1111_1111 => Err(TooLongSeqence),
-            0b_0000_0000...0b_0111_1111 => Ok(0),
-            0b_1100_0000...0b_1101_1111 => Ok(1),
-            0b_1110_0000...0b_1110_1111 => Ok(2),
-            0b_1111_0000...0b_1111_0111 => Ok(3),
-                         _              => unreachable!(),
-        });
-    }
-}
-
-#[test]
-fn utf16_extra_unit() {
-    for c in 0..0x1_00_00 {
-        assert_eq!( (c as u16).utf16_needs_extra_unit(), match c {
-            0b_0000_0000_0000_0000...0b_1101_0111_1111_1111 => Some(false),
-            0b_1101_1000_0000_0000...0b_1101_1011_1111_1111 => Some(true),
-            0b_1101_1100_0000_0000...0b_1101_1111_1111_1111 => None,
-            0b_1110_0000_0000_0000...0b_1111_1111_1111_1111 => Some(false),
-                                   _                        => unreachable!(),
-        });
-    }
-}
-
-
-#[test]
-fn from_utf16_tuple() {
-    use encode_unicode::error::InvalidUtf16Tuple::*;
-    for u in 0xdc00..0xe000 {
-        let close = if u%3==0 {u-100} else {u+100};
-        let doesnt_matter = if u%2==0 {Some(close)} else {None};
-	    assert_eq!(char::from_utf16_tuple((u,doesnt_matter)), Err(FirstIsTrailingSurrogate));
-    }
-    for u in (0..0xd800).chain(0xe000..0x10000) {
-        assert_eq!(char::from_utf16_tuple((u as u16,Some((0x100+u) as u16))), Err(SuperfluousSecond));
-	}
-    for u in 0xd800..0xdc00 {
-        assert_eq!(char::from_utf16_tuple((u,None)), Err(MissingSecond));
-
-	    assert_eq!(char::from_utf16_tuple((u,Some(u - 0x2ff))), Err(InvalidSecond));
-    }
-}
-
-#[test]
-fn overlong_utf8() {
-    use encode_unicode::error::InvalidUtf8::OverLong;
-    let overlongs = [[0xc0,0xbf], [0xe0,0x9f], [0xf0,0x8f],
-                     [0xc0,0x9f], [0xe0,0x8f], [0xf0,0x87]];
-    for o in overlongs.iter() {
-        let arr = [o[0],o[1], 0x80, 0x80];
-        assert_eq!(char::from_utf8_slice(&arr), Err(InvalidUtf8Slice::Utf8(OverLong)));
-        assert_eq!(char::from_utf8_array(arr), Err(InvalidUtf8Array::Utf8(OverLong)));
-    }
-}
-
-#[test]
-fn utf8_char_from_str() {
-    use std::str::FromStr;
-    use encode_unicode::error::FromStrError::*;
-    assert_eq!(Utf8Char::from_str(""), Err(Empty));
-    assert_eq!(Utf8Char::from_str("ab"), Err(SeveralCodePoints));
-    assert_eq!(Utf8Char::from_str("́e"), Err(SeveralCodePoints));// 'e'+u301 combining mark
-}
diff --git a/rustc_deps/vendor/encode_unicode/tests/iterator_tests.rs b/rustc_deps/vendor/encode_unicode/tests/iterator_tests.rs
deleted file mode 100644
index 1490785..0000000
--- a/rustc_deps/vendor/encode_unicode/tests/iterator_tests.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-/* Copyright 2016 Torbjørn Birch Moltu
- *
- * 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.
- */
-
-//! iterators are stateful; test that they behave.
-
-use std::io::Read;
-extern crate encode_unicode;
-use encode_unicode::CharExt;
-//use encode_unicode::{Utf8Iterator,Utf16Iterator};
-
-#[test]
-fn read_single_byte() {
-    let mut buf = [0; 4];
-    for c in 0..128 {
-        let uc = char::from_u32_detailed(c).unwrap().to_utf8();
-        let mut iter = uc.into_iter();
-        assert_eq!((iter.read(&mut buf[..4]).unwrap(),c), (1,c));
-        assert_eq!((iter.read(&mut buf[..4]).unwrap(),c), (0,c));
-        let mut iter = uc.into_iter();
-        assert_eq!((iter.read(&mut buf[..1]).unwrap(),c), (1,c));
-        assert_eq!((iter.read(&mut buf[..1]).unwrap(),c), (0,c));
-        let mut iter = uc.into_iter();
-        assert_eq!((iter.read(&mut buf[..0]).unwrap(),c), (0,c));
-        assert_eq!((iter.read(&mut buf[..2]).unwrap(),c), (1,c));
-    }
-}
diff --git a/rustc_deps/vendor/encode_unicode/tests/pass_tests.rs b/rustc_deps/vendor/encode_unicode/tests/pass_tests.rs
deleted file mode 100644
index e477938..0000000
--- a/rustc_deps/vendor/encode_unicode/tests/pass_tests.rs
+++ /dev/null
@@ -1,147 +0,0 @@
-/* Copyright 2016 Torbjørn Birch Moltu
- *
- * 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.
- */
-
-#![feature(unicode)]// reference implementations of to_slice
-
-//! Test that every method gives the correct result for valid values.
-//! Except iterators, which are stateful.
-
-use std::char;
-use std::str::{self,FromStr};
-use std::hash::{Hash,SipHasher};
-extern crate encode_unicode;
-use encode_unicode::*;
-
-
-#[test]
-fn equal_defaults() {
-    assert_eq!(Utf8Char::default().to_char(), char::default());
-    assert_eq!(Utf16Char::default().to_char(), char::default());
-}
-
-#[test]
-fn same_size_as_char() {
-    use std::mem::size_of;
-    assert_eq!(size_of::<Utf8Char>(), size_of::<char>());
-    assert_eq!(size_of::<Utf16Char>(), size_of::<char>());
-}
-
-
-const EDGES_AND_BETWEEN: [u32;13] = [
-    0x0,// min
-    0x3b,// between
-    0x7f,// max 1-byte UTF-8
-    0x80,// min 2-byte UTF-8
-    0x111,// between
-    0x7ff,// max 2-byte UTF-8
-    0x800,// min 3-byte UTF-8
-    0xd7ff,// before reserved
-    0xe000,// after reserved
-    0xffff,// max UTF-16 single and 3-byte UTF-8
-    0x10000,// min UTF-16 surrogate and 4-byte UTF-8
-    0xabcde,// between
-    0x10ffff,// max
-];
-
-
-fn test(c: u32) {
-    let c = char::from_u32(c).expect(&format!("{:x} is not a valid char", c));
-    assert_eq!(char::from_u32_detailed(c as u32), Ok(c));
-    let sh = &mut SipHasher::new();
-
-    // UTF-8
-    let uc = c.to_utf8();
-    assert_eq!(uc.to_char(), c);
-    assert_eq!(uc.hash(sh), c.hash(sh));
-
-    let mut reference_dst = [0;4];
-    let mut len = None;
-    for i in 0..5 {
-        let mut test_dst = [0;4];
-        len = c.encode_utf8(&mut reference_dst[..i]);
-        assert_eq!(c.to_utf8_slice(&mut test_dst[..i]), len);
-        assert_eq!(test_dst, reference_dst);
-        assert_eq!(uc.to_slice(&mut test_dst[..i]), len);
-        assert_eq!(test_dst, reference_dst);
-    }
-    let len = len.expect(&format!("encode_utf8 never succeded: c={}={:x}, utf8={:?}", c, c as u32, reference_dst));
-    let str_ = str::from_utf8(&reference_dst[..len]).unwrap();
-    let ustr = Utf8Char::from_str(str_).unwrap();
-    assert_eq!(ustr.to_array().0, uc.to_array().0);// bitwise equality
-
-    assert_eq!(reference_dst[0].extra_utf8_bytes(), Ok(len-1));
-    assert_eq!(reference_dst[0].extra_utf8_bytes_unchecked(), len-1);
-    assert_eq!(c.to_utf8_array(),  (reference_dst, len));
-    assert_eq!(char::from_utf8_array(reference_dst), Ok(c));
-    assert_eq!(char::from_utf8_slice(&reference_dst[..len]), Ok((c,len)));
-    for other in &EDGES_AND_BETWEEN {
-        let other = unsafe{ char::from_u32_unchecked(*other) };
-        let uother = other.to_utf8();
-        assert_eq!(uc == uother,  c == other);
-        assert_eq!(uc.hash(sh)==other.hash(sh),  c.hash(sh)==uother.hash(sh));
-        assert_eq!(uc.cmp(&uother), c.cmp(&other));
-    }
-    assert_eq!(uc.to_array(),  (reference_dst, len));
-    assert_eq!(Utf8Char::from_array(reference_dst), Ok(uc));
-    assert_eq!(Utf8Char::from_slice_start(&reference_dst[..len]), Ok((uc,len)));
-    assert_eq!(c.iter_utf8_bytes().len(), len);
-    let iterated: Vec<_> = c.iter_utf8_bytes().collect();
-    assert_eq!(iterated[..], reference_dst[..len]);
-    assert_eq!(<AsRef<[u8]>>::as_ref(&uc), &iterated[..]);
-
-    // UTF-16
-    let uc = c.to_utf16();
-    assert_eq!(uc.to_char(), c);
-    assert_eq!(uc.hash(sh), c.hash(sh));
-    let mut reference_dst = [0;2];
-    let mut len = None;
-    for i in 0..3 {
-        let mut test_dst = [0;2];
-        len = c.encode_utf16(&mut reference_dst[..i]);
-        assert_eq!(c.to_utf16_slice(&mut test_dst[..i]), len);
-        assert_eq!(test_dst, reference_dst);
-        assert_eq!(uc.to_slice(&mut test_dst[..i]), len);
-        assert_eq!(test_dst, reference_dst);
-    }
-    let len = len.unwrap();
-    assert_eq!(reference_dst[0].utf16_needs_extra_unit(), Some(len==2));
-    assert_eq!(reference_dst[0].utf16_is_leading_surrogate(), len==2);
-    assert_eq!(char::from_utf16_slice(&reference_dst[..len]), Ok((c,len)));
-    for other in &EDGES_AND_BETWEEN {
-        let other = unsafe{ char::from_u32_unchecked(*other) };
-        let uother = other.to_utf16();
-        assert_eq!(uc == uother,  c == other);
-        assert_eq!(uc.hash(sh)==other.hash(sh),  c.hash(sh)==uother.hash(sh));
-        assert_eq!(uc.cmp(&uother), c.cmp(&other));
-    }
-    let tuple = c.to_utf16_tuple();
-    assert_eq!([tuple.0, tuple.1.unwrap_or(0)],  reference_dst);
-    assert_eq!(char::from_utf16_tuple(tuple), Ok(c));
-    assert_eq!(c.to_utf16().to_char(), c);
-    assert_eq!(c.iter_utf16_units().len(), len);
-    let iterated: Vec<_> = c.iter_utf16_units().collect();
-    assert_eq!(*iterated, reference_dst[0..len]);
-    assert_eq!(<AsRef<[u16]>>::as_ref(&uc), &iterated[..]);
-}
-
-
-#[test]
-fn edges_middle() {
-    for c in &EDGES_AND_BETWEEN {
-        test(*c);
-    }
-}
-
-
-#[test]
-#[ignore]
-fn all() {
-    for c in std::iter::Iterator::chain(0..0xd800, 0xe000..0x110000) {
-        test(c);
-    }
-}
diff --git a/rustc_deps/vendor/void/LICENSE b/rustc_deps/vendor/void/LICENSE
new file mode 100644
index 0000000..33c7319
--- /dev/null
+++ b/rustc_deps/vendor/void/LICENSE
@@ -0,0 +1,231 @@
+https://raw.githubusercontent.com/reem/rust/master/LICENSE-APACHE:
+
+                              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.
+========================================
+https://raw.githubusercontent.com/reem/rust/master/LICENSE-MIT:
+
+Copyright (c) 2015 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.