[rust] add pretty assertions library

OSRB-78 OSRB-79

Change-Id: I7a2d52cc87d3a614d4b075e06268fcf98a1c73f1
diff --git a/rustc_deps/Cargo.lock b/rustc_deps/Cargo.lock
index 500e0d2..90600e4 100644
--- a/rustc_deps/Cargo.lock
+++ b/rustc_deps/Cargo.lock
@@ -234,6 +234,11 @@
 ]
 
 [[package]]
+name = "difference"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[[package]]
 name = "digest"
 version = "0.7.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -394,6 +399,7 @@
  "num-bigint 0.1.44 (registry+https://github.com/rust-lang/crates.io-index)",
  "parking_lot 0.4.8 (registry+https://github.com/rust-lang/crates.io-index)",
  "pin-utils 0.1.0-alpha.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "pretty_assertions 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "rand 0.4.3 (registry+https://github.com/rust-lang/crates.io-index)",
  "rouille 2.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
  "rust-crypto 0.2.36",
@@ -868,6 +874,15 @@
 ]
 
 [[package]]
+name = "pretty_assertions"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+dependencies = [
+ "ansi_term 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
 name = "proc-macro2"
 version = "0.4.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
@@ -1490,6 +1505,7 @@
 "checksum crc 1.8.1 (registry+https://github.com/rust-lang/crates.io-index)" = "d663548de7f5cca343f1e0a48d14dcfb0e9eb4e079ec58883b7251539fa10aeb"
 "checksum crossbeam 0.3.2 (registry+https://github.com/rust-lang/crates.io-index)" = "24ce9782d4d5c53674646a6a4c1863a21a8fc0cb649b3c94dfc16e45071dea19"
 "checksum deflate 0.7.19 (registry+https://github.com/rust-lang/crates.io-index)" = "8a6abb26e16e8d419b5c78662aa9f82857c2386a073da266840e474d5055ec86"
+"checksum difference 2.0.0 (registry+https://github.com/rust-lang/crates.io-index)" = "524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198"
 "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 encoding 0.2.33 (registry+https://github.com/rust-lang/crates.io-index)" = "6b0d943856b990d12d3b55b359144ff341533e516d94098b1d3fc1ac666d36ec"
@@ -1556,6 +1572,7 @@
 "checksum phf_shared 0.7.23 (registry+https://github.com/rust-lang/crates.io-index)" = "b539898d22d4273ded07f64a05737649dc69095d92cb87c7097ec68e3f150b93"
 "checksum pin-utils 0.1.0-alpha.3 (registry+https://github.com/rust-lang/crates.io-index)" = "42d42579e40cc2de14252a729e9727439657cf68a4997593aafe63728544ecb3"
 "checksum plist 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "c61ac2afed2856590ae79d6f358a24b85ece246d2aa134741a66d589519b7503"
+"checksum pretty_assertions 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3a029430f0d744bc3d15dd474d591bed2402b645d024583082b9f63bb936dac6"
 "checksum proc-macro2 0.4.20 (registry+https://github.com/rust-lang/crates.io-index)" = "3d7b7eaaa90b4a90a932a9ea6666c95a389e424eff347f0f793979289429feee"
 "checksum pulse 0.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "655612b6c8d96a8a02f331fe296cb4f925b68e87c1d195544675abca2d9b9af0"
 "checksum quote 0.6.8 (registry+https://github.com/rust-lang/crates.io-index)" = "dd636425967c33af890042c483632d33fa7a18f19ad1d7ea72e8998c6ef8dea5"
diff --git a/rustc_deps/Cargo.toml b/rustc_deps/Cargo.toml
index 95e7233..1a1bc66 100644
--- a/rustc_deps/Cargo.toml
+++ b/rustc_deps/Cargo.toml
@@ -35,6 +35,7 @@
 num-bigint = "0.1"
 parking_lot = "0.4"
 pin-utils = "=0.1.0-alpha.3"
+pretty_assertions = "0.5.1"
 rand = "0.4"
 rouille = "2.1.0"
 rust-crypto = "0.2"
diff --git a/rustc_deps/vendor/difference/.cargo-checksum.json b/rustc_deps/vendor/difference/.cargo-checksum.json
new file mode 100644
index 0000000..5b81146
--- /dev/null
+++ b/rustc_deps/vendor/difference/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{".travis.yml":"35865895d1613758ea91a51977559112bddbe7e414c217e9a0f0756d86a7c161","Cargo.toml":"5eb2f80e0614bed57405a7e05e594485dc86d9cefe1fb824ab48fd5e0212cbe5","Examples.md":"bf0a8c13c17a28b2b170c00c1593deb4ccd1e91bb7b13af0390f92730286b197","LICENSE":"1792fda8a7468d32b8b24322c0cf1c083ba3053afcd315f10b46668ba01b77a3","README.md":"08182d9667fb5b6f7685d3019708e8aed112006fbff6290b2334cdd222a185ad","appveyor.yml":"e6aabdcc8454e213186f3d7f98e87b9e0dd79a43dc1e35e0af89dbde09506839","assets/fox.png":"5fcd20685756d1c9a22a3301e57724e1b094da87bd71190d20d0ec5536261b29","assets/git-style.png":"587d92795402debee8004385eb44f4c3fb6f7afa8a3615efa26511b2d8dba7d0","assets/github-style.png":"680ccd1bf610620d9c90aa9b078ae295afa0b85458ead49d9dabf83308c0c377","assets/word-underline.png":"0eac0df0ddee8f5cbd3ec9c64c4e0ff3c930d9e8c61bbe6928b300a7202cb01e","examples/github-style.rs":"e843a419c5ba4967d9f1095b96a3e7923f3b48cf3ee45c5a72a3b4e37e06118a","examples/line-by-line.rs":"5c870cae9b9457590ee2da4ef6e52bcf75c3e20c7c6cf94cd7127b7b6e4998e8","examples/underline-words.rs":"bc595c0bafe9a295527414dd8b98fe5280e628996ab31e560f3369d44f269270","rustfmt.toml":"078f47705afd62e12a508b06dff69e6067fe89b2726693d35b54e7be4f046e7a","src/display.rs":"3cd59f244122d3dd927404b5de22cdfee9b87d4893b919dfca0e65610beba888","src/lcs.rs":"2766f4a55beabd28b9fe012338d5037f7f671efbdfa864d50e20201e07412659","src/lib.rs":"37265cdf78398416cf1a21254abaadd1debd23069a659a70edec04431410cbd2","src/main.rs":"65f0a7bd6aeca1c10c822de65a8066f3407bd34c4345b4ccd84ae5f852191cff","src/merge.rs":"be180d16869468ccb0cdda116ee486116550d6751e7688fcb068dedf770ddb0c","tests/quickcheck.rs":"cd40ccf20dc043c942399d2fc32226ffac509a3b356f25f79b4b9355a2d43caa"},"package":"524cbf6897b527295dff137cec09ecf3a05f4fddffd7dfcd1585403449e74198"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/difference/.travis.yml b/rustc_deps/vendor/difference/.travis.yml
new file mode 100644
index 0000000..1180305
--- /dev/null
+++ b/rustc_deps/vendor/difference/.travis.yml
@@ -0,0 +1,53 @@
+dist: trusty
+sudo: false
+language: rust
+rust:
+  - stable
+  - beta
+  - nightly
+
+install:
+  # Install rustfmt
+  # There are no linux binaries for rustfmt-bin available right now. See https://github.com/japaric/rustfmt-bin/issues/2.
+  #- curl -LSfs https://japaric.github.io/trust/install.sh | sh -s -- --force --crate rustfmt --git japaric/rustfmt-bin --tag v0.9.0-20170614
+  - if [ "$TRAVIS_RUST_VERSION" = "stable" ]; then (cargo install rustfmt --vers 0.9.0 --force) fi
+  # Install clippy
+  - if [ "$TRAVIS_RUST_VERSION" = "nightly" ]; then (cargo install clippy --force) fi
+  - export PATH=$HOME/.cargo/bin:$PATH
+
+script:
+  - cargo build --features=bin
+  - cargo test
+  - if [ "$TRAVIS_RUST_VERSION" = "nightly" ]; then (cargo clippy) fi
+  - if [ "$TRAVIS_RUST_VERSION" = "stable" ]; then (cargo fmt -- --write-mode=diff) fi
+
+addons:
+  apt:
+    packages:
+      - libcurl4-openssl-dev
+      - libelf-dev
+      - libdw-dev
+      - cmake
+      - gcc
+      - binutils-dev
+
+cache:
+  apt: true
+  directories:
+    - $HOME/.cargo
+    - target/debug/build
+
+before_cache:
+    # Travis can't cache files that are not readable by "others"
+    - chmod -R a+r $HOME/.cargo
+
+after_success: |
+  [ $TRAVIS_RUST_VERSION = stable ] &&
+  wget https://github.com/SimonKagstrom/kcov/archive/master.tar.gz &&
+  tar xzf master.tar.gz && mkdir kcov-master/build && cd kcov-master/build && cmake .. && make && make install DESTDIR=../tmp && cd ../.. &&
+  ls target/debug &&
+  ./kcov-master/tmp/usr/local/bin/kcov --coveralls-id=$TRAVIS_JOB_ID --exclude-pattern=/.cargo target/kcov target/debug/difference-*
+
+env:
+  global:
+    - secure: by21VBcjZUvTcgLKxo9lSKIoHfPCHPHitazvLgebRInyI82hH39HiCsNLVwjU6BGGjTnj9Y/j/ygr8qogq+WW+Wls2LrMsomid+I5WvldgJNPoKaHNNa68zTK18zVq68nM351CU9CjMSMS7MPpWsrgD6avAB50nmrEjWhi8n6jwu6FIXkRZtOyIgdlR/Qm1CnOA5OX2i3EiGe0r90tLpEpyaQ2Ml0pLyBdlxftqef++nvY9e0ufihGdzkRyVAsDs7td4JkHkEPN9rKMRx0jq42daB5Mvu9nWKPGbz04RfOug0SxaT7BnUhRsIJGwd9be7Hz2Wdvb5I7uV/g86INojMhU8S4/BlXKkIy1CZvLrQc+fGjeA9MXFeKFBVbC3L+qAfTPdkhjw6VAdg37tiYzV4lnPYyujiY00qGmKTKoG+xGTx/jEX2kRt8p7OGXgougwxIbEowHOduYtbCnBmhng6bcy3qyr8AztcM44AIlEy3OLKB7ocgvoFv+Fz4kjROQCVq+oW86bZ014Ex8k32wAlibU8M3mVALRk6Cgk7nbCl6s1+Y5uZE/TeDaLEYpLGSqYWeU9in8o4m6U65bh9XEUCnEgY7IcwV93zHUA+i50bwOROkS7c57bvAfdq/dwaW79VHqpq5D2toDVlKXYN90r6vAX0VhH91rW31FNXe0X0=
diff --git a/rustc_deps/vendor/difference/Cargo.toml b/rustc_deps/vendor/difference/Cargo.toml
new file mode 100644
index 0000000..1f84bc2
--- /dev/null
+++ b/rustc_deps/vendor/difference/Cargo.toml
@@ -0,0 +1,44 @@
+# 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 = "difference"
+version = "2.0.0"
+authors = ["Johann Hofmann <mail@johann-hofmann.com>"]
+description = "A Rust text diffing and assertion library."
+documentation = "https://johannhof.github.io/difference.rs/difference/index.html"
+readme = "README.md"
+keywords = ["diff", "text", "compare", "changes", "assert"]
+categories = ["text-processing", "development-tools::testing"]
+license = "MIT"
+repository = "https://github.com/johannhof/difference.rs"
+
+[[bin]]
+name = "difference"
+doc = false
+[dependencies.getopts]
+version = "0.2"
+optional = true
+[dev-dependencies.quickcheck]
+version = "0.4"
+
+[dev-dependencies.term]
+version = "0.2.7"
+
+[features]
+bin = ["getopts"]
+default = []
+[badges.appveyor]
+repository = "johannhof/difference.rs"
+
+[badges.travis-ci]
+repository = "johannhof/difference.rs"
diff --git a/rustc_deps/vendor/difference/Examples.md b/rustc_deps/vendor/difference/Examples.md
new file mode 100644
index 0000000..bb3f435
--- /dev/null
+++ b/rustc_deps/vendor/difference/Examples.md
@@ -0,0 +1,21 @@
+# Diff Examples
+
+These examples use the official term library to format output.
+
+## Line-by-line (Git Style)
+
+[examples/line-by-line.rs](examples/line-by-line.rs)
+
+![line-by-line.rs](https://raw.githubusercontent.com/johannhof/difference.rs/master/assets/git-style.png)
+
+## Underline words (GitHub Style)
+
+[examples/underline-words.rs](examples/underline-words.rs)
+
+![underline-words.rs](https://raw.githubusercontent.com/johannhof/difference.rs/master/assets/word-underline.png)
+
+## GitHub Style (Multiline)
+
+[examples/github-style.rs](examples/github-style.rs)
+
+![github-style.rs](https://raw.githubusercontent.com/johannhof/difference.rs/master/assets/github-style.png)
diff --git a/rustc_deps/vendor/difference/LICENSE b/rustc_deps/vendor/difference/LICENSE
new file mode 100644
index 0000000..70d9ff6
--- /dev/null
+++ b/rustc_deps/vendor/difference/LICENSE
@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Johann Hofmann
+
+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/difference/README.md b/rustc_deps/vendor/difference/README.md
new file mode 100644
index 0000000..363123e
--- /dev/null
+++ b/rustc_deps/vendor/difference/README.md
@@ -0,0 +1,46 @@
+# difference.rs [![](https://travis-ci.org/johannhof/difference.rs.svg?branch=master)](https://travis-ci.org/johannhof/difference.rs) [![](https://ci.appveyor.com/api/projects/status/n1nqaitd5uja8tsi/branch/master?svg=true)](https://ci.appveyor.com/project/johannhof/liquid-rust/branch/master) [![](https://coveralls.io/repos/johannhof/difference.rs/badge.svg?branch=master&service=github)](https://coveralls.io/github/johannhof/difference.rs?branch=master) [![](https://img.shields.io/crates/v/difference.svg)](https://crates.io/crates/difference)
+A Rust text diffing library with built-in diffing assertion.
+
+__[Documentation](https://johannhof.github.io/difference.rs)__
+
+__[Examples](/Examples.md)__
+
+```rust
+use difference::Changeset;
+
+let changeset = Changeset::new("test", "tent", "");
+
+assert_eq!(changeset.diffs, vec![
+  Difference::Same("te".to_string()),
+  Difference::Rem("s".to_string()),
+  Difference::Add("n".to_string()),
+  Difference::Same("t".to_string())
+]);
+```
+
+![](https://raw.githubusercontent.com/johannhof/difference.rs/master/assets/fox.png)
+![](https://raw.githubusercontent.com/johannhof/difference.rs/master/assets/github-style.png)
+
+Usage
+----------
+
+Add the following to your Cargo.toml:
+
+```toml
+[dependencies]
+difference = "2.0"
+```
+
+Now you can use the crate in your code
+```rust
+extern crate difference;
+```
+
+Using the binary
+-----------------
+
+difference can also be used as a command-line application. The best way to install it is using:
+
+```sh
+$ cargo install --features=bin
+```
diff --git a/rustc_deps/vendor/difference/appveyor.yml b/rustc_deps/vendor/difference/appveyor.yml
new file mode 100644
index 0000000..619e4aa
--- /dev/null
+++ b/rustc_deps/vendor/difference/appveyor.yml
@@ -0,0 +1,43 @@
+environment:
+  global:
+    RUST_VERSION: stable
+
+  matrix:
+    # Stable channel
+    - TARGET: x86_64-pc-windows-gnu
+      CHANNEL: stable
+    - TARGET: i686-pc-windows-msvc
+      CHANNEL: stable
+    - TARGET: x86_64-pc-windows-msvc
+      CHANNEL: stable
+    # Beta channel
+    - TARGET: x86_64-pc-windows-msvc
+      CHANNEL: beta
+    # Nightly channel
+    - TARGET: x86_64-pc-windows-msvc
+      CHANNEL: nightly
+
+install:
+  - ps: >-
+      If ($Env:TARGET -eq 'x86_64-pc-windows-gnu') {
+        $Env:PATH += ';C:\msys64\mingw64\bin'
+      } ElseIf ($Env:TARGET -eq 'i686-pc-windows-gnu') {
+        $Env:PATH += ';C:\msys64\mingw32\bin'
+      }
+  - curl -sSf -o rustup-init.exe https://win.rustup.rs/
+  - rustup-init.exe -y --default-host %TARGET% --default-toolchain %RUST_VERSION%
+  - set PATH=%PATH%;C:\Users\appveyor\.cargo\bin
+  - rustc -Vv
+  - cargo -V
+
+# Build and test
+test_script:
+  - cargo build --features=bin
+  - cargo test
+
+cache:
+  - C:\Users\appveyor\.cargo\registry
+  - target
+
+# disable automatic builds
+build: false
diff --git a/rustc_deps/vendor/difference/assets/fox.png b/rustc_deps/vendor/difference/assets/fox.png
new file mode 100644
index 0000000..76caa20
--- /dev/null
+++ b/rustc_deps/vendor/difference/assets/fox.png
Binary files differ
diff --git a/rustc_deps/vendor/difference/assets/git-style.png b/rustc_deps/vendor/difference/assets/git-style.png
new file mode 100644
index 0000000..ef2e0b4
--- /dev/null
+++ b/rustc_deps/vendor/difference/assets/git-style.png
Binary files differ
diff --git a/rustc_deps/vendor/difference/assets/github-style.png b/rustc_deps/vendor/difference/assets/github-style.png
new file mode 100644
index 0000000..b369c4b
--- /dev/null
+++ b/rustc_deps/vendor/difference/assets/github-style.png
Binary files differ
diff --git a/rustc_deps/vendor/difference/assets/word-underline.png b/rustc_deps/vendor/difference/assets/word-underline.png
new file mode 100644
index 0000000..73baf63
--- /dev/null
+++ b/rustc_deps/vendor/difference/assets/word-underline.png
Binary files differ
diff --git a/rustc_deps/vendor/difference/examples/github-style.rs b/rustc_deps/vendor/difference/examples/github-style.rs
new file mode 100644
index 0000000..66283be
--- /dev/null
+++ b/rustc_deps/vendor/difference/examples/github-style.rs
@@ -0,0 +1,70 @@
+extern crate term;
+extern crate difference;
+use difference::{Difference, Changeset};
+use std::io::Write;
+
+// Screenshot:
+// https://raw.githubusercontent.com/johannhof/difference.rs/master/assets/github-style.png
+
+#[allow(unused_must_use)]
+fn main() {
+    let text1 = "Roses are red, violets are blue,\n\
+                 I wrote this library here,\n\
+                 just for you.\n\
+                 (It's true).";
+
+    let text2 = "Roses are red, violets are blue,\n\
+                 I wrote this documentation here,\n\
+                 just for you.\n\
+                 (It's quite true).";
+
+    let Changeset { diffs, .. } = Changeset::new(text1, text2, "\n");
+
+    let mut t = term::stdout().unwrap();
+
+    for i in 0..diffs.len() {
+        match diffs[i] {
+            Difference::Same(ref x) => {
+                t.reset().unwrap();
+                writeln!(t, " {}", x);
+            }
+            Difference::Add(ref x) => {
+                match diffs[i - 1] {
+                    Difference::Rem(ref y) => {
+                        t.fg(term::color::GREEN).unwrap();
+                        write!(t, "+");
+                        let Changeset { diffs, .. } = Changeset::new(y, x, " ");
+                        for c in diffs {
+                            match c {
+                                Difference::Same(ref z) => {
+                                    t.fg(term::color::GREEN).unwrap();
+                                    write!(t, "{}", z);
+                                    write!(t, " ");
+                                }
+                                Difference::Add(ref z) => {
+                                    t.fg(term::color::WHITE).unwrap();
+                                    t.bg(term::color::GREEN).unwrap();
+                                    write!(t, "{}", z);
+                                    t.reset().unwrap();
+                                    write!(t, " ");
+                                }
+                                _ => (),
+                            }
+                        }
+                        writeln!(t, "");
+                    }
+                    _ => {
+                        t.fg(term::color::BRIGHT_GREEN).unwrap();
+                        writeln!(t, "+{}", x);
+                    }
+                };
+            }
+            Difference::Rem(ref x) => {
+                t.fg(term::color::RED).unwrap();
+                writeln!(t, "-{}", x);
+            }
+        }
+    }
+    t.reset().unwrap();
+    t.flush().unwrap();
+}
diff --git a/rustc_deps/vendor/difference/examples/line-by-line.rs b/rustc_deps/vendor/difference/examples/line-by-line.rs
new file mode 100644
index 0000000..d23ba81
--- /dev/null
+++ b/rustc_deps/vendor/difference/examples/line-by-line.rs
@@ -0,0 +1,52 @@
+extern crate term;
+extern crate difference;
+use difference::{Difference, Changeset};
+use std::io::Write;
+
+/*
+ * The only thing to do here is to create a diff based on line
+ * splits (passing the newline character as a split symbol)
+ * and iterate over the results, matching and formatting them based
+ * on the type of `Difference`.
+ *
+ * Screenshot:
+ * https://raw.githubusercontent.com/johannhof/difference.rs/master/assets/git-style.png
+ */
+
+#[allow(unused_must_use)]
+#[cfg_attr(feature = "cargo-clippy", allow(needless_range_loop))]
+fn main() {
+    let text1 = "Roses are red, violets are blue,\n\
+               I wrote this library here,\n\
+               just for you.\n\
+               (It's true).";
+
+    let text2 = "Roses are red, violets are blue,\n\
+               I wrote this documentation here,\n\
+               just for you.\n\
+               (It's quite true).";
+
+    // Compare both texts, the third parameter defines the split level.
+    let Changeset { diffs, .. } = Changeset::new(text1, text2, "\n");
+
+    let mut t = term::stdout().unwrap();
+
+    for i in 0..diffs.len() {
+        match diffs[i] {
+            Difference::Same(ref x) => {
+                t.reset().unwrap();
+                writeln!(t, " {}", x);
+            }
+            Difference::Add(ref x) => {
+                t.fg(term::color::GREEN).unwrap();
+                writeln!(t, "+{}", x);
+            }
+            Difference::Rem(ref x) => {
+                t.fg(term::color::RED).unwrap();
+                writeln!(t, "-{}", x);
+            }
+        }
+    }
+    t.reset().unwrap();
+    t.flush().unwrap();
+}
diff --git a/rustc_deps/vendor/difference/examples/underline-words.rs b/rustc_deps/vendor/difference/examples/underline-words.rs
new file mode 100644
index 0000000..9fef95b
--- /dev/null
+++ b/rustc_deps/vendor/difference/examples/underline-words.rs
@@ -0,0 +1,54 @@
+extern crate term;
+extern crate difference;
+use difference::{Difference, Changeset};
+use std::io::Write;
+
+// Screenshot:
+// https://raw.githubusercontent.com/johannhof/difference.rs/master/assets/word-underline.png
+
+#[allow(unused_must_use)]
+fn main() {
+    let text1 = "Roses are red, violets are blue.";
+    let text2 = "Roses are blue, violets are";
+
+    let mut t = term::stdout().unwrap();
+
+    let Changeset { diffs, .. } = Changeset::new(text1, text2, "");
+
+    for c in &diffs {
+        match *c {
+            Difference::Same(ref z) => {
+                t.fg(term::color::RED).unwrap();
+                write!(t, "{}", z);
+            }
+            Difference::Rem(ref z) => {
+                t.fg(term::color::WHITE).unwrap();
+                t.bg(term::color::RED).unwrap();
+                write!(t, "{}", z);
+                t.reset().unwrap();
+            }
+            _ => (),
+        }
+    }
+    t.reset().unwrap();
+
+    writeln!(t, "");
+
+    for c in &diffs {
+        match *c {
+            Difference::Same(ref z) => {
+                t.fg(term::color::GREEN).unwrap();
+                write!(t, "{}", z);
+            }
+            Difference::Add(ref z) => {
+                t.fg(term::color::WHITE).unwrap();
+                t.bg(term::color::GREEN).unwrap();
+                write!(t, "{}", z);
+                t.reset().unwrap();
+            }
+            _ => (),
+        }
+    }
+    t.reset().unwrap();
+    t.flush().unwrap();
+}
diff --git a/rustc_deps/vendor/difference/rustfmt.toml b/rustc_deps/vendor/difference/rustfmt.toml
new file mode 100644
index 0000000..501bd8a
--- /dev/null
+++ b/rustc_deps/vendor/difference/rustfmt.toml
@@ -0,0 +1,3 @@
+format_strings = false
+reorder_imports = true
+error_on_line_overflow = false
diff --git a/rustc_deps/vendor/difference/src/display.rs b/rustc_deps/vendor/difference/src/display.rs
new file mode 100644
index 0000000..826cb10
--- /dev/null
+++ b/rustc_deps/vendor/difference/src/display.rs
@@ -0,0 +1,100 @@
+
+
+use super::{Changeset, Difference};
+use std::fmt;
+
+impl fmt::Display for Changeset {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        for d in &self.diffs {
+            match *d {
+                Difference::Same(ref x) => {
+                    try!(write!(f, "{}{}", x, self.split));
+                }
+                Difference::Add(ref x) => {
+                    try!(write!(f, "\x1b[92m{}\x1b[0m{}", x, self.split));
+                }
+                Difference::Rem(ref x) => {
+                    try!(write!(f, "\x1b[91m{}\x1b[0m{}", x, self.split));
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::Changeset;
+    use std::io::Write;
+    use std::iter::FromIterator;
+    use std::thread;
+    use std::time;
+
+    /// convert slice to vector for assert_eq
+    fn vb(b: &'static [u8]) -> Vec<u8> {
+        Vec::from_iter(b.iter().cloned())
+    }
+
+    /// if the format changes, you can use this to help create the test for color
+    /// just pass it in and copy-paste (validating that it looks right first of course...)
+    #[allow(dead_code)]
+    fn debug_bytes(result: &[u8], expected: &[u8]) {
+        // sleep for a bit so stderr passes us
+        thread::sleep(time::Duration::new(0, 2e8 as u32));
+        println!("Debug Result:");
+        for b in result {
+            print!("{}", *b as char);
+        }
+        println!("Repr Result:");
+        repr_bytes(result);
+        println!("");
+        println!("--Result Repr DONE");
+
+        println!("Debug Expected:");
+        for b in expected {
+            print!("{}", *b as char);
+        }
+        println!("Repr Expected:");
+        repr_bytes(expected);
+        println!("");
+        println!("--Expected Repr DONE");
+    }
+
+    /// for helping debugging what the actual bytes are
+    /// for writing user tests
+    fn repr_bytes(bytes: &[u8]) {
+        for b in bytes {
+            match *b {
+                // 9 => print!("{}", *b as char), // TAB
+                b'\n' => print!("\\n"),
+                b'\r' => print!("\\r"),
+                32...126 => print!("{}", *b as char), // visible ASCII
+                _ => print!(r"\x{:0>2x}", b),
+
+            }
+        }
+    }
+
+    #[test]
+    fn test_display() {
+        let text1 = "Roses are red, violets are blue,\n\
+                     I wrote this library,\n\
+                     just for you.\n\
+                     (It's true).";
+
+        let text2 = "Roses are red, violets are blue,\n\
+                     I wrote this documentation,\n\
+                     just for you.\n\
+                     (It's quite true).";
+        let expected = b"Roses are red, violets are blue,\n\x1b[91mI wrote this library,\x1b\
+            [0m\n\x1b[92mI wrote this documentation,\x1b[0m\njust for you.\n\x1b\
+            [91m(It's true).\x1b[0m\n\x1b[92m(It's quite true).\x1b[0m\n";
+
+        let ch = Changeset::new(text1, text2, "\n");
+        let mut result: Vec<u8> = Vec::new();
+        write!(result, "{}", ch).unwrap();
+        debug_bytes(&result, expected);
+        assert_eq!(result, vb(expected));
+
+    }
+}
diff --git a/rustc_deps/vendor/difference/src/lcs.rs b/rustc_deps/vendor/difference/src/lcs.rs
new file mode 100644
index 0000000..abe9839
--- /dev/null
+++ b/rustc_deps/vendor/difference/src/lcs.rs
@@ -0,0 +1,131 @@
+use std::cmp::max;
+
+// strsplit is like `s.split(split)`, except that if `split` is "", it
+// trims the leading and trailing empty elements, since the `lcs`
+// logic won't handle those properly.
+fn strsplit<'a>(s: &'a str, split: &str) -> Vec<&'a str> {
+    let mut si = s.split(split);
+    if split == "" {
+        si.next();
+    }
+    let mut v: Vec<&str> = si.collect();
+    if split == "" {
+        v.pop();
+    }
+    v
+}
+
+// finds the longest common subsequences
+// outputs the edit distance and a string containing
+// all chars both inputs have in common
+//
+// This algorithm is based on
+// https://en.wikipedia.org/wiki/Longest_common_subsequence_problem#Code_for_the_dynamic_programming_solution
+#[allow(non_snake_case)]
+#[cfg_attr(feature = "cargo-clippy", allow(many_single_char_names))]
+pub fn lcs(orig: &str, edit: &str, split: &str) -> (i32, String) {
+    // make list by custom splits
+    let a = strsplit(orig, split);
+    let b = strsplit(edit, split);
+
+    let N = a.len();
+    let M = b.len();
+
+    let mut idx: Vec<usize> = Vec::with_capacity(N * M);
+    idx.resize(N * M, 0);
+
+    for i in 0..N {
+        for j in 0..M {
+            if b[j] == a[i] {
+                if i == 0 || j == 0 {
+                    idx[i * M + j] = 1;
+                } else {
+                    idx[i * M + j] = idx[(i - 1) * M + j - 1] + 1;
+                }
+            } else if i == 0 {
+                if j == 0 {
+                    idx[i * M + j] = 0;
+                } else {
+                    idx[i * M + j] = idx[i * M + j - 1];
+                }
+            } else if j == 0 {
+                idx[i * M + j] = idx[(i - 1) * M + j];
+            } else {
+                idx[i * M + j] = max(idx[i * M + j - 1], idx[(i - 1) * M + j]);
+            }
+        }
+    }
+
+    let mut i = (N as isize) - 1;
+    let mut j = (M as isize) - 1;
+    let mut lcs = Vec::new();
+    while i >= 0 && j >= 0 {
+        let ui = i as usize;
+        let uj = j as usize;
+        if a[ui] == b[uj] {
+            lcs.push(a[ui]);
+            i -= 1;
+            j -= 1;
+        } else if j == 0 && i == 0 {
+            break;
+        } else if i == 0 || idx[ui * M + uj - 1] > idx[(ui - 1) * M + uj] {
+            j -= 1;
+        } else {
+            i -= 1;
+        }
+    }
+
+    lcs.reverse();
+    ((N + M - 2 * lcs.len()) as i32, lcs.join(split))
+}
+
+#[test]
+fn test_lcs() {
+    assert_eq!(lcs("test", "tost", ""), (2, "tst".to_string()));
+    assert_eq!(lcs("test", "test", ""), (0, "test".to_string()));
+
+    assert_eq!(lcs("test", "test", " "), (0, "test".to_string()));
+
+    assert_eq!(
+        lcs(
+            "The quick brown fox jumps over the lazy dog",
+            "The quick brown dog leaps over the lazy cat",
+            "",
+        ),
+        (16, "The quick brown o ps over the lazy ".to_string())
+    );
+    assert_eq!(
+        lcs(
+            "The quick brown fox jumps over the lazy dog",
+            "The quick brown dog leaps over the lazy cat",
+            " ",
+        ),
+        (6, "The quick brown over the lazy".to_string())
+    );
+
+    assert_eq!(
+        lcs(
+            "The quick brown fox jumps over the lazy dog",
+            "The quick brown dog leaps over the lazy cat",
+            "\n",
+        ),
+        (2, "".to_string())
+    );
+    assert_eq!(
+        lcs(
+            "The quick brown fox jumps over the lazy dog",
+            "The quick brown fox jumps over the lazy dog",
+            "\n",
+        ),
+        (0, "The quick brown fox jumps over the lazy dog".to_string())
+    );
+
+    assert_eq!(
+        lcs("a b : c", "b a : b : c", " "),
+        (2, "a b : c".to_string())
+    );
+
+    assert_eq!(lcs("", "a b c", ""), (5, "".to_string()));
+
+    assert_eq!(lcs("", " a", " "), (1, "".to_string()));
+}
diff --git a/rustc_deps/vendor/difference/src/lib.rs b/rustc_deps/vendor/difference/src/lib.rs
new file mode 100644
index 0000000..37f27bf
--- /dev/null
+++ b/rustc_deps/vendor/difference/src/lib.rs
@@ -0,0 +1,334 @@
+//! Functions to find the difference between two texts (strings).
+//! Usage
+//! ----------
+//!
+//! Add the following to your `Cargo.toml`:
+//!
+//! ```toml
+//! [dependencies]
+//! difference = "2.0"
+//! ```
+//!
+//! Now you can use the crate in your code
+//! ```ignore
+//! extern crate difference;
+//! ```
+//!
+//! ## Examples
+//!
+//! See [Examples.md](Examples.md) for more examples.
+//!
+//! ```rust
+//! use difference::{Difference, Changeset};
+//!
+//! let changeset = Changeset::new("test", "tent", "");
+//!
+//! assert_eq!(changeset.diffs, vec![
+//!   Difference::Same("te".to_string()),
+//!   Difference::Rem("s".to_string()),
+//!   Difference::Add("n".to_string()),
+//!   Difference::Same("t".to_string())
+//! ]);
+//! ```
+
+#![crate_name = "difference"]
+#![doc(html_root_url = "http://docs.rs/difference")]
+#![deny(missing_docs)]
+#![deny(warnings)]
+
+mod lcs;
+mod merge;
+mod display;
+
+use lcs::lcs;
+use merge::merge;
+
+/// Defines the contents of a changeset
+/// Changesets will be delivered in order of appearance in the original string
+/// Sequences of the same kind will be grouped into one Difference
+#[derive(PartialEq, Debug)]
+pub enum Difference {
+    /// Sequences that are the same
+    Same(String),
+    /// Sequences that are an addition (don't appear in the first string)
+    Add(String),
+    /// Sequences that are a removal (don't appear in the second string)
+    Rem(String),
+}
+
+/// The information about a full changeset
+pub struct Changeset {
+    /// An ordered vector of `Difference` objects, coresponding
+    /// to the differences within the text
+    pub diffs: Vec<Difference>,
+    /// The split used when creating the `Changeset`
+    /// Common splits are `""` for char-level, `" "` for word-level and `"\n"` for line-level.
+    pub split: String,
+    /// The edit distance of the `Changeset`
+    pub distance: i32,
+}
+
+impl Changeset {
+    /// Calculates the edit distance and the changeset for two given strings.
+    /// The first string is assumed to be the "original", the second to be an
+    /// edited version of the first. The third parameter specifies how to split
+    /// the input strings, leading to a more or less exact comparison.
+    ///
+    /// Common splits are `""` for char-level, `" "` for word-level and `"\n"` for line-level.
+    ///
+    /// Outputs the edit distance (how much the two strings differ) and a "changeset", that is
+    /// a `Vec` containing `Difference`s.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use difference::{Changeset, Difference};
+    ///
+    /// let changeset = Changeset::new("test", "tent", "");
+    ///
+    /// assert_eq!(changeset.diffs, vec![
+    ///     Difference::Same("te".to_string()),
+    ///     Difference::Rem("s".to_string()),
+    ///     Difference::Add("n".to_string()),
+    ///     Difference::Same("t".to_string())
+    /// ]);
+    /// ```
+    pub fn new(orig: &str, edit: &str, split: &str) -> Changeset {
+        let (dist, common) = lcs(orig, edit, split);
+        Changeset {
+            diffs: merge(orig, edit, &common, split),
+            split: split.to_string(),
+            distance: dist,
+        }
+    }
+}
+
+/// **This function is deprecated, please use `Changeset::new` instead**
+///
+/// Calculates the edit distance and the changeset for two given strings.
+/// The first string is assumed to be the "original", the second to be an
+/// edited version of the first. The third parameter specifies how to split
+/// the input strings, leading to a more or less exact comparison.
+///
+/// Common splits are `""` for char-level, `" "` for word-level and `"\n"` for line-level.
+///
+/// Outputs the edit distance (how much the two strings differ) and a "changeset", that is
+/// a `Vec` containing `Difference`s.
+///
+/// # Examples
+///
+/// ```
+/// use difference::diff;
+/// use difference::Difference;
+///
+/// let (dist, changeset) = diff("test", "tent", "");
+///
+/// assert_eq!(changeset, vec![
+///     Difference::Same("te".to_string()),
+///     Difference::Rem("s".to_string()),
+///     Difference::Add("n".to_string()),
+///     Difference::Same("t".to_string())
+/// ]);
+/// ```
+#[deprecated(since = "1.0.0", note = "please use `Changeset::new` instead")]
+pub fn diff(orig: &str, edit: &str, split: &str) -> (i32, Vec<Difference>) {
+    let ch = Changeset::new(orig, edit, split);
+    (ch.distance, ch.diffs)
+}
+
+/// Assert the difference between two strings. Works like diff, but takes
+/// a fourth parameter that is the expected edit distance (e.g. 0 if you want to
+/// test for equality).
+///
+/// To include this macro use:
+///
+/// ```
+/// #[macro_use(assert_diff)]
+/// extern crate difference;
+/// # fn main() { }
+/// ```
+///
+/// Remember that edit distance might not be equal to your understanding of difference,
+/// for example the words "Rust" and "Dust" have an edit distance of 2 because two changes (a
+/// removal and an addition) are required to make them look the same.
+///
+/// Will print an error with a colorful diff in case of failure.
+#[macro_export]
+macro_rules! assert_diff {
+    ($orig:expr , $edit:expr, $split: expr, $expected: expr) => ({
+        let orig = $orig;
+        let edit = $edit;
+
+        let changeset = $crate::Changeset::new(orig, edit, &($split));
+        if changeset.distance != $expected {
+            println!("{}", changeset);
+            panic!("assertion failed: edit distance between {:?} and {:?} is {} and not {}, see \
+                    diffset above",
+                   orig,
+                   edit,
+                   changeset.distance,
+                   &($expected))
+        }
+    })
+}
+
+/// **This function is deprecated, `Changeset` now implements the `Display` trait instead**
+///
+/// Prints a colorful visual representation of the diff.
+/// This is just a convenience function for those who want quick results.
+///
+/// I recommend checking out the examples on how to build your
+/// own diff output.
+/// # Examples
+///
+/// ```
+/// use difference::print_diff;
+/// print_diff("Diffs are awesome", "Diffs are cool", " ");
+/// ```
+#[deprecated(since = "1.0.0", note = "`Changeset` now implements the `Display` trait instead")]
+pub fn print_diff(orig: &str, edit: &str, split: &str) {
+    let ch = Changeset::new(orig, edit, split);
+    println!("{}", ch);
+}
+
+#[test]
+fn test_diff() {
+    let text1 = "Roses are red, violets are blue,\n\
+                 I wrote this library,\n\
+                 just for you.\n\
+                 (It's true).";
+
+    let text2 = "Roses are red, violets are blue,\n\
+                 I wrote this documentation,\n\
+                 just for you.\n\
+                 (It's quite true).";
+
+    let changeset = Changeset::new(text1, text2, "\n");
+
+    assert_eq!(changeset.distance, 4);
+
+    assert_eq!(
+        changeset.diffs,
+        vec![
+            Difference::Same("Roses are red, violets are blue,".to_string()),
+            Difference::Rem("I wrote this library,".to_string()),
+            Difference::Add("I wrote this documentation,".to_string()),
+            Difference::Same("just for you.".to_string()),
+            Difference::Rem("(It's true).".to_string()),
+            Difference::Add("(It's quite true).".to_string()),
+        ]
+    );
+}
+
+#[test]
+fn test_diff_brief() {
+    let text1 = "Hello\nworld";
+    let text2 = "Ola\nmundo";
+
+    let changeset = Changeset::new(text1, text2, "\n");
+
+    assert_eq!(
+        changeset.diffs,
+        vec![
+            Difference::Rem("Hello\nworld".to_string()),
+            Difference::Add("Ola\nmundo".to_string()),
+        ]
+    );
+}
+
+#[test]
+fn test_diff_smaller_line_count_on_left() {
+    let text1 = "Hello\nworld";
+    let text2 = "Ola\nworld\nHow is it\ngoing?";
+
+    let changeset = Changeset::new(text1, text2, "\n");
+
+    assert_eq!(
+        changeset.diffs,
+        vec![
+            Difference::Rem("Hello".to_string()),
+            Difference::Add("Ola".to_string()),
+            Difference::Same("world".to_string()),
+            Difference::Add("How is it\ngoing?".to_string()),
+        ]
+    );
+}
+
+#[test]
+fn test_diff_smaller_line_count_on_right() {
+    let text1 = "Hello\nworld\nWhat a \nbeautiful\nday!";
+    let text2 = "Ola\nworld";
+
+    let changeset = Changeset::new(text1, text2, "\n");
+
+    assert_eq!(
+        changeset.diffs,
+        vec![
+            Difference::Rem("Hello".to_string()),
+            Difference::Add("Ola".to_string()),
+            Difference::Same("world".to_string()),
+            Difference::Rem("What a \nbeautiful\nday!".to_string()),
+        ]
+    );
+}
+
+#[test]
+fn test_diff_similar_text_with_smaller_line_count_on_right() {
+    let text1 = "Hello\nworld\nWhat a \nbeautiful\nday!";
+    let text2 = "Hello\nwoRLd";
+
+    let changeset = Changeset::new(text1, text2, "\n");
+
+    assert_eq!(
+        changeset.diffs,
+        vec![
+            Difference::Same("Hello".to_string()),
+            Difference::Rem("world\nWhat a \nbeautiful\nday!".to_string()),
+            Difference::Add("woRLd".to_string()),
+        ]
+    );
+}
+
+#[test]
+fn test_diff_similar_text_with_similar_line_count() {
+    let text1 = "Hello\nworld\nWhat a \nbeautiful\nday!";
+    let text2 = "Hello\nwoRLd\nbeautiful";
+
+    let changeset = Changeset::new(text1, text2, "\n");
+
+    assert_eq!(
+        changeset.diffs,
+        vec![
+            Difference::Same("Hello".to_string()),
+            Difference::Rem("world\nWhat a ".to_string()),
+            Difference::Add("woRLd".to_string()),
+            Difference::Same("beautiful".to_string()),
+            Difference::Rem("day!".to_string()),
+        ]
+    );
+}
+
+#[test]
+#[should_panic]
+fn test_assert_diff_panic() {
+    let text1 = "Roses are red, violets are blue,\n\
+                 I wrote this library,\n\
+                 just for you.\n\
+                 (It's true).";
+
+    let text2 = "Roses are red, violets are blue,\n\
+                 I wrote this documentation,\n\
+                 just for you.\n\
+                 (It's quite true).";
+
+    assert_diff!(text1, text2, "\n'", 0);
+}
+
+#[test]
+fn test_assert_diff() {
+    let text1 = "Roses are red, violets are blue";
+
+    let text2 = "Roses are green, violets are blue";
+
+    assert_diff!(text1, text2, " ", 2);
+}
diff --git a/rustc_deps/vendor/difference/src/main.rs b/rustc_deps/vendor/difference/src/main.rs
new file mode 100644
index 0000000..a5ec9a9
--- /dev/null
+++ b/rustc_deps/vendor/difference/src/main.rs
@@ -0,0 +1,46 @@
+#![deny(warnings)]
+
+#[cfg(feature = "bin")]
+extern crate difference;
+#[cfg(feature = "bin")]
+extern crate getopts;
+
+#[cfg(feature = "bin")]
+use getopts::Options;
+#[cfg(feature = "bin")]
+use std::env;
+
+#[cfg(not(feature = "bin"))]
+fn main() {
+    panic!("Needs to be compiled with --features=bin");
+}
+
+#[cfg(feature = "bin")]
+fn main() {
+    let args: Vec<String> = env::args().collect();
+    let program = args[0].clone();
+
+    let mut opts = Options::new();
+    opts.optopt("s", "split", "", "char|word|line");
+    let matches = match opts.parse(&args[1..]) {
+        Ok(m) => m,
+        Err(f) => panic!(f.to_string()),
+    };
+
+    let split = match matches.opt_str("s") {
+        Some(ref x) if x == "char" => "",
+        Some(ref x) if x == "word" => " ",
+        Some(ref x) if x == "line" => "\n",
+        _ => " ",
+    };
+
+    if matches.free.len() > 1 {
+        let ch = difference::Changeset::new(&matches.free[0], &matches.free[1], split);
+        println!("{}", ch);
+    } else {
+        print!("{}", opts.usage(&format!("Usage: {} [options]", program)));
+        return;
+    };
+
+
+}
diff --git a/rustc_deps/vendor/difference/src/merge.rs b/rustc_deps/vendor/difference/src/merge.rs
new file mode 100644
index 0000000..a8e7093
--- /dev/null
+++ b/rustc_deps/vendor/difference/src/merge.rs
@@ -0,0 +1,92 @@
+use Difference;
+
+// merges the changes from two strings, given a common substring
+pub fn merge(orig: &str, edit: &str, common: &str, split: &str) -> Vec<Difference> {
+    let mut ret = Vec::new();
+
+    let mut l = orig.split(split).peekable();
+    let mut r = edit.split(split).peekable();
+    let mut c = common.split(split).peekable();
+
+    // Turn empty strings into [], not [""]
+    if orig == "" {
+        l.next();
+    }
+    if edit == "" {
+        r.next();
+    }
+    if common == "" {
+        c.next();
+    }
+
+    while l.peek().is_some() || r.peek().is_some() {
+        let mut same = Vec::new();
+        while l.peek().is_some() && l.peek() == c.peek() && r.peek() == c.peek() {
+            same.push(l.next().unwrap());
+            r.next();
+            c.next();
+        }
+        if !same.is_empty() {
+            let joined = same.join(split);
+            if split != "" || joined != "" {
+                ret.push(Difference::Same(joined));
+            }
+        }
+
+        let mut rem = Vec::new();
+        while l.peek().is_some() && l.peek() != c.peek() {
+            rem.push(l.next().unwrap());
+        }
+        if !rem.is_empty() {
+            ret.push(Difference::Rem(rem.join(split)));
+        }
+
+        let mut add = Vec::new();
+        while r.peek().is_some() && r.peek() != c.peek() {
+            add.push(r.next().unwrap());
+        }
+        if !add.is_empty() {
+            ret.push(Difference::Add(add.join(split)));
+        }
+    }
+
+    ret
+}
+
+
+#[test]
+fn test_merge() {
+    assert_eq!(
+        merge("testa", "tost", "tst", ""),
+        vec![
+            Difference::Same("t".to_string()),
+            Difference::Rem("e".to_string()),
+            Difference::Add("o".to_string()),
+            Difference::Same("st".to_string()),
+            Difference::Rem("a".to_string()),
+        ]
+    );
+
+    assert_eq!(
+        merge("", "a", "", ""),
+        vec![Difference::Add("a".to_string())]
+    );
+
+    assert_eq!(
+        merge("a\nb", "a\n\nb", "a\nb", "\n"),
+        vec![
+            Difference::Same("a".to_string()),
+            Difference::Add("".to_string()),
+            Difference::Same("b".to_string()),
+        ]
+    );
+
+    assert_eq!(
+        merge("a\n", "c\n", "\n", "\n"),
+        vec![
+            Difference::Rem("a".to_string()),
+            Difference::Add("c".to_string()),
+            Difference::Same("".to_string()),
+        ]
+    );
+}
diff --git a/rustc_deps/vendor/difference/tests/quickcheck.rs b/rustc_deps/vendor/difference/tests/quickcheck.rs
new file mode 100644
index 0000000..e376654
--- /dev/null
+++ b/rustc_deps/vendor/difference/tests/quickcheck.rs
@@ -0,0 +1,132 @@
+extern crate difference;
+extern crate quickcheck;
+
+use difference::{Changeset, Difference};
+use quickcheck::{TestResult, quickcheck, QuickCheck};
+use std::fmt;
+
+const DEBUG: bool = false;
+
+struct Check<'a> {
+    old: &'a str,
+    new: &'a str,
+    changeset: Changeset,
+}
+
+impl<'a> fmt::Display for Check<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(
+            f,
+            "Changeset::new({:?}, {:?}, {:?}) -> [",
+            self.old,
+            self.new,
+            self.changeset.split
+        )?;
+
+        let mut iter = self.changeset.diffs.iter();
+        if let Some(d) = iter.next() {
+            write!(f, "{:?}", d)?;
+        }
+        for d in iter {
+            write!(f, " {:?}", d)?;
+        }
+        write!(f, "]")
+    }
+}
+
+fn check_changeset(old: &str, new: &str, split: &str) -> TestResult {
+    Check::new(old, new, split).check()
+}
+
+impl<'a> Check<'a> {
+    fn new(old: &'a str, new: &'a str, split: &'a str) -> Check<'a> {
+        Check {
+            old: old,
+            new: new,
+            changeset: Changeset::new(old, new, split),
+        }
+    }
+
+    fn check(&self) -> TestResult {
+        let split = &self.changeset.split;
+
+        let mut old: Vec<&str> = Vec::new();
+        let mut new: Vec<&str> = Vec::new();
+
+        for d in &self.changeset.diffs {
+            if DEBUG {
+                println!("assert `{:?}` (old: {:?}, new: {:?})", d, old, new);
+            }
+
+            match *d {
+                Difference::Same(ref x) => {
+                    old.push(x);
+                    new.push(x);
+                }
+                Difference::Add(ref x) => {
+                    new.push(x);
+                }
+                Difference::Rem(ref x) => {
+                    old.push(x);
+                }
+            }
+        }
+        let got_old = old.join(split);
+        let got_new = new.join(split);
+        if got_old != self.old {
+            return TestResult::error(format!("Diff output implies old=`{:?}`, not `{:?}` in {}",
+                        got_old, self.old, self,
+                ));
+        }
+        if got_new != self.new {
+            return TestResult::error(format!("Diff output implies new=`{:?}`, not `{:?}` in {}",
+                        got_new, self.new, self,
+                ));
+        }
+
+        TestResult::passed()
+    }
+}
+
+#[test]
+fn simple() {
+    quickcheck(check_changeset("a", "a a", " "));
+}
+
+#[test]
+fn issue_19() {
+    // https://github.com/johannhof/difference.rs/issues/19
+    quickcheck(check_changeset("a b : g", "b a : b b : g g", " "));
+}
+
+#[test]
+#[allow(needless_pass_by_value)]
+fn fuzzy() {
+    fn prop(old: Vec<usize>, new: Vec<usize>, words: Vec<char>) -> TestResult {
+        if words.is_empty() {
+            return TestResult::discard();
+        }
+
+        fn map_to_words(input: &[usize], words: &[char]) -> String {
+            input.iter().enumerate().fold(
+                String::new(),
+                |mut acc, (i, x)| {
+                    if i > 0 {
+                        acc.push(' ');
+                    }
+                    acc.push(words[x % words.len()]);
+                    acc
+                },
+            )
+        }
+        let old = map_to_words(&old, &words);
+        let new = map_to_words(&new, &words);
+
+        check_changeset(&old, &new, " ")
+    }
+
+    QuickCheck::new()
+        .tests(100) // max successful tests
+        .max_tests(10_000) // max attempts
+        .quickcheck(prop as fn(Vec<usize>, Vec<usize>, Vec<char>) -> TestResult);
+}
diff --git a/rustc_deps/vendor/pretty_assertions/.cargo-checksum.json b/rustc_deps/vendor/pretty_assertions/.cargo-checksum.json
new file mode 100644
index 0000000..cdacee5
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{".travis.yml":"ff0e8f86a91e512373aae42ed8cfb6411d5a1c7e986a81d0f2062d6e1e2943b9","Cargo.toml":"ab18b2e7553414ddb13a440c2e65fc0300d8c5e7b16b6bf3a08a5f3088a49666","LICENSE-APACHE":"2e54cd84a645bea25943c75dd8ae67cb291e66a47a11578333c9b4b3b6b86c85","LICENSE-MIT":"95957289f00a90ccbe04c7d792677e5b6ee2425a08c483b1c3aba194eb83ee29","README.md":"c8443ea0a9813ead34efe2dbe142f1cceef4d35d973f205a5b807c44bfc4474a","examples/pretty_assertion.png":"9d5e425076ce4c593cd38634522e2ad40ff6a2fd8db09a3480589fa9b42b6417","examples/pretty_assertion.rs":"02117bfc769f4c9c0eb8710c5e52d72b5e5f024cddcc737663fd749819aac4fb","examples/standard_assertion.png":"939e98b0de9a96b0f7a71e9a91fce0d05824e14d5d7757446d2df4313e0b409b","examples/standard_assertion.rs":"8913d32b23d8d4532f128e5d5580d83f6209e67e98d28d50388a3383d228ad72","src/format_changeset.rs":"158832e72b0484916747765bb9a6bf61177f8930b24e231b8007f103219cd420","src/lib.rs":"40abf0ffe7504496c9e2ccdc8919a915a2107be93b78467ba984abfbc6a764a1","tests/assert_eq.rs":"7fd2a386a66a3fe284fc640a82c2d31ebe9dcc0e9e209ee0c4c26f0887ba840b","tests/assert_ne.rs":"fdc0936c9e66ab3898183556aec2537cc76b288c13a742c73541f6b3e84e7858"},"package":"3a029430f0d744bc3d15dd474d591bed2402b645d024583082b9f63bb936dac6"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/pretty_assertions/.travis.yml b/rustc_deps/vendor/pretty_assertions/.travis.yml
new file mode 100644
index 0000000..60d5757
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/.travis.yml
@@ -0,0 +1,12 @@
+sudo: false

+language: rust

+cache: cargo

+rust:

+  - nightly

+  - beta

+  - stable

+  - 1.17.0

+script: |

+  cargo build &&

+  cargo test &&

+  cargo doc

diff --git a/rustc_deps/vendor/pretty_assertions/Cargo.toml b/rustc_deps/vendor/pretty_assertions/Cargo.toml
new file mode 100644
index 0000000..3861beb
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/Cargo.toml
@@ -0,0 +1,30 @@
+# 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 = "pretty_assertions"
+version = "0.5.1"
+authors = ["Colin Kiegel <kiegel@gmx.de>", "Florent Fayolle <florent.fayolle69@gmail.com>"]
+description = "Overwrite `assert_eq!` and `assert_ne!` with drop-in replacements, adding colorful diffs."
+documentation = "https://docs.rs/pretty_assertions"
+readme = "README.md"
+keywords = ["assert", "diff", "pretty", "color"]
+categories = ["development-tools"]
+license = "MIT/Apache-2.0"
+repository = "https://github.com/colin-kiegel/rust-pretty-assertions"
+[dependencies.ansi_term]
+version = "0.11"
+
+[dependencies.difference]
+version = "2.0.0"
+[badges.travis-ci]
+repository = "colin-kiegel/rust-pretty-assertions"
diff --git a/rustc_deps/vendor/pretty_assertions/LICENSE-APACHE b/rustc_deps/vendor/pretty_assertions/LICENSE-APACHE
new file mode 100644
index 0000000..113e843
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/LICENSE-APACHE
@@ -0,0 +1,202 @@
+                                 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/pretty_assertions/LICENSE-MIT b/rustc_deps/vendor/pretty_assertions/LICENSE-MIT
new file mode 100644
index 0000000..4558bb9
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/LICENSE-MIT
@@ -0,0 +1,21 @@
+The MIT License (MIT)

+

+Copyright (c) 2016 rust-derive-builder contributors

+

+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/pretty_assertions/README.md b/rustc_deps/vendor/pretty_assertions/README.md
new file mode 100644
index 0000000..682a2a9
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/README.md
@@ -0,0 +1,85 @@
+[![Build status](https://travis-ci.org/colin-kiegel/rust-pretty-assertions.svg?branch=master)](https://travis-ci.org/colin-kiegel/rust-pretty-assertions)

+[![Latest version](https://img.shields.io/crates/v/pretty-assertions.svg)](https://crates.io/crates/pretty-assertions)

+[![All downloads](https://img.shields.io/crates/d/pretty-assertions.svg)](https://crates.io/crates/pretty-assertions)

+[![Downloads of latest version](https://img.shields.io/crates/dv/pretty-assertions.svg)](https://crates.io/crates/pretty-assertions)

+

+# Pretty Assertions

+

+When writing tests in Rust, you'll probably use `assert_eq!(a, b)` _a lot_.

+

+If such a test fails, it will present all the details of `a` and `b`, but you have to spot, the differences yourself, which is not always straightforward, like here:

+

+![standard assertion](examples/standard_assertion.png)

+

+Wouldn't that task be _much_ easier with a colorful diff?

+

+![pretty assertion](examples/pretty_assertion.png)

+

+Yep — and you only need **one line of code** to make it happen:

+

+```rust,ignore

+#[macro_use] extern crate pretty_assertions;

+```

+

+<details>

+<summary>Show the example behind the screenshots above.</summary>

+

+```rust,ignore

+// 1. add the `pretty_assertions` dependency to `Cargo.toml`.

+// 2. insert this line at the top of your crate root or integration test

+#[macro_use] extern crate pretty_assertions;

+

+fn main() {

+    #[derive(Debug, PartialEq)]

+    struct Foo {

+        lorem: &'static str,

+        ipsum: u32,

+        dolor: Result<String, String>,

+    }

+

+    let x = Some(Foo { lorem: "Hello World!", ipsum: 42, dolor: Ok("hey".to_string())});

+    let y = Some(Foo { lorem: "Hello Wrold!", ipsum: 42, dolor: Ok("hey ho!".to_string())});

+

+    assert_eq!(x, y);

+}

+```

+</details>

+

+## Tip

+

+Specify it as [`[dev-dependencies]`](http://doc.crates.io/specifying-dependencies.html#development-dependencies)

+and it will only be used for compiling tests, examples, and benchmarks.

+This way the compile time of `cargo build` won't be affected!

+

+In your crate root, also add `#[cfg(test)]` to the crate import, like this:

+

+```rust,ignore

+#[cfg(test)] // <-- not needed in examples + integration tests

+#[macro_use]

+extern crate pretty_assertions;

+```

+

+## Note

+

+* Each example and integration test also needs `#[macro_use] extern crate

+  pretty_assertions`, if you want colorful diffs there.

+* The replacement is only effective in your own crate, not in other libraries

+  you include.

+* `assert_ne` is also switched to multi-line presentation, but does _not_ show

+  a diff.

+

+## 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/pretty_assertions/examples/pretty_assertion.png b/rustc_deps/vendor/pretty_assertions/examples/pretty_assertion.png
new file mode 100644
index 0000000..7e9da7d
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/examples/pretty_assertion.png
Binary files differ
diff --git a/rustc_deps/vendor/pretty_assertions/examples/pretty_assertion.rs b/rustc_deps/vendor/pretty_assertions/examples/pretty_assertion.rs
new file mode 100644
index 0000000..db0adc1
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/examples/pretty_assertion.rs
@@ -0,0 +1,4 @@
+#[macro_use]

+extern crate pretty_assertions;

+

+include!("standard_assertion.rs");

diff --git a/rustc_deps/vendor/pretty_assertions/examples/standard_assertion.png b/rustc_deps/vendor/pretty_assertions/examples/standard_assertion.png
new file mode 100644
index 0000000..1d7e182
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/examples/standard_assertion.png
Binary files differ
diff --git a/rustc_deps/vendor/pretty_assertions/examples/standard_assertion.rs b/rustc_deps/vendor/pretty_assertions/examples/standard_assertion.rs
new file mode 100644
index 0000000..ac3a87f
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/examples/standard_assertion.rs
@@ -0,0 +1,21 @@
+fn main() {

+    #[derive(Debug, PartialEq)]

+    struct Foo {

+        lorem: &'static str,

+        ipsum: u32,

+        dolor: Result<String, String>,

+    }

+

+    let x = Some(Foo {

+        lorem: "Hello World!",

+        ipsum: 42,

+        dolor: Ok("hey".to_string()),

+    });

+    let y = Some(Foo {

+        lorem: "Hello Wrold!",

+        ipsum: 42,

+        dolor: Ok("hey ho!".to_string()),

+    });

+

+    assert_eq!(x, y);

+}

diff --git a/rustc_deps/vendor/pretty_assertions/src/format_changeset.rs b/rustc_deps/vendor/pretty_assertions/src/format_changeset.rs
new file mode 100644
index 0000000..bb1d339
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/src/format_changeset.rs
@@ -0,0 +1,176 @@
+use difference::{Difference, Changeset};

+use std::fmt;

+use ansi_term::Colour::{Red, Green, Fixed};

+use ansi_term::Style;

+

+macro_rules! paint {

+    ($f:ident, $colour:expr, $fmt:expr, $($args:tt)*) => (

+        write!($f, "{}", $colour.paint(format!($fmt, $($args)*)))

+    )

+}

+

+const SIGN_RIGHT: char = '>'; // + > →

+const SIGN_LEFT: char = '<'; // - < ←

+

+// Adapted from:

+// https://github.com/johannhof/difference.rs/blob/c5749ad7d82aa3d480c15cb61af9f6baa08f116f/examples/github-style.rs

+// Credits johannhof (MIT License)

+

+pub fn format_changeset(f: &mut fmt::Formatter, changeset: &Changeset) -> fmt::Result {

+    let ref diffs = changeset.diffs;

+

+    writeln!(

+        f,

+        "{} {} / {} :",

+        Style::new().bold().paint("Diff"),

+        Red.paint(format!("{} left", SIGN_LEFT)),

+        Green.paint(format!("right {}", SIGN_RIGHT))

+    )?;

+    for i in 0..diffs.len() {

+        match diffs[i] {

+            Difference::Same(ref same) => {

+                // Have to split line by line in order to have the extra whitespace

+                // at the beginning.

+                for line in same.split('\n') {

+                    writeln!(f, " {}", line)?;

+                }

+            }

+            Difference::Add(ref added) => {

+                match diffs.get(i - 1) {

+                    Some(&Difference::Rem(ref removed)) => {

+                        // The addition is preceded by an removal.

+                        //

+                        // Let's highlight the character-differences in this replaced

+                        // chunk. Note that this chunk can span over multiple lines.

+                        format_replacement(f, added, removed)?;

+                    }

+                    _ => {

+                        for line in added.split('\n') {

+                            paint!(f, Green, "{}{}\n", SIGN_RIGHT, line)?;

+                        }

+                    }

+                };

+            }

+            Difference::Rem(ref removed) => {

+                match diffs.get(i + 1) {

+                    Some(&Difference::Add(_)) => {

+                        // The removal is followed by an addition.

+                        //

+                        // ... we'll handle both in the next iteration.

+                    }

+                    _ => {

+                        for line in removed.split('\n') {

+                            paint!(f, Red, "{}{}\n", SIGN_LEFT, line)?;

+                        }

+                    }

+                }

+            }

+        }

+    }

+    Ok(())

+}

+

+macro_rules! join {

+    (

+        $elem:ident in ($iter:expr) {

+            $( $body:tt )*

+        } seperated by {

+            $( $separator:tt )*

+        }

+    ) => (

+        let mut iter = $iter;

+

+        if let Some($elem) = iter.next() {

+            $( $body )*

+        }

+

+        for $elem in iter {

+            $( $separator )*

+            $( $body )*

+        }

+    )

+}

+

+pub fn format_replacement(f: &mut fmt::Write, added: &str, removed: &str) -> fmt::Result {

+    let Changeset { diffs, .. } = Changeset::new(removed, added, "");

+

+    // LEFT side (==what's been)

+    paint!(f, Red, "{}", SIGN_LEFT)?;

+    for c in &diffs {

+        match *c {

+            Difference::Same(ref word_diff) => {

+                join!(chunk in (word_diff.split('\n')) {

+                    paint!(f, Red, "{}", chunk)?;

+                } seperated by {

+                    writeln!(f)?;

+                    paint!(f, Red, "{}", SIGN_LEFT)?;

+                });

+            }

+            Difference::Rem(ref word_diff) => {

+                join!(chunk in (word_diff.split('\n')) {

+                    paint!(f, Red.on(Fixed(52)).bold(), "{}", chunk)?;

+                } seperated by {

+                    writeln!(f)?;

+                    paint!(f, Red.bold(), "{}", SIGN_LEFT)?;

+                });

+            }

+            _ => (),

+        }

+    }

+    writeln!(f, "")?;

+

+    // RIGHT side (==what's new)

+    paint!(f, Green, "{}", SIGN_RIGHT)?;

+    for c in &diffs {

+        match *c {

+            Difference::Same(ref word_diff) => {

+                join!(chunk in (word_diff.split('\n')) {

+                    paint!(f, Green, "{}", chunk)?;

+                } seperated by {

+                    writeln!(f)?;

+                    paint!(f, Green, "{}", SIGN_RIGHT)?;

+                });

+            }

+            Difference::Add(ref word_diff) => {

+                join!(chunk in (word_diff.split('\n')) {

+                    paint!(f, Green.on(Fixed(22)).bold(), "{}", chunk)?;

+                } seperated by {

+                    writeln!(f)?;

+                    paint!(f, Green.bold(), "{}", SIGN_RIGHT)?;

+                });

+            }

+            _ => (),

+        }

+    }

+

+    writeln!(f, "")

+}

+

+#[test]

+fn test_format_replacement() {

+    let added = "    84,\

+                 \n    248,";

+    let removed = "    0,\

+                 \n    0,\

+                 \n    128,";

+

+    let mut buf = String::new();

+    let _ = format_replacement(&mut buf, added, removed);

+

+    println!(

+        "## removed ##\

+            \n{}\

+            \n## added ##\

+            \n{}\

+            \n## diff ##\

+            \n{}",

+        removed,

+        added,

+        buf

+    );

+

+    assert_eq!(

+        buf,

+        "\u{1b}[31m<\u{1b}[0m\u{1b}[31m    \u{1b}[0m\u{1b}[1;48;5;52;31m0\u{1b}[0m\u{1b}[31m,\u{1b}[0m\n\u{1b}[31m<\u{1b}[0m\u{1b}[31m    \u{1b}[0m\u{1b}[1;48;5;52;31m0,\u{1b}[0m\n\u{1b}[1;31m<\u{1b}[0m\u{1b}[1;48;5;52;31m    1\u{1b}[0m\u{1b}[31m2\u{1b}[0m\u{1b}[31m8,\u{1b}[0m\n\u{1b}[32m>\u{1b}[0m\u{1b}[32m    \u{1b}[0m\u{1b}[1;48;5;22;32m84\u{1b}[0m\u{1b}[32m,\u{1b}[0m\n\u{1b}[32m>\u{1b}[0m\u{1b}[32m    \u{1b}[0m\u{1b}[32m2\u{1b}[0m\u{1b}[1;48;5;22;32m4\u{1b}[0m\u{1b}[32m8,\u{1b}[0m\n"

+    );

+}

diff --git a/rustc_deps/vendor/pretty_assertions/src/lib.rs b/rustc_deps/vendor/pretty_assertions/src/lib.rs
new file mode 100644
index 0000000..a248299
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/src/lib.rs
@@ -0,0 +1,185 @@
+//! # Pretty Assertions

+//!

+//! When writing tests in Rust, you'll probably use `assert_eq!(a, b)` _a lot_.

+//!

+//! If such a test fails, it will present all the details of `a` and `b`. 

+//! But you have to spot the differences yourself, which is not always straightforward,

+//! like here:

+//!

+//! ![standard assertion](https://raw.githubusercontent.com/colin-kiegel/rust-pretty-assertions/1a7feb17e1dfbeabfac91b0d5a9cb78dfb1bc065/examples/standard_assertion.png)

+//!

+//! Wouldn't that task be _much_ easier with a colorful diff?

+//!

+//! ![pretty assertion](https://raw.githubusercontent.com/colin-kiegel/rust-pretty-assertions/1a7feb17e1dfbeabfac91b0d5a9cb78dfb1bc065/examples/pretty_assertion.png)

+//!

+//! Yep — and you only need **one line of code** to make it happen:

+//!

+//! ```rust,ignore

+//! #[macro_use] extern crate pretty_assertions;

+//! ```

+//!

+//! <details>

+//! <summary>Show the example behind the screenshots above.</summary>

+//!

+//! ```rust,ignore

+//! // 1. add the `pretty_assertions` dependency to `Cargo.toml`.

+//! // 2. insert this line at the top of your crate root or integration test

+//! #[macro_use] extern crate pretty_assertions;

+//!

+//! fn main() {

+//!     #[derive(Debug, PartialEq)]

+//!     struct Foo {

+//!         lorem: &'static str,

+//!         ipsum: u32,

+//!         dolor: Result<String, String>,

+//!     }

+//!

+//!     let x = Some(Foo { lorem: "Hello World!", ipsum: 42, dolor: Ok("hey".to_string())});

+//!     let y = Some(Foo { lorem: "Hello Wrold!", ipsum: 42, dolor: Ok("hey ho!".to_string())});

+//!

+//!     assert_eq!(x, y);

+//! }

+//! ```

+//! </details>

+//!

+//! ## Tip

+//!

+//! Specify it as [`[dev-dependencies]`](http://doc.crates.io/specifying-dependencies.html#development-dependencies)

+//! and it will only be used for compiling tests, examples, and benchmarks.

+//! This way the compile time of `cargo build` won't be affected!

+//!

+//! In your crate root, also add `#[cfg(test)]` to the crate import, like this:

+//!

+//! ```rust,ignore

+//! #[cfg(test)] // <-- not needed in examples + integration tests

+//! #[macro_use]

+//! extern crate pretty_assertions;

+//! ```

+//!

+//! ## Note

+//!

+//! * Each example and integration test also needs `#[macro_use] extern crate

+//!   pretty_assertions`, if you want colorful diffs there.

+//! * The replacement is only effective in your own crate, not in other libraries

+//!   you include.

+//! * `assert_ne` is also switched to multi-line presentation, but does _not_ show

+//!   a diff.

+

+extern crate difference;

+extern crate ansi_term;

+mod format_changeset;

+

+use std::fmt::{self, Debug, Display};

+use difference::Changeset;

+

+use format_changeset::format_changeset;

+pub use ansi_term::Style;

+

+#[doc(hidden)]

+pub struct Comparison(Changeset);

+

+impl Comparison {

+    pub fn new<TLeft: Debug, TRight: Debug>(left: &TLeft, right: &TRight) -> Comparison {

+        let left_dbg = format!("{:#?}", *left);

+        let right_dbg = format!("{:#?}", *right);

+        let changeset = Changeset::new(&left_dbg, &right_dbg, "\n");

+

+        Comparison(changeset)

+    }

+}

+

+impl Display for Comparison {

+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

+        format_changeset(f, &self.0)

+    }

+}

+

+#[macro_export]

+macro_rules! assert_eq {

+    ($left:expr , $right:expr,) => ({

+        assert_eq!($left, $right)

+    });

+    ($left:expr , $right:expr) => ({

+        match (&($left), &($right)) {

+            (left_val, right_val) => {

+                if !(*left_val == *right_val) {

+                    panic!("assertion failed: `(left == right)`\

+                          \n\

+                          \n{}\

+                          \n",

+                           $crate::Comparison::new(left_val, right_val))

+                }

+            }

+        }

+    });

+    ($left:expr , $right:expr, $($arg:tt)*) => ({

+        match (&($left), &($right)) {

+            (left_val, right_val) => {

+                if !(*left_val == *right_val) {

+                    panic!("assertion failed: `(left == right)`: {}\

+                          \n\

+                          \n{}\

+                          \n",

+                           format_args!($($arg)*),

+                           $crate::Comparison::new(left_val, right_val))

+                }

+            }

+        }

+    });

+}

+

+#[macro_export]

+#[doc(hidden)]

+macro_rules! __assert_ne {

+    ($left:expr, $right:expr, $maybe_semicolon:expr, $($arg:tt)+) => ({

+        match (&($left), &($right)) {

+            (left_val, right_val) => {

+                if *left_val == *right_val {

+                  let left_dbg = format!("{:?}", *left_val);

+                  let right_dbg = format!("{:?}", *right_val);

+                  if left_dbg != right_dbg {

+

+                      panic!("assertion failed: `(left != right)`{}{}\

+                            \n\

+                            \n{}\

+                            \n{}: According to the `PartialEq` implementation, both of the values \

+                              are partially equivalent, even if the `Debug` outputs differ.\

+                            \n\

+                            \n",

+                             $maybe_semicolon,

+                             format_args!($($arg)+),

+                             $crate::Comparison::new(left_val, right_val),

+                             $crate::Style::new()

+                                 .bold()

+                                 .underline()

+                                 .paint("Note"))

+                  }

+

+                  panic!("assertion failed: `(left != right)`{}{}\

+                        \n\

+                        \n{}:\

+                        \n{:#?}\

+                        \n\

+                        \n",

+                         $maybe_semicolon,

+                         format_args!($($arg)+),

+                         $crate::Style::new().bold().paint("Both sides"),

+                         left_val)

+                }

+            }

+        }

+    });

+}

+

+#[macro_export]

+macro_rules! assert_ne {

+    ($left:expr, $right:expr) => ({

+        __assert_ne!($left, $right, "", "");

+    });

+    ($left:expr, $right:expr,) => ({

+        __assert_ne!($left, $right, "", "");

+    });

+    ($left:expr, $right:expr, $($arg:tt)+) => ({

+        __assert_ne!($left, $right, ": ", $($arg)+);

+    });

+}

diff --git a/rustc_deps/vendor/pretty_assertions/tests/assert_eq.rs b/rustc_deps/vendor/pretty_assertions/tests/assert_eq.rs
new file mode 100644
index 0000000..11b4e3b
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/tests/assert_eq.rs
@@ -0,0 +1,195 @@
+#[macro_use]

+extern crate pretty_assertions;

+extern crate difference;

+

+#[test]

+#[should_panic(expected = r#"assertion failed: `(left == right)`

+

+Diff < left / right > :

+ Some(

+     Foo {

+<        lorem: "Hello World!",

+>        lorem: "Hello Wrold!",

+         ipsum: 42,

+         dolor: Ok(

+<            "hey"

+>            "hey ho!"

+         )

+     }

+ )

+

+"#)]

+fn assert_eq() {

+

+    #[derive(Debug, PartialEq)]

+    struct Foo {

+        lorem: &'static str,

+        ipsum: u32,

+        dolor: Result<String, String>,

+    }

+

+    let x = Some(Foo {

+        lorem: "Hello World!",

+        ipsum: 42,

+        dolor: Ok("hey".to_string()),

+    });

+    let y = Some(Foo {

+        lorem: "Hello Wrold!",

+        ipsum: 42,

+        dolor: Ok("hey ho!".to_string()),

+    });

+

+    assert_eq!(x, y);

+}

+

+#[test]

+#[should_panic(expected = r#"assertion failed: `(left == right)`: custom panic message

+

+Diff < left / right > :

+ Some(

+     Foo {

+<        lorem: "Hello World!",

+>        lorem: "Hello Wrold!",

+         ipsum: 42,

+         dolor: Ok(

+<            "hey"

+>            "hey ho!"

+         )

+     }

+ )

+

+"#)]

+fn assert_eq_custom() {

+

+    #[derive(Debug, PartialEq)]

+    struct Foo {

+        lorem: &'static str,

+        ipsum: u32,

+        dolor: Result<String, String>,

+    }

+

+    let x = Some(Foo {

+        lorem: "Hello World!",

+        ipsum: 42,

+        dolor: Ok("hey".to_string()),

+    });

+    let y = Some(Foo {

+        lorem: "Hello Wrold!",

+        ipsum: 42,

+        dolor: Ok("hey ho!".to_string()),

+    });

+

+    assert_eq!(x, y, "custom panic message");

+}

+

+#[test]

+fn assert_eq_with_comparable_types() {

+    let s0: &'static str = "foo";

+    let s1: String = "foo".to_string();

+    assert_eq!(s0, s1);

+}

+

+#[test]

+#[should_panic(expected = r#"assertion failed: `(left == right)`

+

+Diff < left / right > :

+ [

+<    0,

+<    0,

+<    0,

+<    128,

+<    10,

+<    191,

+<    5,

+>    84,

+>    248,

+>    45,

+     64

+ ]

+

+"#)]

+fn issue12() {

+    let left = vec![0, 0, 0, 128, 10, 191, 5, 64];

+    let right = vec![84, 248, 45, 64];

+    assert_eq!(left, right);

+}

+

+#[test]

+#[should_panic(expected = r#"assertion failed: `(left == right)`

+

+Diff < left / right > :

+ Some(

+     Foo {

+<        lorem: "Hello World!",

+>        lorem: "Hello Wrold!",

+         ipsum: 42,

+         dolor: Ok(

+<            "hey"

+>            "hey ho!"

+         )

+     }

+ )

+

+"#)]

+fn assert_eq_trailing_comma() {

+

+    #[derive(Debug, PartialEq)]

+    struct Foo {

+        lorem: &'static str,

+        ipsum: u32,

+        dolor: Result<String, String>,

+    }

+

+    let x = Some(Foo {

+        lorem: "Hello World!",

+        ipsum: 42,

+        dolor: Ok("hey".to_string()),

+    });

+    let y = Some(Foo {

+        lorem: "Hello Wrold!",

+        ipsum: 42,

+        dolor: Ok("hey ho!".to_string()),

+    });

+

+    assert_eq!(x, y,);

+}

+

+#[test]

+#[should_panic(expected = r#"assertion failed: `(left == right)`: custom panic message

+

+Diff < left / right > :

+ Some(

+     Foo {

+<        lorem: "Hello World!",

+>        lorem: "Hello Wrold!",

+         ipsum: 42,

+         dolor: Ok(

+<            "hey"

+>            "hey ho!"

+         )

+     }

+ )

+

+"#)]

+fn assert_eq_custom_trailing_comma() {

+

+    #[derive(Debug, PartialEq)]

+    struct Foo {

+        lorem: &'static str,

+        ipsum: u32,

+        dolor: Result<String, String>,

+    }

+

+    let x = Some(Foo {

+        lorem: "Hello World!",

+        ipsum: 42,

+        dolor: Ok("hey".to_string()),

+    });

+    let y = Some(Foo {

+        lorem: "Hello Wrold!",

+        ipsum: 42,

+        dolor: Ok("hey ho!".to_string()),

+    });

+

+    assert_eq!(x, y, "custom panic message",);

+}

diff --git a/rustc_deps/vendor/pretty_assertions/tests/assert_ne.rs b/rustc_deps/vendor/pretty_assertions/tests/assert_ne.rs
new file mode 100644
index 0000000..5b4fc99
--- /dev/null
+++ b/rustc_deps/vendor/pretty_assertions/tests/assert_ne.rs
@@ -0,0 +1,175 @@
+#[macro_use]

+extern crate pretty_assertions;

+

+#[test]

+#[should_panic(expected = r#"assertion failed: `(left != right)`

+

+Both sides:

+Some(

+    Foo {

+        lorem: "Hello World!",

+        ipsum: 42,

+        dolor: Ok(

+            "hey"

+        )

+    }

+)

+

+"#)]

+fn assert_ne() {

+

+    #[derive(Debug, PartialEq)]

+    struct Foo {

+        lorem: &'static str,

+        ipsum: u32,

+        dolor: Result<String, String>,

+    }

+

+    let x = Some(Foo {

+        lorem: "Hello World!",

+        ipsum: 42,

+        dolor: Ok("hey".to_string()),

+    });

+

+    assert_ne!(x, x);

+}

+

+#[test]

+#[should_panic(expected = r#"assertion failed: `(left != right)`: custom panic message

+

+Both sides:

+Some(

+    Foo {

+        lorem: "Hello World!",

+        ipsum: 42,

+        dolor: Ok(

+            "hey"

+        )

+    }

+)

+

+"#)]

+fn assert_ne_custom() {

+

+    #[derive(Debug, PartialEq)]

+    struct Foo {

+        lorem: &'static str,

+        ipsum: u32,

+        dolor: Result<String, String>,

+    }

+

+    let x = Some(Foo {

+        lorem: "Hello World!",

+        ipsum: 42,

+        dolor: Ok("hey".to_string()),

+    });

+

+    assert_ne!(x, x, "custom panic message");

+}

+

+#[test]

+#[should_panic]

+fn assert_ne_non_empty_return() {

+    fn not_zero(x: u32) -> u32 {

+        assert_ne!(x, 0);

+        x

+    };

+    not_zero(0);

+}

+

+#[test]

+#[should_panic(expected = r#"assertion failed: `(left != right)`

+

+Diff < left / right > :

+<-0.0

+>0.0

+

+Note: According to the `PartialEq` implementation, both of the values are partially equivalent, even if the `Debug` outputs differ.

+

+"#)]

+fn assert_ne_partial() {

+    // Workaround for https://github.com/rust-lang/rust/issues/47619

+    // can be removed, when we require rust 1.25 or higher

+    struct Foo(f32);

+

+    use ::std::fmt;

+    impl fmt::Debug for Foo {

+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {

+            write!(f, "{:.1?}", self.0)

+        }

+    }

+

+    impl PartialEq for Foo {

+        fn eq(&self, other: &Self) -> bool {

+            self.0 == other.0

+        }

+    }

+

+    assert_ne!(Foo(-0.0), Foo(0.0));

+}

+

+#[test]

+#[should_panic(expected = r#"assertion failed: `(left != right)`

+

+Both sides:

+Some(

+    Foo {

+        lorem: "Hello World!",

+        ipsum: 42,

+        dolor: Ok(

+            "hey"

+        )

+    }

+)

+

+"#)]

+fn assert_ne_trailing_comma() {

+

+    #[derive(Debug, PartialEq)]

+    struct Foo {

+        lorem: &'static str,

+        ipsum: u32,

+        dolor: Result<String, String>,

+    }

+

+    let x = Some(Foo {

+        lorem: "Hello World!",

+        ipsum: 42,

+        dolor: Ok("hey".to_string()),

+    });

+

+    assert_ne!(x, x,);

+}

+

+#[test]

+#[should_panic(expected = r#"assertion failed: `(left != right)`: custom panic message

+

+Both sides:

+Some(

+    Foo {

+        lorem: "Hello World!",

+        ipsum: 42,

+        dolor: Ok(

+            "hey"

+        )

+    }

+)

+

+"#)]

+fn assert_ne_custom_trailing_comma() {

+

+    #[derive(Debug, PartialEq)]

+    struct Foo {

+        lorem: &'static str,

+        ipsum: u32,

+        dolor: Result<String, String>,

+    }

+

+    let x = Some(Foo {

+        lorem: "Hello World!",

+        ipsum: 42,

+        dolor: Ok("hey".to_string()),

+    });

+

+    assert_ne!(x, x, "custom panic message",);

+}