[rust] Update structopt to 0.2.14

Change-Id: Ib9ac151af87064d245391f586d1d1080b92a0224
diff --git a/rustc_deps/Cargo.lock b/rustc_deps/Cargo.lock
index c52b687..2066a40 100644
--- a/rustc_deps/Cargo.lock
+++ b/rustc_deps/Cargo.lock
@@ -483,7 +483,7 @@
  "serde_json 1.0.33 (registry+https://github.com/rust-lang/crates.io-index)",
  "slab 0.4.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "smallvec 0.6.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "structopt 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "structopt 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
  "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
  "tempfile 3.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "time 0.1.40 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -1467,18 +1467,19 @@
 
 [[package]]
 name = "structopt"
-version = "0.2.12"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
  "clap 2.32.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "structopt-derive 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)",
+ "structopt-derive 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
 [[package]]
 name = "structopt-derive"
-version = "0.2.12"
+version = "0.2.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 dependencies = [
+ "heck 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "proc-macro2 0.4.24 (registry+https://github.com/rust-lang/crates.io-index)",
  "quote 0.6.10 (registry+https://github.com/rust-lang/crates.io-index)",
  "syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2070,8 +2071,8 @@
 "checksum stb_truetype 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "48fa7d3136d8645909de1f7c7eb5416cc43057a75ace08fc39ae736bc9da8af1"
 "checksum string 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "00caf261d6f90f588f8450b8e1230fa0d5be49ee6140fdfbcb55335aff350970"
 "checksum strsim 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "bb4f380125926a99e52bc279241539c018323fab05ad6368b56f93d9369ff550"
-"checksum structopt 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)" = "d77af7242f18c40fd19cb270985930f239ee1646cfb482050bbae9da1d18743b"
-"checksum structopt-derive 0.2.12 (registry+https://github.com/rust-lang/crates.io-index)" = "17ff01fe96de9d16e7372ae5f19dd7ece2c703b51043c3db9ea27f9e393ea311"
+"checksum structopt 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)" = "670ad348dc73012fcf78c71f06f9d942232cdd4c859d4b6975e27836c3efc0c3"
+"checksum structopt-derive 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)" = "ef98172b1a00b0bec738508d3726540edcbd186d50dfd326f2b1febbb3559f04"
 "checksum syn 0.15.23 (registry+https://github.com/rust-lang/crates.io-index)" = "9545a6a093a3f0bd59adb472700acc08cad3776f860f16a897dfce8c88721cbc"
 "checksum synstructure 0.10.1 (registry+https://github.com/rust-lang/crates.io-index)" = "73687139bf99285483c96ac0add482c3776528beac1d97d444f6e91f203a2015"
 "checksum syntect 2.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "dc8a6f0db88d4afc340522c20d260411e746b2225b257c6b238a75de9d7cec78"
diff --git a/rustc_deps/Cargo.toml b/rustc_deps/Cargo.toml
index a2f48dc..4e63644 100644
--- a/rustc_deps/Cargo.toml
+++ b/rustc_deps/Cargo.toml
@@ -54,7 +54,7 @@
 serde_json = "1"
 slab = "0.4"
 smallvec = "0.6"
-structopt = "0.2.4"
+structopt = "0.2.14"
 tempfile = "3"
 time = "0.1"
 timebomb = "0.1.2"
diff --git a/rustc_deps/vendor/structopt-derive/.cargo-checksum.json b/rustc_deps/vendor/structopt-derive/.cargo-checksum.json
index 0216324..0417cb5 100644
--- a/rustc_deps/vendor/structopt-derive/.cargo-checksum.json
+++ b/rustc_deps/vendor/structopt-derive/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"Cargo.toml":"a57fac7a8443a6cbee138749304186a1f3a75b1805c51ac722b2a599f2f20263","LICENSE-APACHE":"c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4","LICENSE-MIT":"8a44e151af3f22ffe260a07253995300e3600614fba131f0315aa7d9d5c88470","src/attrs.rs":"0aca8db2880fa49567aa60fdffa103aa5a5386643a084ef4ad0a7fb285e750b7","src/lib.rs":"f1f70cec6242c9caae3601b40c92d87b2256154ba00214de3626417d4c608df2"},"package":"17ff01fe96de9d16e7372ae5f19dd7ece2c703b51043c3db9ea27f9e393ea311"}
\ No newline at end of file
+{"files":{"Cargo.toml":"4e5632b97299778a2c2cbbf4f53e477432d2e822cb95f3f35fba012d144db0be","LICENSE-APACHE":"c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4","LICENSE-MIT":"8a44e151af3f22ffe260a07253995300e3600614fba131f0315aa7d9d5c88470","src/attrs.rs":"db0b2069ed33c171f035616434a0ebb81d9ee0cfdba0cd3242050d98b1b5559e","src/lib.rs":"915cf32edb2ecad30c2674d00ae973711db780ccc8bd2367fcd3f231b8023d5d"},"package":"ef98172b1a00b0bec738508d3726540edcbd186d50dfd326f2b1febbb3559f04"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/structopt-derive/Cargo.toml b/rustc_deps/vendor/structopt-derive/Cargo.toml
index e1f3d16..b5ce613 100644
--- a/rustc_deps/vendor/structopt-derive/Cargo.toml
+++ b/rustc_deps/vendor/structopt-derive/Cargo.toml
@@ -12,7 +12,7 @@
 
 [package]
 name = "structopt-derive"
-version = "0.2.12"
+version = "0.2.14"
 authors = ["Guillaume Pinot <texitoi@texitoi.eu>"]
 description = "Parse command line argument by defining a struct, derive crate."
 documentation = "https://docs.rs/structopt-derive"
@@ -23,6 +23,9 @@
 
 [lib]
 proc-macro = true
+[dependencies.heck]
+version = "^0.3.0"
+
 [dependencies.proc-macro2]
 version = "0.4"
 
diff --git a/rustc_deps/vendor/structopt-derive/src/attrs.rs b/rustc_deps/vendor/structopt-derive/src/attrs.rs
index e2bf070..ea5ba38 100644
--- a/rustc_deps/vendor/structopt-derive/src/attrs.rs
+++ b/rustc_deps/vendor/structopt-derive/src/attrs.rs
@@ -6,6 +6,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use heck::{CamelCase, KebabCase, MixedCase, ShoutySnakeCase, SnakeCase};
 use proc_macro2::{Span, TokenStream};
 use std::{env, mem};
 use syn::Type::Path;
@@ -27,6 +28,8 @@
 #[derive(Debug)]
 pub struct Attrs {
     name: String,
+    cased_name: String,
+    casing: CasingStyle,
     methods: Vec<Method>,
     parser: (Parser, TokenStream),
     has_custom_parser: bool,
@@ -45,6 +48,24 @@
     TryFromOsStr,
     FromOccurrences,
 }
+
+/// Defines the casing for the attributes long representation.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum CasingStyle {
+    /// Indicate word boundaries with uppercase letter, excluding the first word.
+    Camel,
+    /// Keep all letters lowercase and indicate word boundaries with hyphens.
+    Kebab,
+    /// Indicate word boundaries with uppercase letter, including the first word.
+    Pascal,
+    /// Keep all letters uppercase and indicate word boundaries with underscores.
+    ScreamingSnake,
+    /// Keep all letters lowercase and indicate word boundaries with underscores.
+    Snake,
+    /// Use the original attribute name defined in the code.
+    Verbatim,
+}
+
 impl ::std::str::FromStr for Parser {
     type Err = String;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -59,10 +80,47 @@
     }
 }
 
+impl CasingStyle {
+    fn translate(&self, input: &str) -> String {
+        match *self {
+            CasingStyle::Pascal => input.to_camel_case(),
+            CasingStyle::Kebab => input.to_kebab_case(),
+            CasingStyle::Camel => input.to_mixed_case(),
+            CasingStyle::ScreamingSnake => input.to_shouty_snake_case(),
+            CasingStyle::Snake => input.to_snake_case(),
+            CasingStyle::Verbatim => String::from(input),
+        }
+    }
+}
+
+impl ::std::str::FromStr for CasingStyle {
+    type Err = String;
+
+    fn from_str(name: &str) -> Result<Self, Self::Err> {
+        let name = name.to_camel_case().to_lowercase();
+
+        let case = match name.as_ref() {
+            "camel" | "camelcase" => CasingStyle::Camel,
+            "kebab" | "kebabcase" => CasingStyle::Kebab,
+            "pascal" | "pascalcase" => CasingStyle::Pascal,
+            "screamingsnake" | "screamingsnakecase" => CasingStyle::ScreamingSnake,
+            "snake" | "snakecase" => CasingStyle::Snake,
+            "verbatim" | "verbatimcase" => CasingStyle::Verbatim,
+            _ => return Err(format!("unsupported casing: {}", name)),
+        };
+
+        Ok(case)
+    }
+}
+
 impl Attrs {
-    fn new(name: String) -> Attrs {
+    fn new(name: String, casing: CasingStyle) -> Attrs {
+        let cased_name = casing.translate(&name);
+
         Attrs {
-            name: name,
+            name,
+            cased_name,
+            casing,
             methods: vec![],
             parser: (Parser::TryFromStr, quote!(::std::str::FromStr::from_str)),
             has_custom_parser: false,
@@ -75,7 +133,10 @@
                 let methods = mem::replace(&mut self.methods, vec![]);
                 self.methods = methods.into_iter().filter(|m| m.name != name).collect();
             }
-            ("name", new_name) => self.name = new_name.into(),
+            ("name", new_name) => {
+                self.name = new_name.into();
+                self.cased_name = self.casing.translate(new_name);
+            }
             (name, arg) => self.methods.push(Method {
                 name: name.to_string(),
                 args: quote!(#arg),
@@ -87,27 +148,42 @@
         use Meta::*;
         use NestedMeta::*;
 
-        let iter = attrs
+        let structopt_attrs = attrs
             .iter()
             .filter_map(|attr| {
                 let path = &attr.path;
-                match quote!(#path).to_string() == "structopt" {
-                    true => Some(
+                match quote!(#path).to_string().as_ref() {
+                    "structopt" => Some(
                         attr.interpret_meta()
                             .expect(&format!("invalid structopt syntax: {}", quote!(attr))),
                     ),
-                    false => None,
+                    _ => None,
                 }
-            }).flat_map(|m| match m {
+            })
+            .flat_map(|m| match m {
                 List(l) => l.nested,
                 tokens => panic!("unsupported syntax: {}", quote!(#tokens).to_string()),
-            }).map(|m| match m {
+            })
+            .map(|m| match m {
                 Meta(m) => m,
                 ref tokens => panic!("unsupported syntax: {}", quote!(#tokens).to_string()),
             });
-        for attr in iter {
+
+        for attr in structopt_attrs {
             match attr {
                 NameValue(MetaNameValue {
+                    ref ident,
+                    lit: Str(ref value),
+                    ..
+                }) if ident == "rename_all" => {
+                    self.casing = {
+                        let input = value.value();
+                        ::std::str::FromStr::from_str(&input)
+                            .unwrap_or_else(|error| panic!("{}", error))
+                    };
+                    self.cased_name = self.casing.translate(&self.name);
+                }
+                NameValue(MetaNameValue {
                     ident,
                     lit: Str(value),
                     ..
@@ -120,9 +196,7 @@
                     ref ident,
                     ref nested,
                     ..
-                })
-                    if ident == "parse" =>
-                {
+                }) if ident == "parse" => {
                     if nested.len() != 1 {
                         panic!("parse must have exactly one argument");
                     }
@@ -158,9 +232,7 @@
                     ref ident,
                     ref nested,
                     ..
-                })
-                    if ident == "raw" =>
-                {
+                }) if ident == "raw" => {
                     for method in nested {
                         match *method {
                             Meta(NameValue(MetaNameValue {
@@ -178,6 +250,14 @@
                 Word(ref w) if w == "flatten" => {
                     self.set_kind(Kind::FlattenStruct);
                 }
+                Word(ref w) if w == "long" => {
+                    let cased_name = &self.cased_name.clone();
+                    self.push_str_method("long", cased_name);
+                }
+                Word(ref w) if w == "short" => {
+                    let cased_named = &self.cased_name.clone();
+                    self.push_str_method("short", cased_named);
+                }
                 ref i @ List(..) | ref i @ Word(..) => panic!("unsupported option: {}", quote!(#i)),
             }
         }
@@ -194,7 +274,7 @@
         })
     }
     fn push_doc_comment(&mut self, attrs: &[Attribute], name: &str) {
-        let doc_comments: Vec<_> = attrs
+        let doc_comments = attrs
             .iter()
             .filter_map(|attr| {
                 let path = &attr.path;
@@ -202,7 +282,8 @@
                     true => attr.interpret_meta(),
                     false => None,
                 }
-            }).filter_map(|attr| {
+            })
+            .filter_map(|attr| {
                 use Lit::*;
                 use Meta::*;
                 if let NameValue(MetaNameValue {
@@ -228,23 +309,54 @@
                 } else {
                     None
                 }
-            }).collect();
+            })
+            .collect::<Vec<_>>();
+
         if doc_comments.is_empty() {
             return;
         }
-        let arg = doc_comments
+
+        let merged_lines = doc_comments
             .join(" ")
             .split('\n')
-            .map(|l| l.trim().to_string())
+            .map(str::trim)
+            .map(str::to_string)
             .collect::<Vec<_>>()
             .join("\n");
-        self.methods.push(Method {
-            name: name.to_string(),
-            args: quote!(#arg),
-        });
+
+        let expected_doc_comment_split = if let Some(content) = doc_comments.get(1) {
+            (doc_comments.len() > 2) && (content == &"\n\n")
+        } else {
+            false
+        };
+
+        if expected_doc_comment_split {
+            let long_name = String::from("long_") + name;
+
+            self.methods.push(Method {
+                name: long_name,
+                args: quote!(#merged_lines),
+            });
+
+            let short_arg = doc_comments
+                .first()
+                .map(String::as_ref)
+                .map(str::trim)
+                .unwrap_or("");
+
+            self.methods.push(Method {
+                name: name.to_string(),
+                args: quote!(#short_arg),
+            });
+        } else {
+            self.methods.push(Method {
+                name: name.to_string(),
+                args: quote!(#merged_lines),
+            });
+        }
     }
-    pub fn from_struct(attrs: &[Attribute], name: String) -> Attrs {
-        let mut res = Self::new(name);
+    pub fn from_struct(attrs: &[Attribute], name: String, argument_casing: CasingStyle) -> Attrs {
+        let mut res = Self::new(name, argument_casing);
         let attrs_with_env = [
             ("version", "CARGO_PKG_VERSION"),
             ("about", "CARGO_PKG_DESCRIPTION"),
@@ -289,9 +401,9 @@
             Ty::Other
         }
     }
-    pub fn from_field(field: &syn::Field) -> Attrs {
+    pub fn from_field(field: &syn::Field, struct_casing: CasingStyle) -> Attrs {
         let name = field.ident.as_ref().unwrap().to_string();
-        let mut res = Self::new(name);
+        let mut res = Self::new(name, struct_casing);
         res.push_doc_comment(&field.attrs, "help");
         res.push_attrs(&field.attrs);
 
@@ -363,8 +475,8 @@
         });
         quote!( #(#methods)* )
     }
-    pub fn name(&self) -> &str {
-        &self.name
+    pub fn cased_name(&self) -> &str {
+        &self.cased_name
     }
     pub fn parser(&self) -> &(Parser, TokenStream) {
         &self.parser
@@ -372,4 +484,7 @@
     pub fn kind(&self) -> Kind {
         self.kind
     }
+    pub fn casing(&self) -> CasingStyle {
+        self.casing
+    }
 }
diff --git a/rustc_deps/vendor/structopt-derive/src/lib.rs b/rustc_deps/vendor/structopt-derive/src/lib.rs
index f9e9f9b..0f73ef6 100644
--- a/rustc_deps/vendor/structopt-derive/src/lib.rs
+++ b/rustc_deps/vendor/structopt-derive/src/lib.rs
@@ -14,16 +14,30 @@
 extern crate syn;
 #[macro_use]
 extern crate quote;
+extern crate heck;
 extern crate proc_macro2;
 
 mod attrs;
 
-use attrs::{Attrs, Kind, Parser, Ty};
+use attrs::{Attrs, CasingStyle, Kind, Parser, Ty};
 use proc_macro2::{Span, TokenStream};
 use syn::punctuated::Punctuated;
 use syn::token::Comma;
 use syn::*;
 
+/// Default casing style for generated arguments.
+const DEFAULT_CASING: CasingStyle = CasingStyle::Verbatim;
+
+/// Output for the gen_xxx() methods were we need more than a simple stream of tokens.
+///
+/// The output of a generation method is not only the stream of new tokens but also the attribute
+/// information of the current element. These attribute information may contain valuable information
+/// for any kind of child arguments.
+struct GenOutput {
+    tokens: TokenStream,
+    attrs: Attrs,
+}
+
 /// Generates the `StructOpt` impl.
 #[proc_macro_derive(StructOpt, attributes(structopt))]
 pub fn structopt(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
@@ -45,9 +59,7 @@
             arguments:
                 PathArguments::AngleBracketed(AngleBracketedGenericArguments { ref args, .. }),
             ..
-        }
-            if args.len() == 1 =>
-        {
+        } if args.len() == 1 => {
             if let GenericArgument::Type(ref ty) = args[0] {
                 Some(ty)
             } else {
@@ -60,11 +72,15 @@
 
 /// Generate a block of code to add arguments/subcommands corresponding to
 /// the `fields` to an app.
-fn gen_augmentation(fields: &Punctuated<Field, Comma>, app_var: &Ident) -> TokenStream {
+fn gen_augmentation(
+    fields: &Punctuated<Field, Comma>,
+    app_var: &Ident,
+    parent_attribute: &Attrs,
+) -> TokenStream {
     let subcmds: Vec<_> = fields
         .iter()
         .filter_map(|field| {
-            let attrs = Attrs::from_field(&field);
+            let attrs = Attrs::from_field(&field, parent_attribute.casing());
             if let Kind::Subcommand(ty) = attrs.kind() {
                 let subcmd_type = match (ty, sub_type(&field.ty)) {
                     (Ty::Option, Some(sub_type)) => sub_type,
@@ -80,14 +96,15 @@
                     }
                 };
 
-                Some(quote!{
+                Some(quote! {
                     let #app_var = <#subcmd_type>::augment_clap( #app_var );
                     #required
                 })
             } else {
                 None
             }
-        }).collect();
+        })
+        .collect();
 
     assert!(
         subcmds.len() <= 1,
@@ -95,7 +112,7 @@
     );
 
     let args = fields.iter().filter_map(|field| {
-        let attrs = Attrs::from_field(field);
+        let attrs = Attrs::from_field(field, parent_attribute.casing());
         match attrs.kind() {
             Kind::Subcommand(_) => None,
             Kind::FlattenStruct => {
@@ -142,8 +159,9 @@
                     }
                 };
                 let methods = attrs.methods();
-                let name = attrs.name();
-                Some(quote!{
+                let name = attrs.cased_name();
+
+                Some(quote! {
                     let #app_var = #app_var.arg(
                         ::structopt::clap::Arg::with_name(#name)
                             #modifier
@@ -161,9 +179,9 @@
     }}
 }
 
-fn gen_constructor(fields: &Punctuated<Field, Comma>) -> TokenStream {
+fn gen_constructor(fields: &Punctuated<Field, Comma>, parent_attribute: &Attrs) -> TokenStream {
     let fields = fields.iter().map(|field| {
-        let attrs = Attrs::from_field(field);
+        let attrs = Attrs::from_field(field, parent_attribute.casing());
         let field_name = field.ident.as_ref().unwrap();
         match attrs.kind() {
             Kind::Subcommand(ty) => {
@@ -197,7 +215,7 @@
                 };
 
                 let occurences = attrs.parser().0 == Parser::FromOccurrences;
-                let name = attrs.name();
+                let name = attrs.cased_name();
                 let field_value = match ty {
                     Ty::Bool => quote!(matches.is_present(#name)),
                     Ty::Option => quote! {
@@ -230,8 +248,12 @@
     }}
 }
 
-fn gen_from_clap(struct_name: &Ident, fields: &Punctuated<Field, Comma>) -> TokenStream {
-    let field_block = gen_constructor(fields);
+fn gen_from_clap(
+    struct_name: &Ident,
+    fields: &Punctuated<Field, Comma>,
+    parent_attribute: &Attrs,
+) -> TokenStream {
+    let field_block = gen_constructor(fields, parent_attribute);
 
     quote! {
         fn from_clap(matches: &::structopt::clap::ArgMatches) -> Self {
@@ -240,29 +262,42 @@
     }
 }
 
-fn gen_clap(attrs: &[Attribute]) -> TokenStream {
+fn gen_clap(attrs: &[Attribute]) -> GenOutput {
     let name = std::env::var("CARGO_PKG_NAME")
         .ok()
         .unwrap_or_else(String::default);
-    let attrs = Attrs::from_struct(attrs, name);
-    let name = attrs.name();
-    let methods = attrs.methods();
-    quote!(::structopt::clap::App::new(#name)#methods)
+
+    let attrs = Attrs::from_struct(attrs, name, DEFAULT_CASING);
+    let tokens = {
+        let name = attrs.cased_name();
+        let methods = attrs.methods();
+
+        quote!(::structopt::clap::App::new(#name)#methods)
+    };
+
+    GenOutput { tokens, attrs }
 }
 
-fn gen_clap_struct(struct_attrs: &[Attribute]) -> TokenStream {
-    let gen = gen_clap(struct_attrs);
-    quote! {
+fn gen_clap_struct(struct_attrs: &[Attribute]) -> GenOutput {
+    let initial_clap_app_gen = gen_clap(struct_attrs);
+    let clap_tokens = initial_clap_app_gen.tokens;
+
+    let augmented_tokens = quote! {
         fn clap<'a, 'b>() -> ::structopt::clap::App<'a, 'b> {
-            let app = #gen;
+            let app = #clap_tokens;
             Self::augment_clap(app)
         }
+    };
+
+    GenOutput {
+        tokens: augmented_tokens,
+        attrs: initial_clap_app_gen.attrs,
     }
 }
 
-fn gen_augment_clap(fields: &Punctuated<Field, Comma>) -> TokenStream {
+fn gen_augment_clap(fields: &Punctuated<Field, Comma>, parent_attribute: &Attrs) -> TokenStream {
     let app_var = Ident::new("app", Span::call_site());
-    let augmentation = gen_augmentation(fields, &app_var);
+    let augmentation = gen_augmentation(fields, &app_var, parent_attribute);
     quote! {
         pub fn augment_clap<'a, 'b>(
             #app_var: ::structopt::clap::App<'a, 'b>
@@ -272,26 +307,36 @@
     }
 }
 
-fn gen_clap_enum(enum_attrs: &[Attribute]) -> TokenStream {
-    let gen = gen_clap(enum_attrs);
-    quote! {
+fn gen_clap_enum(enum_attrs: &[Attribute]) -> GenOutput {
+    let initial_clap_app_gen = gen_clap(enum_attrs);
+    let clap_tokens = initial_clap_app_gen.tokens;
+
+    let tokens = quote! {
         fn clap<'a, 'b>() -> ::structopt::clap::App<'a, 'b> {
-            let app = #gen
+            let app = #clap_tokens
                 .setting(::structopt::clap::AppSettings::SubcommandRequiredElseHelp);
             Self::augment_clap(app)
         }
+    };
+
+    GenOutput {
+        tokens,
+        attrs: initial_clap_app_gen.attrs,
     }
 }
 
-fn gen_augment_clap_enum(variants: &Punctuated<Variant, Comma>) -> TokenStream {
+fn gen_augment_clap_enum(
+    variants: &Punctuated<Variant, Comma>,
+    parent_attribute: &Attrs,
+) -> TokenStream {
     use syn::Fields::*;
 
     let subcommands = variants.iter().map(|variant| {
         let name = variant.ident.to_string();
-        let attrs = Attrs::from_struct(&variant.attrs, name);
+        let attrs = Attrs::from_struct(&variant.attrs, name, parent_attribute.casing());
         let app_var = Ident::new("subcommand", Span::call_site());
         let arg_block = match variant.fields {
-            Named(ref fields) => gen_augmentation(&fields.named, &app_var),
+            Named(ref fields) => gen_augmentation(&fields.named, &app_var, &attrs),
             Unit => quote!( #app_var ),
             Unnamed(FieldsUnnamed { ref unnamed, .. }) if unnamed.len() == 1 => {
                 let ty = &unnamed[0];
@@ -311,7 +356,7 @@
             Unnamed(..) => panic!("{}: tuple enum are not supported", variant.ident),
         };
 
-        let name = attrs.name();
+        let name = attrs.cased_name();
         let from_attrs = attrs.methods();
         quote! {
             .subcommand({
@@ -340,15 +385,23 @@
     }
 }
 
-fn gen_from_subcommand(name: &Ident, variants: &Punctuated<Variant, Comma>) -> TokenStream {
+fn gen_from_subcommand(
+    name: &Ident,
+    variants: &Punctuated<Variant, Comma>,
+    parent_attribute: &Attrs,
+) -> TokenStream {
     use syn::Fields::*;
 
     let match_arms = variants.iter().map(|variant| {
-        let attrs = Attrs::from_struct(&variant.attrs, variant.ident.to_string());
-        let sub_name = attrs.name();
+        let attrs = Attrs::from_struct(
+            &variant.attrs,
+            variant.ident.to_string(),
+            parent_attribute.casing(),
+        );
+        let sub_name = attrs.cased_name();
         let variant_name = &variant.ident;
         let constructor_block = match variant.fields {
-            Named(ref fields) => gen_constructor(&fields.named),
+            Named(ref fields) => gen_constructor(&fields.named, &attrs),
             Unit => quote!(),
             Unnamed(ref fields) if fields.unnamed.len() == 1 => {
                 let ty = &fields.unnamed[0];
@@ -380,14 +433,15 @@
     fields: &Punctuated<Field, Comma>,
     attrs: &[Attribute],
 ) -> TokenStream {
-    let clap = gen_clap_struct(attrs);
-    let augment_clap = gen_augment_clap(fields);
-    let from_clap = gen_from_clap(name, fields);
+    let basic_clap_app_gen = gen_clap_struct(attrs);
+    let augment_clap = gen_augment_clap(fields, &basic_clap_app_gen.attrs);
+    let from_clap = gen_from_clap(name, fields, &basic_clap_app_gen.attrs);
 
+    let clap_tokens = basic_clap_app_gen.tokens;
     quote! {
         #[allow(unused_variables)]
         impl ::structopt::StructOpt for #name {
-            #clap
+            #clap_tokens
             #from_clap
         }
 
@@ -405,14 +459,16 @@
     variants: &Punctuated<Variant, Comma>,
     attrs: &[Attribute],
 ) -> TokenStream {
-    let clap = gen_clap_enum(attrs);
-    let augment_clap = gen_augment_clap_enum(variants);
-    let from_clap = gen_from_clap_enum(name);
-    let from_subcommand = gen_from_subcommand(name, variants);
+    let basic_clap_app_gen = gen_clap_enum(attrs);
 
+    let augment_clap = gen_augment_clap_enum(variants, &basic_clap_app_gen.attrs);
+    let from_clap = gen_from_clap_enum(name);
+    let from_subcommand = gen_from_subcommand(name, variants, &basic_clap_app_gen.attrs);
+
+    let clap_tokens = basic_clap_app_gen.tokens;
     quote! {
         impl ::structopt::StructOpt for #name {
-            #clap
+            #clap_tokens
             #from_clap
         }
 
diff --git a/rustc_deps/vendor/structopt/.cargo-checksum.json b/rustc_deps/vendor/structopt/.cargo-checksum.json
index 0b1f8c3..4a517a1 100644
--- a/rustc_deps/vendor/structopt/.cargo-checksum.json
+++ b/rustc_deps/vendor/structopt/.cargo-checksum.json
@@ -1 +1 @@
-{"files":{"CHANGELOG.md":"f8deb513abc8ddff858fa5b21d0627b20d6403ea0ae3f53233280fa82a39d0c6","Cargo.toml":"40952678f1d2f5c54da3b6ab4eee5e6a1db9c7fb6e8dc618efc551b800635496","LICENSE-APACHE":"c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4","LICENSE-MIT":"8a44e151af3f22ffe260a07253995300e3600614fba131f0315aa7d9d5c88470","README.md":"1e3b11be51d8926271dc5bebe387e77774880fc178d1fad3bec22dd7611348eb","examples/at_least_two.rs":"f9558c31779e765a86441af13e79e0c224b716f11f7ee52a1dd460314354698b","examples/basic.rs":"a9fdf6afdc580f9f588f769db02b669d222a628143ac4cee7b63d80f493f5564","examples/deny_missing_docs.rs":"d48a1e8529071c8592d1ebd7d7c52487e7e07a6d21c6e254ba9de4ddbcc397b3","examples/enum_in_args.rs":"d785f3224d8a0c18e5e0cb40d1abf58c51fd706989ed48946dfd3ba2aedb20f7","examples/enum_tuple.rs":"d95ce7261d784c9668854d2eccb2962f974a1bcf66e1b6c2dbaa7c94e2f5f7ed","examples/example.rs":"18fa26bbbfd94304d7abfdb17462874e514055034dc6cd8282f48f77f2bf01b2","examples/flatten.rs":"e9fb9ac14b52f0de68bf9f09a0b54bc962d20d6e80f07294b7e68eda58a6c485","examples/git.rs":"7cb9f2215c6e7e40fce7534223b1b584fa853fd7f62afa04a49dfaa2ccbfe14c","examples/group.rs":"e2b4737accc5acc8d44e0312323520bfec4827538b3427690da57daaae443470","examples/keyvalue.rs":"605847b8871ddc44fb57786d2e3e13db87477383b888a4267c6d036660d17456","examples/no_version.rs":"1d0aaaf5f67cee3dd7b85e30b935969b2925d7163160234994e7a532b44f1aac","examples/raw_attributes.rs":"5d08637cbe13d8d65f50075e9fb73ed5c0040c55f4d83ee95650628b8635e967","examples/simple_group.rs":"aa65830001504c362cd03c25e2146feee4c086a53e8b2f27ee4e41019c973d24","examples/subcommand_aliases.rs":"aa0a3df4534ef3a0037d41064debb04430eb7034537638a895c707de6c34bc52","src/lib.rs":"56425b4b0dc342b666d51c258bf9ad945c4cb716d6de9e630e0c5d979a2d632f","tests/arguments.rs":"34bb72ccc06fb36f6ce6cfc1fc2a2efad8aaee996f93249327401d8d7ca95a9c","tests/author_version_about.rs":"3f6b37257b5b426c69214dc69e5d0aca0558bc7b8d7d5196d5a7f5cda987161a","tests/custom-string-parsers.rs":"f007b10f25e53982dfca7b9512eff22b9c350f492bd0a4109e2e6e0035fd0574","tests/deny-warnings.rs":"badb0130e936c1ca5a459d96d4969515164c2dff9d9a34faf642fdb653eb73fc","tests/doc-comments-help.rs":"c16a698629a33b4a52461694c5463e7d2811a3b71fde02f803910712964fde74","tests/flags.rs":"eed9f721bafb3875bbed6b024e5f05a00c042e7c789d4e631a966d33d3d018e9","tests/flatten.rs":"7cc2416711c608ae7ea4c73b59b55dcec2e1e1549e7ba526ffbb78fb95d526b4","tests/nested-subcommands.rs":"dc4dae72a82bd359270dd28a6f56048eed9656237208cbcddd39e4cec8b55d49","tests/options.rs":"d5ad598707843b639c7d51e51fcfd92c9d2e0684e8e19024cf488d6fdc80122f","tests/privacy.rs":"5ec0c0654d8330b42bf5abf90c209cc5e88e1a4a2a81d15ae37ee889f9915aca","tests/raw_attributes.rs":"0cb4b260d5c471942f534b6ac5a78c3734345046e032d1a8006b6d18bc621ff6","tests/subcommands.rs":"7ac6acbad780e92655adbb088784afa48f51a46b0c48e05b8f607126d772b82b"},"package":"d77af7242f18c40fd19cb270985930f239ee1646cfb482050bbae9da1d18743b"}
\ No newline at end of file
+{"files":{"CHANGELOG.md":"4f793a46ca6644d2e65b5604011821a6c312a7cb2f90e8fb6f6937f80b626197","Cargo.toml":"ebc42682898fb825e3c224ca65466d871bdc574eade7c882cd3d446850cda0fb","LICENSE-APACHE":"c71d239df91726fc519c6eb72d318ec65820627232b2f796219e87dcf35d0ab4","LICENSE-MIT":"8a44e151af3f22ffe260a07253995300e3600614fba131f0315aa7d9d5c88470","README.md":"1e3b11be51d8926271dc5bebe387e77774880fc178d1fad3bec22dd7611348eb","examples/at_least_two.rs":"f9558c31779e765a86441af13e79e0c224b716f11f7ee52a1dd460314354698b","examples/basic.rs":"a334afac47636288e4abaa22ecf6f925edb48a56301e610214094ec4d4fb9691","examples/deny_missing_docs.rs":"d48a1e8529071c8592d1ebd7d7c52487e7e07a6d21c6e254ba9de4ddbcc397b3","examples/doc_comments.rs":"6447a161db9d3cfd4461ae4621fb6c8d5ae661cc84a2fbc2e3430e2e5bae75cd","examples/enum_in_args.rs":"49fc4765c3cb81c49709745c643ad7c068f954dcf2f0a1f3cf53e822aeb700ce","examples/enum_tuple.rs":"d95ce7261d784c9668854d2eccb2962f974a1bcf66e1b6c2dbaa7c94e2f5f7ed","examples/example.rs":"9527da82620e022c3b9ed531e364b14245b9a8aa29007d7cf64e55b7d90d23f8","examples/flatten.rs":"e9fb9ac14b52f0de68bf9f09a0b54bc962d20d6e80f07294b7e68eda58a6c485","examples/git.rs":"7cb9f2215c6e7e40fce7534223b1b584fa853fd7f62afa04a49dfaa2ccbfe14c","examples/group.rs":"e2b4737accc5acc8d44e0312323520bfec4827538b3427690da57daaae443470","examples/keyvalue.rs":"605847b8871ddc44fb57786d2e3e13db87477383b888a4267c6d036660d17456","examples/no_version.rs":"1d0aaaf5f67cee3dd7b85e30b935969b2925d7163160234994e7a532b44f1aac","examples/raw_attributes.rs":"98817c1a344f34bae7e50233e368979b8b5c207ac0d1efa03d5edb2a0bb81538","examples/rename_all.rs":"f75ac0449eccc6af66dafa74efee7ac49a79b6d6d060f5c7a8d866af027f0855","examples/simple_group.rs":"aa65830001504c362cd03c25e2146feee4c086a53e8b2f27ee4e41019c973d24","examples/subcommand_aliases.rs":"aa0a3df4534ef3a0037d41064debb04430eb7034537638a895c707de6c34bc52","src/lib.rs":"6914b37abe3d440643ca6f43e272883dc1a72e24dc5049813afd96d02ce940c2","tests/argument_naming.rs":"41ac667c64aa2991be059ccf5286fe13934840f545170b2ff272d18db8fadc84","tests/arguments.rs":"bc8417f8fb6ca63230ae4d473ada273755cb1c6fc555a88c1bb72a7f051648d0","tests/author_version_about.rs":"3f6b37257b5b426c69214dc69e5d0aca0558bc7b8d7d5196d5a7f5cda987161a","tests/custom-string-parsers.rs":"c624b289c20bbcd86830d21c10fc8bc5d3c0d99f0acfaad9d0892d9739031cbb","tests/deny-warnings.rs":"badb0130e936c1ca5a459d96d4969515164c2dff9d9a34faf642fdb653eb73fc","tests/doc-comments-help.rs":"51289f087643adee9adcf798f457bd32b957e3cb00eb252de83dc50a352beed5","tests/flags.rs":"52dc51eccc227017fb7179af47360b25589823ff23bf4640d9e76f61c377a1b0","tests/flatten.rs":"741d4b76c76bf9acc398ec842b7d8ab07bb6e61be89e8bf6cbe9a1909c7c6d01","tests/nested-subcommands.rs":"dc4dae72a82bd359270dd28a6f56048eed9656237208cbcddd39e4cec8b55d49","tests/options.rs":"9fc7f9901e6ff23c580ceed5dda1ef524b9c4a6286b26674c40e2f560a80543e","tests/privacy.rs":"5ec0c0654d8330b42bf5abf90c209cc5e88e1a4a2a81d15ae37ee889f9915aca","tests/raw_attributes.rs":"26ae3a74d28b265136d3a79a516b532d36d3844ce9e7f008a2a81d65d83dbe18","tests/subcommands.rs":"7ac6acbad780e92655adbb088784afa48f51a46b0c48e05b8f607126d772b82b"},"package":"670ad348dc73012fcf78c71f06f9d942232cdd4c859d4b6975e27836c3efc0c3"}
\ No newline at end of file
diff --git a/rustc_deps/vendor/structopt/CHANGELOG.md b/rustc_deps/vendor/structopt/CHANGELOG.md
index 30f358f..0613886 100644
--- a/rustc_deps/vendor/structopt/CHANGELOG.md
+++ b/rustc_deps/vendor/structopt/CHANGELOG.md
@@ -1,3 +1,11 @@
+# v0.2.14 (2018-12-10)
+
+* Introduce smarter parsing of doc comments by [@0ndorio](https://github.com/0ndorio)
+
+# v0.2.13 (2018-11-01)
+
+* Automatic naming of fields and subcommands by [@0ndorio](https://github.com/0ndorio)
+
 # v0.2.12 (2018-10-11)
 
 * Fix minimal clap version by [@TeXitoi](https://github.com/TeXitoi)
diff --git a/rustc_deps/vendor/structopt/Cargo.toml b/rustc_deps/vendor/structopt/Cargo.toml
index 5b934b0..204f3a0 100644
--- a/rustc_deps/vendor/structopt/Cargo.toml
+++ b/rustc_deps/vendor/structopt/Cargo.toml
@@ -12,7 +12,7 @@
 
 [package]
 name = "structopt"
-version = "0.2.12"
+version = "0.2.14"
 authors = ["Guillaume Pinot <texitoi@texitoi.eu>", "others"]
 description = "Parse command line argument by defining a struct."
 documentation = "https://docs.rs/structopt"
@@ -26,7 +26,7 @@
 default-features = false
 
 [dependencies.structopt-derive]
-version = "0.2.12"
+version = "0.2.14"
 
 [features]
 color = ["clap/color"]
diff --git a/rustc_deps/vendor/structopt/examples/basic.rs b/rustc_deps/vendor/structopt/examples/basic.rs
index b05d5ad..8d322d6 100644
--- a/rustc_deps/vendor/structopt/examples/basic.rs
+++ b/rustc_deps/vendor/structopt/examples/basic.rs
@@ -27,20 +27,22 @@
     #[structopt(short = "v", long = "verbose", parse(from_occurrences))]
     verbose: u8,
 
+    // The standalone parameters `short`and `long` automatically name the
+    // arguments based on the field name (defaults to kebab-case).
     /// Set speed
-    #[structopt(short = "s", long = "speed", default_value = "42")]
+    #[structopt(short, long, default_value = "42")]
     speed: f64,
 
     /// Output file
-    #[structopt(short = "o", long = "output", parse(from_os_str))]
+    #[structopt(short, long, parse(from_os_str))]
     output: PathBuf,
 
     /// Number of cars
-    #[structopt(short = "c", long = "nb-cars")]
+    #[structopt(short = "c", long)]
     nb_cars: Option<i32>,
 
     /// admin_level to consider
-    #[structopt(short = "l", long = "level")]
+    #[structopt(short, long)]
     level: Vec<String>,
 
     /// Files to process
diff --git a/rustc_deps/vendor/structopt/examples/doc_comments.rs b/rustc_deps/vendor/structopt/examples/doc_comments.rs
new file mode 100644
index 0000000..32028df
--- /dev/null
+++ b/rustc_deps/vendor/structopt/examples/doc_comments.rs
@@ -0,0 +1,86 @@
+// Copyright 2018 Guillaume Pinot (@TeXitoi) <texitoi@texitoi.eu>
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate structopt;
+
+use std::path::PathBuf;
+use structopt::StructOpt;
+
+/// A basic example for the usage of doc comments as replacement
+/// of the arguments `help`, `long_help`, `about` and `long_about`.
+#[derive(StructOpt, Debug)]
+#[structopt(name = "basic")]
+struct Opt {
+    /// Just use doc comments to replace `help`, `long_help`,
+    /// `about` or `long_about` input.
+    #[structopt(short = "f", long = "first-flag")]
+    first_flag: bool,
+
+    /// Split between `help` and `long_help`.
+    ///
+    /// In the previous case structopt is going to present
+    /// the whole comment both as text for the `help` and the
+    /// `long_help` argument.
+    ///
+    /// But if the doc comment is formatted like this example
+    /// -- with an empty second line splitting the heading and
+    /// the rest of the comment -- only the first line is used
+    /// as `help` argument. The `long_help` argument will still
+    /// contain the whole comment.
+    ///
+    /// ## Attention
+    ///
+    /// Any formatting next to empty lines that could be used
+    /// inside a doc comment is currently not preserved. If
+    /// lists or other well formatted content is required it is
+    /// necessary to use the related structopt argument with a
+    /// raw string as shown on the `third_flag` description.
+    #[structopt(short = "s", long = "second-flag")]
+    second_flag: bool,
+
+    #[structopt(
+        short = "t",
+        long = "third-flag",
+        long_help = r"This is a raw string.
+
+It can be used to pass well formatted content (e.g. lists or source
+code) in the description:
+
+ - first example list entry
+ - second example list entry
+ "
+    )]
+    third_flag: bool,
+
+    #[structopt(subcommand)]
+    sub_command: SubCommand,
+}
+
+#[derive(StructOpt, Debug)]
+#[structopt()]
+enum SubCommand {
+    /// The same rules described previously for flags. Are
+    /// also true for in regards of sub-commands.
+    #[structopt(name = "first")]
+    First,
+
+    /// Applicable for both `about` an `help`.
+    ///
+    /// The formatting rules described in the comment of the
+    /// `second_flag` also apply to the description of
+    /// sub-commands which is normally given through the `about`
+    /// and `long_about` arguments.
+    #[structopt(name = "second")]
+    Second,
+}
+
+fn main() {
+    let opt = Opt::from_args();
+    println!("{:?}", opt);
+}
diff --git a/rustc_deps/vendor/structopt/examples/enum_in_args.rs b/rustc_deps/vendor/structopt/examples/enum_in_args.rs
index d744fe0..482d563 100644
--- a/rustc_deps/vendor/structopt/examples/enum_in_args.rs
+++ b/rustc_deps/vendor/structopt/examples/enum_in_args.rs
@@ -17,12 +17,7 @@
 #[derive(StructOpt, Debug)]
 struct Opt {
     /// Important argument.
-    #[structopt(
-        raw(
-            possible_values = "&Baz::variants()",
-            case_insensitive = "true"
-        )
-    )]
+    #[structopt(raw(possible_values = "&Baz::variants()", case_insensitive = "true"))]
     i: Baz,
 }
 
diff --git a/rustc_deps/vendor/structopt/examples/example.rs b/rustc_deps/vendor/structopt/examples/example.rs
index d5a3aa4..c188794 100644
--- a/rustc_deps/vendor/structopt/examples/example.rs
+++ b/rustc_deps/vendor/structopt/examples/example.rs
@@ -19,12 +19,7 @@
     debug: bool,
 
     /// An argument of type float, with a default value.
-    #[structopt(
-        short = "s",
-        long = "speed",
-        help = "Set speed",
-        default_value = "42"
-    )]
+    #[structopt(short = "s", long = "speed", help = "Set speed", default_value = "42")]
     speed: f64,
 
     /// Needed parameter, the first on the command line.
diff --git a/rustc_deps/vendor/structopt/examples/raw_attributes.rs b/rustc_deps/vendor/structopt/examples/raw_attributes.rs
index 0eca949..e2a3503 100644
--- a/rustc_deps/vendor/structopt/examples/raw_attributes.rs
+++ b/rustc_deps/vendor/structopt/examples/raw_attributes.rs
@@ -14,20 +14,16 @@
 
 /// An example of raw attributes
 #[derive(StructOpt, Debug)]
-#[structopt(
-    raw(global_settings = "&[AppSettings::ColoredHelp, AppSettings::VersionlessSubcommands]")
-)]
+#[structopt(raw(
+    global_settings = "&[AppSettings::ColoredHelp, AppSettings::VersionlessSubcommands]"
+))]
 struct Opt {
     /// Output file
     #[structopt(short = "o", long = "output")]
     output: String,
 
     /// admin_level to consider
-    #[structopt(
-        short = "l",
-        long = "level",
-        raw(aliases = r#"&["set-level", "lvl"]"#)
-    )]
+    #[structopt(short = "l", long = "level", raw(aliases = r#"&["set-level", "lvl"]"#))]
     level: Vec<String>,
 
     /// Files to process
diff --git a/rustc_deps/vendor/structopt/examples/rename_all.rs b/rustc_deps/vendor/structopt/examples/rename_all.rs
new file mode 100644
index 0000000..36ac12e
--- /dev/null
+++ b/rustc_deps/vendor/structopt/examples/rename_all.rs
@@ -0,0 +1,76 @@
+//! Example on how the `rename_all` parameter works.
+//!
+//! `rename_all` can be used to override the casing style used during argument
+//! generation. By default the `verbatim-case` style will be used but there are a wide
+//! variety of other styles available.
+//!
+//! ## Supported styles overview:
+//!
+//! - **Camel Case**: Indicate word boundaries with uppercase letter, excluding
+//!                   the first word.
+//! - **Kebab Case**: Keep all letters lowercase and indicate word boundaries
+//!                   with hyphens.
+//! - **Pascal Case**: Indicate word boundaries with uppercase letter,
+//!                    including the first word.
+//! - **Screaming Snake Case**: Keep all letters uppercase and indicate word
+//!                             boundaries with underscores.
+//! - **Snake Case**: Keep all letters lowercase and indicate word boundaries
+//!                   with underscores.
+//! - **Verbatim**: Use the original attribute name defined in the code.
+#[macro_use]
+extern crate structopt;
+
+use structopt::StructOpt;
+
+#[derive(StructOpt, Debug)]
+#[structopt(name = "rename_all", rename_all = "screaming_snake_case")]
+enum Opt {
+    // This subcommand will be named `FIRST_COMMAND`. As the command doesn't
+    // override the initial casing style, ...
+    /// A screaming loud first command. Only use if necessary.
+    FirstCommand {
+        // this flag will be available as `--FOO` and `-F`.
+        /// This flag will even scream louder.
+        #[structopt(long, short)]
+        foo: bool,
+    },
+
+    // As we override the casing style for this variant the related subcommand
+    // will be named `SecondCommand`.
+    /// Not nearly as loud as the first command.
+    #[structopt(rename_all = "pascal_case")]
+    SecondCommand {
+        // We can also override it again on a single field.
+        /// Nice quiet flag. No one is annoyed.
+        #[structopt(rename_all = "snake_case", long)]
+        bar_option: bool,
+
+        // Renaming will not be propagated into subcommand flagged enums. If
+        // a non default casing style is required it must be defined on the
+        // enum itself.
+        #[structopt(subcommand)]
+        cmds: Subcommands,
+
+        // or flattened structs.
+        #[structopt(flatten)]
+        options: BonusOptions,
+    },
+}
+
+#[derive(StructOpt, Debug)]
+enum Subcommands {
+    // This one will be available as `FirstSubcommand`.
+    FirstSubcommand,
+}
+
+#[derive(StructOpt, Debug)]
+struct BonusOptions {
+    // And this one will be available as `baz_option`.
+    #[structopt(long)]
+    baz_option: bool,
+}
+
+fn main() {
+    let opt = Opt::from_args();
+    println!("{:?}", opt);
+}
diff --git a/rustc_deps/vendor/structopt/src/lib.rs b/rustc_deps/vendor/structopt/src/lib.rs
index 3d153a8..fc22f01 100644
--- a/rustc_deps/vendor/structopt/src/lib.rs
+++ b/rustc_deps/vendor/structopt/src/lib.rs
@@ -96,9 +96,9 @@
 //! Then, each field of the struct not marked as a subcommand corresponds
 //! to a `clap::Arg`. As with the struct attributes, every method of
 //! `clap::Arg` in the form of `fn function_name(self, &str)` can be used
-//! through specifying it as an attribute.
-//! The `name` attribute can be used to customize the
-//! `Arg::with_name()` call (defaults to the field name).
+//! through specifying it as an attribute. The `name` attribute can be used
+//! to customize the `Arg::with_name()` call (defaults to the field name in
+//! kebab-case).
 //! For functions that do not take a `&str` as argument, the attribute can be
 //! wrapped in `raw()`, e. g. `raw(aliases = r#"&["alias"]"#, next_line_help = "true")`.
 //!
@@ -135,6 +135,68 @@
 //! # }
 //! ```
 //!
+//! ## Specifying argument types
+//!
+//! There are three types of arguments that can be supplied to each
+//! (sub-)command:
+//!
+//!  - short (e.g. `-h`),
+//!  - long (e.g. `--help`)
+//!  - and positional.
+//!
+//! Like clap, structopt defaults to creating positional arguments.
+//!
+//! If you want to generate a long argument you can specify either
+//! `long = $NAME`, or just `long` to get a long flag generated using
+//! the field name.  The generated casing style can be modified using
+//! the `rename_all` attribute. See the `rename_all` example for more.
+//!
+//! For short arguments, `short` will use the first letter of the
+//! field name by default, but just like the long option it's also
+//! possible to use a custom letter through `short = $LETTER`.
+//!
+//! If an argument is renamed using `name = $NAME` any following call to
+//! `short` or `long` will use the new name.
+//!
+//! ```
+//! #[macro_use]
+//! extern crate structopt;
+//!
+//! use structopt::StructOpt;
+//!
+//! #[derive(StructOpt)]
+//! #[structopt(rename_all = "kebab-case")]
+//! struct Opt {
+//!     /// This option can be specified with something like `--foo-option
+//!     /// value` or `--foo-option=value`
+//!     #[structopt(long)]
+//!     foo_option: String,
+//!
+//!     /// This option can be specified with something like `-b value` (but
+//!     /// not `--bar-option value`).
+//!     #[structopt(short)]
+//!     bar_option: String,
+//!
+//!     /// This option can be specified either `--baz value` or `-z value`.
+//!     #[structopt(short = "z", long = "baz")]
+//!     baz_option: String,
+//!
+//!     /// This option can be specified either by `--custom value` or
+//!     /// `-c value`.
+//!     #[structopt(name = "custom", long, short)]
+//!     custom_option: String,
+//!
+//!     /// This option is positional, meaning it is the first unadorned string
+//!     /// you provide (multiple others could follow).
+//!     my_positional: String,
+//! }
+//!
+//! # fn main() {
+//! # Opt::from_clap(&Opt::clap().get_matches_from(
+//! #    &["test", "--foo-option", "", "-b", "", "--baz", "", "--custom", "", "positional"]));
+//! # }
+//! ```
+//!
 //! ## Help messages
 //!
 //! Help messages for the whole binary or individual arguments can be
@@ -155,6 +217,43 @@
 //! # fn main() {}
 //! ```
 //!
+//! If it is necessary or wanted to provide a more complex help message then the
+//! previous used ones, it could still be a good idea to distinguish between the
+//! actual help message a short summary. In this case `about` and `help` should
+//! only contain the short and concise form while the two additional arguments
+//! `long_about` and `long_help` can be used to store a descriptive and more in
+//! depth message.
+//!
+//! If both - the short and the long version of the argument - are present,
+//! the user can later chose between the short summary (`-h`) and the long
+//! descriptive version (`--help`) of the help message. Also in case
+//! of subcommands the short help message will automatically be used for the
+//! command description inside the parents help message and the long version
+//! as command description if help is requested on the actual subcommand.
+//!
+//! This feature can also be used with doc comments instead of arguments through
+//! proper comment formatting. To be activated it requires, that the first line
+//! of the comment is separated from the rest of the comment through an empty line.
+//! In this case the first line is used as summary and the whole comment represents
+//! the long descriptive message.
+//!
+//! ```
+//! # #[macro_use] extern crate structopt;
+//! #[derive(StructOpt)]
+//! #[structopt(name = "foo")]
+//! /// The help message that will be displayed when passing `--help`.
+//! struct Foo {
+//!   #[structopt(short = "b")]
+//!   /// Only this summary is visible when passing `-h`.
+//!   ///
+//!   /// But the whole comment will be displayed when passing `--help`.
+//!   /// This could be quite useful to provide further hints are usage
+//!   /// examples.
+//!   bar: String
+//! }
+//! # fn main() {}
+//! ```
+//!
 //! ## Subcommands
 //!
 //! Some applications, especially large ones, split their functionality
diff --git a/rustc_deps/vendor/structopt/tests/argument_naming.rs b/rustc_deps/vendor/structopt/tests/argument_naming.rs
new file mode 100644
index 0000000..d37a9e3
--- /dev/null
+++ b/rustc_deps/vendor/structopt/tests/argument_naming.rs
@@ -0,0 +1,314 @@
+#[macro_use]
+extern crate structopt;
+
+use structopt::StructOpt;
+
+#[test]
+fn test_single_word_enum_variant_is_default_renamed_into_verbatim_case() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    enum Opt {
+        Command { foo: u32 },
+    }
+
+    assert_eq!(
+        Opt::Command { foo: 0 },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "Command", "0"]))
+    );
+}
+
+#[test]
+fn test_multi_word_enum_variant_is_renamed() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    enum Opt {
+        FirstCommand { foo: u32 },
+    }
+
+    assert_eq!(
+        Opt::FirstCommand { foo: 0 },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "FirstCommand", "0"]))
+    );
+}
+
+#[test]
+fn test_standalone_long_generates_verbatim_case() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    #[allow(non_snake_case)]
+    struct Opt {
+        #[structopt(long)]
+        FOO_OPTION: bool,
+    }
+
+    assert_eq!(
+        Opt { FOO_OPTION: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "--FOO_OPTION"]))
+    );
+}
+
+#[test]
+fn test_custom_long_overwrites_default_name() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    struct Opt {
+        #[structopt(long = "foo")]
+        foo_option: bool,
+    }
+
+    assert_eq!(
+        Opt { foo_option: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "--foo"]))
+    );
+}
+
+#[test]
+fn test_standalone_long_uses_previous_defined_custom_name() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    struct Opt {
+        #[structopt(name = "foo", long)]
+        foo_option: bool,
+    }
+
+    assert_eq!(
+        Opt { foo_option: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "--foo"]))
+    );
+}
+
+#[test]
+fn test_standalone_long_ignores_afterwards_defined_custom_name() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    struct Opt {
+        #[structopt(long, name = "foo")]
+        foo_option: bool,
+    }
+
+    assert_eq!(
+        Opt { foo_option: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "--foo_option"]))
+    );
+}
+
+#[test]
+fn test_standalone_short_generates_verbatim_case() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    #[allow(non_snake_case)]
+    struct Opt {
+        #[structopt(short)]
+        FOO_OPTION: bool,
+    }
+
+    assert_eq!(
+        Opt { FOO_OPTION: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "-F"]))
+    );
+}
+
+#[test]
+fn test_custom_short_overwrites_default_name() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    struct Opt {
+        #[structopt(short = "o")]
+        foo_option: bool,
+    }
+
+    assert_eq!(
+        Opt { foo_option: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "-o"]))
+    );
+}
+
+#[test]
+fn test_standalone_short_uses_previous_defined_custom_name() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    struct Opt {
+        #[structopt(name = "option", short)]
+        foo_option: bool,
+    }
+
+    assert_eq!(
+        Opt { foo_option: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "-o"]))
+    );
+}
+
+#[test]
+fn test_standalone_short_ignores_afterwards_defined_custom_name() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    struct Opt {
+        #[structopt(short, name = "option")]
+        foo_option: bool,
+    }
+
+    assert_eq!(
+        Opt { foo_option: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "-f"]))
+    );
+}
+
+#[test]
+fn test_standalone_long_uses_previous_defined_casing() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    struct Opt {
+        #[structopt(rename_all = "screaming_snake", long)]
+        foo_option: bool,
+    }
+
+    assert_eq!(
+        Opt { foo_option: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "--FOO_OPTION"]))
+    );
+}
+
+#[test]
+fn test_standalone_short_uses_previous_defined_casing() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    struct Opt {
+        #[structopt(rename_all = "screaming_snake", short)]
+        foo_option: bool,
+    }
+
+    assert_eq!(
+        Opt { foo_option: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "-F"]))
+    );
+}
+
+#[test]
+fn test_standalone_long_works_with_verbatim_casing() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    #[allow(non_snake_case)]
+    struct Opt {
+        #[structopt(rename_all = "verbatim", long)]
+        _fOO_oPtiON: bool,
+    }
+
+    assert_eq!(
+        Opt { _fOO_oPtiON: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "--_fOO_oPtiON"]))
+    );
+}
+
+#[test]
+fn test_standalone_short_works_with_verbatim_casing() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    struct Opt {
+        #[structopt(rename_all = "verbatim", short)]
+        _foo: bool,
+    }
+
+    assert_eq!(
+        Opt { _foo: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "-_"]))
+    );
+}
+
+#[test]
+fn test_rename_all_is_propagated_from_struct_to_fields() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    #[structopt(rename_all = "screaming_snake")]
+    struct Opt {
+        #[structopt(long)]
+        foo: bool,
+    }
+
+    assert_eq!(
+        Opt { foo: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "--FOO"]))
+    );
+}
+
+#[test]
+fn test_rename_all_is_not_propagated_from_struct_into_flattened() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    #[structopt(rename_all = "screaming_snake")]
+    struct Opt {
+        #[structopt(flatten)]
+        foo: Foo,
+    }
+
+    #[derive(StructOpt, Debug, PartialEq)]
+    struct Foo {
+        #[structopt(long)]
+        foo: bool,
+    }
+
+    assert_eq!(
+        Opt {
+            foo: Foo { foo: true }
+        },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "--foo"]))
+    );
+}
+
+#[test]
+fn test_rename_all_is_not_propagated_from_struct_into_subcommand() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    #[structopt(rename_all = "screaming_snake")]
+    struct Opt {
+        #[structopt(subcommand)]
+        foo: Foo,
+    }
+
+    #[derive(StructOpt, Debug, PartialEq)]
+    enum Foo {
+        Command {
+            #[structopt(long)]
+            foo: bool,
+        },
+    }
+
+    assert_eq!(
+        Opt {
+            foo: Foo::Command { foo: true }
+        },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "Command", "--foo"]))
+    );
+}
+
+#[test]
+fn test_rename_all_is_propagated_from_enum_to_variants_and_their_fields() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    #[structopt(rename_all = "screaming_snake")]
+    enum Opt {
+        FirstVariant,
+        SecondVariant {
+            #[structopt(long)]
+            foo: bool,
+        },
+    }
+
+    assert_eq!(
+        Opt::FirstVariant,
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "FIRST_VARIANT"]))
+    );
+
+    assert_eq!(
+        Opt::SecondVariant { foo: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "SECOND_VARIANT", "--FOO"]))
+    );
+}
+
+#[test]
+fn test_rename_all_is_propagation_can_be_overridden() {
+    #[derive(StructOpt, Debug, PartialEq)]
+    #[structopt(rename_all = "screaming_snake")]
+    enum Opt {
+        #[structopt(rename_all = "kebab_case")]
+        FirstVariant {
+            #[structopt(long)]
+            foo_option: bool,
+        },
+        SecondVariant {
+            #[structopt(rename_all = "kebab_case", long)]
+            foo_option: bool,
+        },
+    }
+
+    assert_eq!(
+        Opt::FirstVariant { foo_option: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "first-variant", "--foo-option"]))
+    );
+
+    assert_eq!(
+        Opt::SecondVariant { foo_option: true },
+        Opt::from_clap(&Opt::clap().get_matches_from(&["test", "SECOND_VARIANT", "--foo-option"]))
+    );
+}
diff --git a/rustc_deps/vendor/structopt/tests/arguments.rs b/rustc_deps/vendor/structopt/tests/arguments.rs
index 47b57f4..a8a1145 100644
--- a/rustc_deps/vendor/structopt/tests/arguments.rs
+++ b/rustc_deps/vendor/structopt/tests/arguments.rs
@@ -20,11 +20,9 @@
     }
     assert_eq!(Opt { arg: 42 }, Opt::from_iter(&["test", "42"]));
     assert!(Opt::clap().get_matches_from_safe(&["test"]).is_err());
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "42", "24"])
-            .is_err()
-    );
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "42", "24"])
+        .is_err());
 }
 
 #[test]
@@ -35,11 +33,9 @@
     }
     assert_eq!(Opt { arg: Some(42) }, Opt::from_iter(&["test", "42"]));
     assert_eq!(Opt { arg: None }, Opt::from_iter(&["test"]));
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "42", "24"])
-            .is_err()
-    );
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "42", "24"])
+        .is_err());
 }
 
 #[test]
@@ -51,11 +47,9 @@
     }
     assert_eq!(Opt { arg: 24 }, Opt::from_iter(&["test", "24"]));
     assert_eq!(Opt { arg: 42 }, Opt::from_iter(&["test"]));
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "42", "24"])
-            .is_err()
-    );
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "42", "24"])
+        .is_err());
 }
 
 #[test]
@@ -67,11 +61,9 @@
     }
     assert_eq!(Opt { arg: 24 }, Opt::from_iter(&["test", "24"]));
     assert_eq!(Opt { arg: 42 }, Opt::from_iter(&["test"]));
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "42", "24"])
-            .is_err()
-    );
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "42", "24"])
+        .is_err());
 }
 
 #[test]
diff --git a/rustc_deps/vendor/structopt/tests/custom-string-parsers.rs b/rustc_deps/vendor/structopt/tests/custom-string-parsers.rs
index ca41643..97a0064 100644
--- a/rustc_deps/vendor/structopt/tests/custom-string-parsers.rs
+++ b/rustc_deps/vendor/structopt/tests/custom-string-parsers.rs
@@ -178,11 +178,7 @@
     #[structopt(short = "r", parse(from_occurrences))]
     little_unsigned: u8,
 
-    #[structopt(
-        short = "c",
-        long = "custom",
-        parse(from_occurrences = "foo")
-    )]
+    #[structopt(short = "c", long = "custom", parse(from_occurrences = "foo"))]
     custom: Foo,
 }
 
@@ -229,11 +225,9 @@
 
     assert!(Opt::clap().get_matches_from_safe(&["test"]).is_err());
     assert!(Opt::clap().get_matches_from_safe(&["test", "-d"]).is_err());
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "-dfoo"])
-            .is_err()
-    );
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "-dfoo"])
+        .is_err());
     assert_eq!(
         Opt {
             debug: false,
diff --git a/rustc_deps/vendor/structopt/tests/doc-comments-help.rs b/rustc_deps/vendor/structopt/tests/doc-comments-help.rs
index 618fbf7..4f96ac5 100644
--- a/rustc_deps/vendor/structopt/tests/doc-comments-help.rs
+++ b/rustc_deps/vendor/structopt/tests/doc-comments-help.rs
@@ -70,3 +70,79 @@
     println!("{}", output);
     assert!(output.starts_with("lorem-ipsum \nFoo.\n\nBar\n\nUSAGE:"));
 }
+
+#[test]
+fn splits_flag_doc_comment_between_short_and_long() {
+    /// Lorem ipsumclap
+    #[derive(StructOpt, PartialEq, Debug)]
+    #[structopt(name = "lorem-ipsum", about = "Dolor sit amet")]
+    struct LoremIpsum {
+        /// DO NOT PASS A BAR UNDER ANY CIRCUMSTANCES
+        ///
+        /// Or something else
+        #[structopt(long = "foo")]
+        foo: bool,
+    }
+
+    let mut app = LoremIpsum::clap();
+
+    let short_help = {
+        let mut buffer = Vec::new();
+        app.write_help(&mut buffer).ok();
+
+        String::from_utf8(buffer).unwrap()
+    };
+
+    let long_help = {
+        let mut buffer = Vec::new();
+        app.write_long_help(&mut buffer).ok();
+
+        String::from_utf8(buffer).unwrap()
+    };
+
+    assert!(!short_help.contains("Or something else"));
+    assert!(long_help.contains("DO NOT PASS A BAR UNDER ANY CIRCUMSTANCES"));
+    assert!(long_help.contains("Or something else"));
+}
+
+#[test]
+fn splits_subcommand_doc_comment_between_short_and_long() {
+    /// Lorem ipsumclap
+    #[derive(StructOpt, Debug)]
+    #[structopt(name = "lorem-ipsum", about = "Dolor sit amet")]
+    struct LoremIpsum {
+        #[structopt(subcommand)]
+        foo: SubCommand,
+    }
+
+    #[derive(StructOpt, Debug)]
+    pub enum SubCommand {
+        /// DO NOT PASS A BAR UNDER ANY CIRCUMSTANCES
+        ///
+        /// Or something else
+        #[structopt(name = "foo")]
+        Foo {
+            #[structopt(help = "foo")]
+            bars: Vec<String>,
+        },
+    }
+
+    let app = LoremIpsum::clap();
+
+    let short_help = {
+        let mut buffer = Vec::new();
+        app.write_help(&mut buffer).ok();
+
+        String::from_utf8(buffer).unwrap()
+    };
+
+    let long_help = {
+        app.get_matches_from_safe(vec!["test", "foo", "--help"])
+            .expect_err("")
+            .message
+    };
+
+    assert!(!short_help.contains("Or something else"));
+    assert!(long_help.contains("DO NOT PASS A BAR UNDER ANY CIRCUMSTANCES"));
+    assert!(long_help.contains("Or something else"));
+}
diff --git a/rustc_deps/vendor/structopt/tests/flags.rs b/rustc_deps/vendor/structopt/tests/flags.rs
index 9e8aaf4..09c4cd1 100644
--- a/rustc_deps/vendor/structopt/tests/flags.rs
+++ b/rustc_deps/vendor/structopt/tests/flags.rs
@@ -32,21 +32,15 @@
         Opt::from_clap(&Opt::clap().get_matches_from(&["test", "--alice"]))
     );
     assert!(Opt::clap().get_matches_from_safe(&["test", "-i"]).is_err());
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "-a", "foo"])
-            .is_err()
-    );
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "-a", "-a"])
-            .is_err()
-    );
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "-a", "--alice"])
-            .is_err()
-    );
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "-a", "foo"])
+        .is_err());
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "-a", "-a"])
+        .is_err());
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "-a", "--alice"])
+        .is_err());
 }
 
 #[test]
@@ -80,11 +74,9 @@
         Opt::from_clap(&Opt::clap().get_matches_from(&["test", "-aaa", "--bob"]))
     );
     assert!(Opt::clap().get_matches_from_safe(&["test", "-i"]).is_err());
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "-a", "foo"])
-            .is_err()
-    );
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "-a", "foo"])
+        .is_err());
 }
 
 #[test]
diff --git a/rustc_deps/vendor/structopt/tests/flatten.rs b/rustc_deps/vendor/structopt/tests/flatten.rs
index b1e802b..3322209 100644
--- a/rustc_deps/vendor/structopt/tests/flatten.rs
+++ b/rustc_deps/vendor/structopt/tests/flatten.rs
@@ -30,11 +30,9 @@
         Opt::from_iter(&["test", "42"])
     );
     assert!(Opt::clap().get_matches_from_safe(&["test"]).is_err());
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "42", "24"])
-            .is_err()
-    );
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "42", "24"])
+        .is_err());
 }
 
 #[test]
diff --git a/rustc_deps/vendor/structopt/tests/options.rs b/rustc_deps/vendor/structopt/tests/options.rs
index 686113e..447f1cd 100644
--- a/rustc_deps/vendor/structopt/tests/options.rs
+++ b/rustc_deps/vendor/structopt/tests/options.rs
@@ -31,11 +31,9 @@
         Opt::from_clap(&Opt::clap().get_matches_from(&["test", "--arg", "42"]))
     );
     assert!(Opt::clap().get_matches_from_safe(&["test"]).is_err());
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "-a42", "-a24"])
-            .is_err()
-    );
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "-a42", "-a24"])
+        .is_err());
 }
 
 #[test]
@@ -53,11 +51,9 @@
         Opt { arg: None },
         Opt::from_clap(&Opt::clap().get_matches_from(&["test"]))
     );
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "-a42", "-a24"])
-            .is_err()
-    );
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "-a42", "-a24"])
+        .is_err());
 }
 
 #[test]
@@ -75,11 +71,9 @@
         Opt { arg: 42 },
         Opt::from_clap(&Opt::clap().get_matches_from(&["test"]))
     );
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "-a42", "-a24"])
-            .is_err()
-    );
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "-a42", "-a24"])
+        .is_err());
 }
 
 #[test]
@@ -97,11 +91,9 @@
         Opt { arg: 42 },
         Opt::from_clap(&Opt::clap().get_matches_from(&["test"]))
     );
-    assert!(
-        Opt::clap()
-            .get_matches_from_safe(&["test", "-a42", "-a24"])
-            .is_err()
-    );
+    assert!(Opt::clap()
+        .get_matches_from_safe(&["test", "-a42", "-a24"])
+        .is_err());
 }
 
 #[test]
diff --git a/rustc_deps/vendor/structopt/tests/raw_attributes.rs b/rustc_deps/vendor/structopt/tests/raw_attributes.rs
index b10a0d0..807d634 100644
--- a/rustc_deps/vendor/structopt/tests/raw_attributes.rs
+++ b/rustc_deps/vendor/structopt/tests/raw_attributes.rs
@@ -27,11 +27,7 @@
     )]
     x: i32,
 
-    #[structopt(
-        short = "l",
-        long = "level",
-        raw(aliases = r#"&["set-level", "lvl"]"#)
-    )]
+    #[structopt(short = "l", long = "level", raw(aliases = r#"&["set-level", "lvl"]"#))]
     level: String,
 
     #[structopt(long = "values")]