src/lib.rs - platform/external/rust/crates/structopt-derive - Git at Google

 // 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.

 //! This crate is custom derive for `StructOpt`. It should not be used
 //! directly. See [structopt documentation](https://docs.rs/structopt)
 //! for the usage of `#[derive(StructOpt)]`.

 #![allow(clippy::large_enum_variant)]
 // FIXME: remove when and if our MSRV hits 1.42
 #![allow(clippy::match_like_matches_macro)]
 #![forbid(unsafe_code)]

 extern crate proc_macro;

 mod attrs;
 mod doc_comments;
 mod parse;
 mod spanned;
 mod ty;

 use crate::{
     attrs::{Attrs, CasingStyle, Kind, Name, ParserKind},
     spanned::Sp,
     ty::{is_simple_ty, sub_type, subty_if_name, Ty},
 };

 use proc_macro2::{Span, TokenStream};
 use proc_macro_error::{abort, abort_call_site, proc_macro_error, set_dummy};
 use quote::{format_ident, quote, quote_spanned};
 use syn::{punctuated::Punctuated, spanned::Spanned, token::Comma, *};

 /// Default casing style for generated arguments.
 const DEFAULT_CASING: CasingStyle = CasingStyle::Kebab;

 /// Default casing style for environment variables
 const DEFAULT_ENV_CASING: CasingStyle = CasingStyle::ScreamingSnake;

 /// 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))]
 #[proc_macro_error]
 pub fn structopt(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input: DeriveInput = syn::parse(input).unwrap();
     let gen = impl_structopt(&input);
     gen.into()
 }

 /// 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,
     parent_attribute: &Attrs,
 ) -> TokenStream {
     let mut subcmds = fields.iter().filter_map(|field| {
         let attrs = Attrs::from_field(
             field,
             Some(parent_attribute),
             parent_attribute.casing(),
             parent_attribute.env_casing(),
         );
         let kind = attrs.kind();
         if let Kind::Subcommand(ty) = &*kind {
             let subcmd_type = match (**ty, sub_type(&field.ty)) {
                 (Ty::Option, Some(sub_type)) => sub_type,
                 _ => &field.ty,
             };
             let required = if **ty == Ty::Option {
                 quote!()
             } else {
                 quote_spanned! { kind.span()=>
                     let #app_var = #app_var.setting(
                         ::structopt::clap::AppSettings::SubcommandRequiredElseHelp
                     );
                 }
             };

             let span = field.span();
             let ts = quote! {
                 let #app_var = <#subcmd_type as ::structopt::StructOptInternal>::augment_clap(
                     #app_var
                 );
                 #required
             };
             Some((span, ts))
         } else {
             None
         }
     });

     let subcmd = subcmds.next().map(|(_, ts)| ts);
     if let Some((span, _)) = subcmds.next() {
         abort!(
             span,
             "multiple subcommand sets are not allowed, that's the second"
         );
     }

     let args = fields.iter().filter_map(|field| {
         let attrs = Attrs::from_field(
             field,
             Some(parent_attribute),
             parent_attribute.casing(),
             parent_attribute.env_casing(),
         );
         let kind = attrs.kind();
         match &*kind {
             Kind::ExternalSubcommand => abort!(
                 kind.span(),
                 "`external_subcommand` is only allowed on enum variants"
             ),
             Kind::Subcommand(_) | Kind::Skip(_) => None,
             Kind::Flatten => {
                 let ty = &field.ty;
                 Some(quote_spanned! { kind.span()=>
                     let #app_var = <#ty as ::structopt::StructOptInternal>::augment_clap(#app_var);
                     let #app_var = if <#ty as ::structopt::StructOptInternal>::is_subcommand() {
                         #app_var.setting(::structopt::clap::AppSettings::SubcommandRequiredElseHelp)
                     } else {
                         #app_var
                     };
                 })
             }
             Kind::Arg(ty) => {
                 let convert_type = match **ty {
                     Ty::Vec | Ty::Option => sub_type(&field.ty).unwrap_or(&field.ty),
                     Ty::OptionOption | Ty::OptionVec => {
                         sub_type(&field.ty).and_then(sub_type).unwrap_or(&field.ty)
                     }
                     _ => &field.ty,
                 };

                 let occurrences = *attrs.parser().kind == ParserKind::FromOccurrences;
                 let flag = *attrs.parser().kind == ParserKind::FromFlag;

                 let parser = attrs.parser();
                 let func = &parser.func;
                 let validator = match *parser.kind {
                     ParserKind::TryFromStr => quote_spanned! { func.span()=>
                         .validator(|s| {
                             #func(s.as_str())
                             .map(|_: #convert_type| ())
                             .map_err(|e| e.to_string())
                         })
                     },
                     ParserKind::TryFromOsStr => quote_spanned! { func.span()=>
                         .validator_os(|s| #func(&s).map(|_: #convert_type| ()))
                     },
                     _ => quote!(),
                 };

                 let modifier = match **ty {
                     Ty::Bool => quote_spanned! { ty.span()=>
                         .takes_value(false)
                         .multiple(false)
                     },

                     Ty::Option => quote_spanned! { ty.span()=>
                         .takes_value(true)
                         .multiple(false)
                         #validator
                     },

                     Ty::OptionOption => quote_spanned! { ty.span()=>
                             .takes_value(true)
                             .multiple(false)
                             .min_values(0)
                             .max_values(1)
                             #validator
                     },

                     Ty::OptionVec => quote_spanned! { ty.span()=>
                         .takes_value(true)
                         .multiple(true)
                         .min_values(0)
                         #validator
                     },

                     Ty::Vec => quote_spanned! { ty.span()=>
                         .takes_value(true)
                         .multiple(true)
                         #validator
                     },

                     Ty::Other if occurrences => quote_spanned! { ty.span()=>
                         .takes_value(false)
                         .multiple(true)
                     },

                     Ty::Other if flag => quote_spanned! { ty.span()=>
                         .takes_value(false)
                         .multiple(false)
                     },

                     Ty::Other => {
                         let required = !attrs.has_method("default_value");
                         quote_spanned! { ty.span()=>
                             .takes_value(true)
                             .multiple(false)
                             .required(#required)
                             #validator
                         }
                     }
                 };

                 let name = attrs.cased_name();
                 let methods = attrs.field_methods();

                 Some(quote_spanned! { field.span()=>
                     let #app_var = #app_var.arg(
                         ::structopt::clap::Arg::with_name(#name)
                             #modifier
                             #methods
                     );
                 })
             }
         }
     });

     let app_methods = parent_attribute.top_level_methods();
     let version = parent_attribute.version();
     quote! {{
         let #app_var = #app_var#app_methods;
         #( #args )*
         #subcmd
         #app_var#version
     }}
 }

 fn gen_constructor(fields: &Punctuated<Field, Comma>, parent_attribute: &Attrs) -> TokenStream {
     // This ident is used in several match branches below,
     // and the `quote[_spanned]` invocations have different spans.
     //
     // Given that this ident is used in several places and
     // that the branches are located inside of a loop, it is possible that
     // this ident will be given _different_ spans in different places, and
     // thus will not be the _same_ ident anymore. To make sure the `matches`
     // is always the same, we factor it out.
     let matches = format_ident!("matches");

     let fields = fields.iter().map(|field| {
         let attrs = Attrs::from_field(
             field,
             Some(parent_attribute),
             parent_attribute.casing(),
             parent_attribute.env_casing(),
         );
         let field_name = field.ident.as_ref().unwrap();
         let kind = attrs.kind();
         match &*kind {
             Kind::ExternalSubcommand => abort!(
                 kind.span(),
                 "`external_subcommand` is allowed only on enum variants"
             ),

             Kind::Subcommand(ty) => {
                 let subcmd_type = match (**ty, sub_type(&field.ty)) {
                     (Ty::Option, Some(sub_type)) => sub_type,
                     _ => &field.ty,
                 };
                 let unwrapper = match **ty {
                     Ty::Option => quote!(),
                     _ => quote_spanned!( ty.span()=> .unwrap() ),
                 };
                 quote_spanned! { kind.span()=>
                     #field_name: <#subcmd_type as ::structopt::StructOptInternal>::from_subcommand(
                         #matches.subcommand())
                         #unwrapper
                 }
             }

             Kind::Flatten => quote_spanned! { kind.span()=>
                 #field_name: ::structopt::StructOpt::from_clap(#matches)
             },

             Kind::Skip(val) => match val {
                 None => quote_spanned!(kind.span()=> #field_name: Default::default()),
                 Some(val) => quote_spanned!(kind.span()=> #field_name: (#val).into()),
             },

             Kind::Arg(ty) => {
                 use crate::attrs::ParserKind::*;

                 let parser = attrs.parser();
                 let func = &parser.func;
                 let span = parser.kind.span();
                 let (value_of, values_of, parse) = match *parser.kind {
                     FromStr => (
                         quote_spanned!(span=> value_of),
                         quote_spanned!(span=> values_of),
                         func.clone(),
                     ),
                     TryFromStr => (
                         quote_spanned!(span=> value_of),
                         quote_spanned!(span=> values_of),
                         quote_spanned!(func.span()=> |s| #func(s).unwrap()),
                     ),
                     FromOsStr => (
                         quote_spanned!(span=> value_of_os),
                         quote_spanned!(span=> values_of_os),
                         func.clone(),
                     ),
                     TryFromOsStr => (
                         quote_spanned!(span=> value_of_os),
                         quote_spanned!(span=> values_of_os),
                         quote_spanned!(func.span()=> |s| #func(s).unwrap()),
                     ),
                     FromOccurrences => (
                         quote_spanned!(span=> occurrences_of),
                         quote!(),
                         func.clone(),
                     ),
                     FromFlag => (quote!(), quote!(), func.clone()),
                 };

                 let flag = *attrs.parser().kind == ParserKind::FromFlag;
                 let occurrences = *attrs.parser().kind == ParserKind::FromOccurrences;
                 let name = attrs.cased_name();
                 let field_value = match **ty {
                     Ty::Bool => quote_spanned!(ty.span()=> #matches.is_present(#name)),

                     Ty::Option => quote_spanned! { ty.span()=>
                         #matches.#value_of(#name)
                             .map(#parse)
                     },

                     Ty::OptionOption => quote_spanned! { ty.span()=>
                         if #matches.is_present(#name) {
                             Some(#matches.#value_of(#name).map(#parse))
                         } else {
                             None
                         }
                     },

                     Ty::OptionVec => quote_spanned! { ty.span()=>
                         if #matches.is_present(#name) {
                             Some(#matches.#values_of(#name)
                                  .map_or_else(Vec::new, |v| v.map(#parse).collect()))
                         } else {
                             None
                         }
                     },

                     Ty::Vec => quote_spanned! { ty.span()=>
                         #matches.#values_of(#name)
                             .map_or_else(Vec::new, |v| v.map(#parse).collect())
                     },

                     Ty::Other if occurrences => quote_spanned! { ty.span()=>
                         #parse(#matches.#value_of(#name))
                     },

                     Ty::Other if flag => quote_spanned! { ty.span()=>
                         #parse(#matches.is_present(#name))
                     },

                     Ty::Other => quote_spanned! { ty.span()=>
                         #matches.#value_of(#name)
                             .map(#parse)
                             .unwrap()
                     },
                 };

                 quote_spanned!(field.span()=> #field_name: #field_value )
             }
         }
     });

     quote! {{
         #( #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 {
             #struct_name #field_block
         }
     }
 }

 fn gen_clap(attrs: &[Attribute]) -> GenOutput {
     let name = std::env::var("CARGO_PKG_NAME").ok().unwrap_or_default();

     let attrs = Attrs::from_struct(
         Span::call_site(),
         attrs,
         Name::Assigned(quote!(#name)),
         None,
         Sp::call_site(DEFAULT_CASING),
         Sp::call_site(DEFAULT_ENV_CASING),
     );
     let tokens = {
         let name = attrs.cased_name();
         quote!(::structopt::clap::App::new(#name))
     };

     GenOutput { tokens, attrs }
 }

 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 = #clap_tokens;
             <Self as ::structopt::StructOptInternal>::augment_clap(app)
         }
     };

     GenOutput {
         tokens: augmented_tokens,
         attrs: initial_clap_app_gen.attrs,
     }
 }

 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, parent_attribute);
     quote! {
         fn augment_clap<'a, 'b>(
             #app_var: ::structopt::clap::App<'a, 'b>
         ) -> ::structopt::clap::App<'a, 'b> {
             #augmentation
         }
     }
 }

 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 = #clap_tokens
                 .setting(::structopt::clap::AppSettings::SubcommandRequiredElseHelp);
             <Self as ::structopt::StructOptInternal>::augment_clap(app)
         }
     };

     GenOutput {
         tokens,
         attrs: initial_clap_app_gen.attrs,
     }
 }

 fn gen_augment_clap_enum(
     variants: &Punctuated<Variant, Comma>,
     parent_attribute: &Attrs,
 ) -> TokenStream {
     use syn::Fields::*;

     let subcommands = variants.iter().map(|variant| {
         let attrs = Attrs::from_struct(
             variant.span(),
             &variant.attrs,
             Name::Derived(variant.ident.clone()),
             Some(parent_attribute),
             parent_attribute.casing(),
             parent_attribute.env_casing(),
         );

         let kind = attrs.kind();
         match &*kind {
             Kind::ExternalSubcommand => {
                 let app_var = Ident::new("app", Span::call_site());
                 quote_spanned! { attrs.kind().span()=>
                     let #app_var = #app_var.setting(
                         ::structopt::clap::AppSettings::AllowExternalSubcommands
                     );
                 }
             },

             Kind::Flatten => {
                 match variant.fields {
                     Unnamed(FieldsUnnamed { ref unnamed, .. }) if unnamed.len() == 1 => {
                         let ty = &unnamed[0];
                         quote! {
                             let app = <#ty as ::structopt::StructOptInternal>::augment_clap(app);
                         }
                     },
                     _ => abort!(
                         variant,
                         "`flatten` is usable only with single-typed tuple variants"
                     ),
                 }
             },

             _ => {
                 let app_var = Ident::new("subcommand", Span::call_site());
                 let arg_block = match variant.fields {
                     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];
                         quote_spanned! { ty.span()=>
                             {
                                 let #app_var = <#ty as ::structopt::StructOptInternal>::augment_clap(
                                     #app_var
                                 );
                                 if <#ty as ::structopt::StructOptInternal>::is_subcommand() {
                                     #app_var.setting(
                                         ::structopt::clap::AppSettings::SubcommandRequiredElseHelp
                                     )
                                 } else {
                                     #app_var
                                 }
                             }
                         }
                     }
                     Unnamed(..) => abort!(variant, "non single-typed tuple enums are not supported"),
                 };

                 let name = attrs.cased_name();
                 let from_attrs = attrs.top_level_methods();
                 let version = attrs.version();
                 quote! {
                     let app = app.subcommand({
                         let #app_var = ::structopt::clap::SubCommand::with_name(#name);
                         let #app_var = #arg_block;
                         #app_var#from_attrs#version
                     });
                 }
             },
         }
     });

     let app_methods = parent_attribute.top_level_methods();
     let version = parent_attribute.version();
     quote! {
         fn augment_clap<'a, 'b>(
             app: ::structopt::clap::App<'a, 'b>
         ) -> ::structopt::clap::App<'a, 'b> {
             let app = app #app_methods;
             #( #subcommands )*;
             app #version
         }
     }
 }

 fn gen_from_clap_enum(name: &Ident) -> TokenStream {
     quote! {
         fn from_clap(matches: &::structopt::clap::ArgMatches) -> Self {
             <#name as ::structopt::StructOptInternal>::from_subcommand(matches.subcommand())
                 .expect("structopt misuse: You likely tried to #[flatten] a struct \
                          that contains #[subcommand]. This is forbidden.")
         }
     }
 }

 fn gen_from_subcommand(
     name: &Ident,
     variants: &Punctuated<Variant, Comma>,
     parent_attribute: &Attrs,
 ) -> TokenStream {
     use syn::Fields::*;

     let mut ext_subcmd = None;

     let (flatten_variants, variants): (Vec<_>, Vec<_>) = variants
         .iter()
         .filter_map(|variant| {
             let attrs = Attrs::from_struct(
                 variant.span(),
                 &variant.attrs,
                 Name::Derived(variant.ident.clone()),
                 Some(parent_attribute),
                 parent_attribute.casing(),
                 parent_attribute.env_casing(),
             );

             let variant_name = &variant.ident;

             if let Kind::ExternalSubcommand = *attrs.kind() {
                 if ext_subcmd.is_some() {
                     abort!(
                         attrs.kind().span(),
                         "Only one variant can be marked with `external_subcommand`, \
                          this is the second"
                     );
                 }

                 let ty = match variant.fields {
                     Unnamed(ref fields) if fields.unnamed.len() == 1 => &fields.unnamed[0].ty,

                     _ => abort!(
                         variant,
                         "The enum variant marked with `external_attribute` must be \
                          a single-typed tuple, and the type must be either `Vec<String>` \
                          or `Vec<OsString>`."
                     ),
                 };

                 let (span, str_ty, values_of) = match subty_if_name(ty, "Vec") {
                     Some(subty) => {
                         if is_simple_ty(subty, "String") {
                             (
                                 subty.span(),
                                 quote!(::std::string::String),
                                 quote!(values_of),
                             )
                         } else {
                             (
                                 subty.span(),
                                 quote!(::std::ffi::OsString),
                                 quote!(values_of_os),
                             )
                         }
                     }

                     None => abort!(
                         ty,
                         "The type must be either `Vec<String>` or `Vec<OsString>` \
                          to be used with `external_subcommand`."
                     ),
                 };

                 ext_subcmd = Some((span, variant_name, str_ty, values_of));
                 None
             } else {
                 Some((variant, attrs))
             }
         })
         .partition(|(_, attrs)| match &*attrs.kind() {
             Kind::Flatten => true,
             _ => false,
         });

     let other = format_ident!("other");
     let matches = format_ident!("matches");

     let external = match ext_subcmd {
         Some((span, var_name, str_ty, values_of)) => quote_spanned! { span=>
             match #other {
                 ("", ::std::option::Option::None) => None,

                 (external, Some(#matches)) => {
                     ::std::option::Option::Some(#name::#var_name(
                         ::std::iter::once(#str_ty::from(external))
                         .chain(
                             #matches.#values_of("").into_iter().flatten().map(#str_ty::from)
                         )
                         .collect::<::std::vec::Vec<_>>()
                     ))
                 }

                 (external, None) => {
                     ::std::option::Option::Some(#name::#var_name(
                         ::std::iter::once(#str_ty::from(external))
                             .collect::<::std::vec::Vec<_>>()
                     ))
                 }
             }
         },

         None => quote!(None),
     };

     let match_arms = variants.iter().map(|(variant, attrs)| {
         let sub_name = attrs.cased_name();
         let variant_name = &variant.ident;
         let constructor_block = match variant.fields {
             Named(ref fields) => gen_constructor(&fields.named, &attrs),
             Unit => quote!(),
             Unnamed(ref fields) if fields.unnamed.len() == 1 => {
                 let ty = &fields.unnamed[0];
                 quote!( ( <#ty as ::structopt::StructOpt>::from_clap(#matches) ) )
             }
             Unnamed(..) => abort!(
                 variant.ident,
                 "non single-typed tuple enums are not supported"
             ),
         };

         quote! {
             (#sub_name, Some(#matches)) => {
                 Some(#name :: #variant_name #constructor_block)
             }
         }
     });

     let child_subcommands = flatten_variants.iter().map(|(variant, _attrs)| {
         let variant_name = &variant.ident;
         match variant.fields {
             Unnamed(ref fields) if fields.unnamed.len() == 1 => {
                 let ty = &fields.unnamed[0];
                 quote! {
                     if let Some(res) =
                         <#ty as ::structopt::StructOptInternal>::from_subcommand(#other)
                     {
                         return Some(#name :: #variant_name (res));
                     }
                 }
             }
             _ => abort!(
                 variant,
                 "`flatten` is usable only with single-typed tuple variants"
             ),
         }
     });

     quote! {
         fn from_subcommand<'a, 'b>(
             sub: (&'b str, Option<&'b ::structopt::clap::ArgMatches<'a>>)
         ) -> Option<Self> {
             match sub {
                 #( #match_arms, )*
                 #other => {
                     #( #child_subcommands )else*;
                     #external
                 }
             }
         }
     }
 }

 #[cfg(feature = "paw")]
 fn gen_paw_impl(name: &Ident) -> TokenStream {
     quote! {
         impl ::structopt::paw::ParseArgs for #name {
             type Error = std::io::Error;

             fn parse_args() -> std::result::Result<Self, Self::Error> {
                 Ok(<#name as ::structopt::StructOpt>::from_args())
             }
         }
     }
 }
 #[cfg(not(feature = "paw"))]
 fn gen_paw_impl(_: &Ident) -> TokenStream {
     TokenStream::new()
 }

 fn impl_structopt_for_struct(
     name: &Ident,
     fields: &Punctuated<Field, Comma>,
     attrs: &[Attribute],
 ) -> TokenStream {
     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 paw_impl = gen_paw_impl(name);

     let clap_tokens = basic_clap_app_gen.tokens;
     quote! {
         #[allow(unused_variables)]
         #[allow(unknown_lints)]
         #[allow(
             clippy::style,
             clippy::complexity,
             clippy::pedantic,
             clippy::restriction,
             clippy::perf,
             clippy::deprecated,
             clippy::nursery,
             clippy::cargo
         )]
         #[deny(clippy::correctness)]
         #[allow(dead_code, unreachable_code)]
         impl ::structopt::StructOpt for #name {
             #clap_tokens
             #from_clap
         }

         #[allow(unused_variables)]
         #[allow(unknown_lints)]
         #[allow(
             clippy::style,
             clippy::complexity,
             clippy::pedantic,
             clippy::restriction,
             clippy::perf,
             clippy::deprecated,
             clippy::nursery,
             clippy::cargo
         )]
         #[deny(clippy::correctness)]
         #[allow(dead_code, unreachable_code)]
         impl ::structopt::StructOptInternal for #name {
             #augment_clap
             fn is_subcommand() -> bool { false }
         }

         #paw_impl
     }
 }

 fn impl_structopt_for_enum(
     name: &Ident,
     variants: &Punctuated<Variant, Comma>,
     attrs: &[Attribute],
 ) -> TokenStream {
     let basic_clap_app_gen = gen_clap_enum(attrs);
     let clap_tokens = basic_clap_app_gen.tokens;
     let attrs = basic_clap_app_gen.attrs;

     let augment_clap = gen_augment_clap_enum(variants, &attrs);
     let from_clap = gen_from_clap_enum(name);
     let from_subcommand = gen_from_subcommand(name, variants, &attrs);
     let paw_impl = gen_paw_impl(name);

     quote! {
         #[allow(unknown_lints)]
         #[allow(unused_variables, dead_code, unreachable_code)]
         #[allow(
             clippy::style,
             clippy::complexity,
             clippy::pedantic,
             clippy::restriction,
             clippy::perf,
             clippy::deprecated,
             clippy::nursery,
             clippy::cargo
         )]
         #[deny(clippy::correctness)]
         impl ::structopt::StructOpt for #name {
             #clap_tokens
             #from_clap
         }

         #[allow(unused_variables)]
         #[allow(unknown_lints)]
         #[allow(
             clippy::style,
             clippy::complexity,
             clippy::pedantic,
             clippy::restriction,
             clippy::perf,
             clippy::deprecated,
             clippy::nursery,
             clippy::cargo
         )]
         #[deny(clippy::correctness)]
         #[allow(dead_code, unreachable_code)]
         impl ::structopt::StructOptInternal for #name {
             #augment_clap
             #from_subcommand
             fn is_subcommand() -> bool { true }
         }

         #paw_impl
     }
 }

 fn impl_structopt(input: &DeriveInput) -> TokenStream {
     use syn::Data::*;

     let struct_name = &input.ident;

     set_dummy(quote! {
         impl ::structopt::StructOpt for #struct_name {
             fn clap<'a, 'b>() -> ::structopt::clap::App<'a, 'b> {
                 unimplemented!()
             }
             fn from_clap(_matches: &::structopt::clap::ArgMatches) -> Self {
                 unimplemented!()
             }
         }

         impl ::structopt::StructOptInternal for #struct_name {}
     });

     match input.data {
         Struct(DataStruct {
             fields: syn::Fields::Named(ref fields),
             ..
         }) => impl_structopt_for_struct(struct_name, &fields.named, &input.attrs),
         Enum(ref e) => impl_structopt_for_enum(struct_name, &e.variants, &input.attrs),
         _ => abort_call_site!("structopt only supports non-tuple structs and enums"),
     }
 }
	// 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.

	//! This crate is custom derive for `StructOpt`. It should not be used
	//! directly. See [structopt documentation](https://docs.rs/structopt)
	//! for the usage of `#[derive(StructOpt)]`.

	#![allow(clippy::large_enum_variant)]
	// FIXME: remove when and if our MSRV hits 1.42
	#![allow(clippy::match_like_matches_macro)]
	#![forbid(unsafe_code)]

	extern crate proc_macro;

	mod attrs;
	mod doc_comments;
	mod parse;
	mod spanned;
	mod ty;

	use crate::{
	attrs::{Attrs, CasingStyle, Kind, Name, ParserKind},
	spanned::Sp,
	ty::{is_simple_ty, sub_type, subty_if_name, Ty},
	};

	use proc_macro2::{Span, TokenStream};
	use proc_macro_error::{abort, abort_call_site, proc_macro_error, set_dummy};
	use quote::{format_ident, quote, quote_spanned};
	use syn::{punctuated::Punctuated, spanned::Spanned, token::Comma, *};

	/// Default casing style for generated arguments.
	const DEFAULT_CASING: CasingStyle = CasingStyle::Kebab;

	/// Default casing style for environment variables
	const DEFAULT_ENV_CASING: CasingStyle = CasingStyle::ScreamingSnake;

	/// 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))]
	#[proc_macro_error]
	pub fn structopt(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
	let input: DeriveInput = syn::parse(input).unwrap();
	let gen = impl_structopt(&input);
	gen.into()
	}

	/// 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,
	parent_attribute: &Attrs,
	) -> TokenStream {
	let mut subcmds = fields.iter().filter_map(\|field\| {
	let attrs = Attrs::from_field(
	field,
	Some(parent_attribute),
	parent_attribute.casing(),
	parent_attribute.env_casing(),
	);
	let kind = attrs.kind();
	if let Kind::Subcommand(ty) = &*kind {
	let subcmd_type = match (**ty, sub_type(&field.ty)) {
	(Ty::Option, Some(sub_type)) => sub_type,
	_ => &field.ty,
	};
	let required = if **ty == Ty::Option {
	quote!()
	} else {
	quote_spanned! { kind.span()=>
	let #app_var = #app_var.setting(
	::structopt::clap::AppSettings::SubcommandRequiredElseHelp
	);
	}
	};

	let span = field.span();
	let ts = quote! {
	let #app_var = <#subcmd_type as ::structopt::StructOptInternal>::augment_clap(
	#app_var
	);
	#required
	};
	Some((span, ts))
	} else {
	None
	}
	});

	let subcmd = subcmds.next().map(\|(_, ts)\| ts);
	if let Some((span, _)) = subcmds.next() {
	abort!(
	span,
	"multiple subcommand sets are not allowed, that's the second"
	);
	}

	let args = fields.iter().filter_map(\|field\| {
	let attrs = Attrs::from_field(
	field,
	Some(parent_attribute),
	parent_attribute.casing(),
	parent_attribute.env_casing(),
	);
	let kind = attrs.kind();
	match &*kind {
	Kind::ExternalSubcommand => abort!(
	kind.span(),
	"`external_subcommand` is only allowed on enum variants"
	),
	Kind::Subcommand(_) \| Kind::Skip(_) => None,
	Kind::Flatten => {
	let ty = &field.ty;
	Some(quote_spanned! { kind.span()=>
	let #app_var = <#ty as ::structopt::StructOptInternal>::augment_clap(#app_var);
	let #app_var = if <#ty as ::structopt::StructOptInternal>::is_subcommand() {
	#app_var.setting(::structopt::clap::AppSettings::SubcommandRequiredElseHelp)
	} else {
	#app_var
	};
	})
	}
	Kind::Arg(ty) => {
	let convert_type = match **ty {
	Ty::Vec \| Ty::Option => sub_type(&field.ty).unwrap_or(&field.ty),
	Ty::OptionOption \| Ty::OptionVec => {
	sub_type(&field.ty).and_then(sub_type).unwrap_or(&field.ty)
	}
	_ => &field.ty,
	};

	let occurrences = *attrs.parser().kind == ParserKind::FromOccurrences;
	let flag = *attrs.parser().kind == ParserKind::FromFlag;

	let parser = attrs.parser();
	let func = &parser.func;
	let validator = match *parser.kind {
	ParserKind::TryFromStr => quote_spanned! { func.span()=>
	.validator(\|s\| {
	#func(s.as_str())
	.map(\|_: #convert_type\| ())
	.map_err(\|e\| e.to_string())
	})
	},
	ParserKind::TryFromOsStr => quote_spanned! { func.span()=>
	.validator_os(\|s\| #func(&s).map(\|_: #convert_type\| ()))
	},
	_ => quote!(),
	};

	let modifier = match **ty {
	Ty::Bool => quote_spanned! { ty.span()=>
	.takes_value(false)
	.multiple(false)
	},

	Ty::Option => quote_spanned! { ty.span()=>
	.takes_value(true)
	.multiple(false)
	#validator
	},

	Ty::OptionOption => quote_spanned! { ty.span()=>
	.takes_value(true)
	.multiple(false)
	.min_values(0)
	.max_values(1)
	#validator
	},

	Ty::OptionVec => quote_spanned! { ty.span()=>
	.takes_value(true)
	.multiple(true)
	.min_values(0)
	#validator
	},

	Ty::Vec => quote_spanned! { ty.span()=>
	.takes_value(true)
	.multiple(true)
	#validator
	},

	Ty::Other if occurrences => quote_spanned! { ty.span()=>
	.takes_value(false)
	.multiple(true)
	},

	Ty::Other if flag => quote_spanned! { ty.span()=>
	.takes_value(false)
	.multiple(false)
	},

	Ty::Other => {
	let required = !attrs.has_method("default_value");
	quote_spanned! { ty.span()=>
	.takes_value(true)
	.multiple(false)
	.required(#required)
	#validator
	}
	}
	};

	let name = attrs.cased_name();
	let methods = attrs.field_methods();

	Some(quote_spanned! { field.span()=>
	let #app_var = #app_var.arg(
	::structopt::clap::Arg::with_name(#name)
	#modifier
	#methods
	);
	})
	}
	}
	});

	let app_methods = parent_attribute.top_level_methods();
	let version = parent_attribute.version();
	quote! {{
	let #app_var = #app_var#app_methods;
	#( #args )*
	#subcmd
	#app_var#version
	}}
	}

	fn gen_constructor(fields: &Punctuated<Field, Comma>, parent_attribute: &Attrs) -> TokenStream {
	// This ident is used in several match branches below,
	// and the `quote[_spanned]` invocations have different spans.
	//
	// Given that this ident is used in several places and
	// that the branches are located inside of a loop, it is possible that
	// this ident will be given _different_ spans in different places, and
	// thus will not be the _same_ ident anymore. To make sure the `matches`
	// is always the same, we factor it out.
	let matches = format_ident!("matches");

	let fields = fields.iter().map(\|field\| {
	let attrs = Attrs::from_field(
	field,
	Some(parent_attribute),
	parent_attribute.casing(),
	parent_attribute.env_casing(),
	);
	let field_name = field.ident.as_ref().unwrap();
	let kind = attrs.kind();
	match &*kind {
	Kind::ExternalSubcommand => abort!(
	kind.span(),
	"`external_subcommand` is allowed only on enum variants"
	),

	Kind::Subcommand(ty) => {
	let subcmd_type = match (**ty, sub_type(&field.ty)) {
	(Ty::Option, Some(sub_type)) => sub_type,
	_ => &field.ty,
	};
	let unwrapper = match **ty {
	Ty::Option => quote!(),
	_ => quote_spanned!( ty.span()=> .unwrap() ),
	};
	quote_spanned! { kind.span()=>
	#field_name: <#subcmd_type as ::structopt::StructOptInternal>::from_subcommand(
	#matches.subcommand())
	#unwrapper
	}
	}

	Kind::Flatten => quote_spanned! { kind.span()=>
	#field_name: ::structopt::StructOpt::from_clap(#matches)
	},

	Kind::Skip(val) => match val {
	None => quote_spanned!(kind.span()=> #field_name: Default::default()),
	Some(val) => quote_spanned!(kind.span()=> #field_name: (#val).into()),
	},

	Kind::Arg(ty) => {
	use crate::attrs::ParserKind::*;

	let parser = attrs.parser();
	let func = &parser.func;
	let span = parser.kind.span();
	let (value_of, values_of, parse) = match *parser.kind {
	FromStr => (
	quote_spanned!(span=> value_of),
	quote_spanned!(span=> values_of),
	func.clone(),
	),
	TryFromStr => (
	quote_spanned!(span=> value_of),
	quote_spanned!(span=> values_of),
	quote_spanned!(func.span()=> \|s\| #func(s).unwrap()),
	),
	FromOsStr => (
	quote_spanned!(span=> value_of_os),
	quote_spanned!(span=> values_of_os),
	func.clone(),
	),
	TryFromOsStr => (
	quote_spanned!(span=> value_of_os),
	quote_spanned!(span=> values_of_os),
	quote_spanned!(func.span()=> \|s\| #func(s).unwrap()),
	),
	FromOccurrences => (
	quote_spanned!(span=> occurrences_of),
	quote!(),
	func.clone(),
	),
	FromFlag => (quote!(), quote!(), func.clone()),
	};

	let flag = *attrs.parser().kind == ParserKind::FromFlag;
	let occurrences = *attrs.parser().kind == ParserKind::FromOccurrences;
	let name = attrs.cased_name();
	let field_value = match **ty {
	Ty::Bool => quote_spanned!(ty.span()=> #matches.is_present(#name)),

	Ty::Option => quote_spanned! { ty.span()=>
	#matches.#value_of(#name)
	.map(#parse)
	},

	Ty::OptionOption => quote_spanned! { ty.span()=>
	if #matches.is_present(#name) {
	Some(#matches.#value_of(#name).map(#parse))
	} else {
	None
	}
	},

	Ty::OptionVec => quote_spanned! { ty.span()=>
	if #matches.is_present(#name) {
	Some(#matches.#values_of(#name)
	.map_or_else(Vec::new, \|v\| v.map(#parse).collect()))
	} else {
	None
	}
	},

	Ty::Vec => quote_spanned! { ty.span()=>
	#matches.#values_of(#name)
	.map_or_else(Vec::new, \|v\| v.map(#parse).collect())
	},

	Ty::Other if occurrences => quote_spanned! { ty.span()=>
	#parse(#matches.#value_of(#name))
	},

	Ty::Other if flag => quote_spanned! { ty.span()=>
	#parse(#matches.is_present(#name))
	},

	Ty::Other => quote_spanned! { ty.span()=>
	#matches.#value_of(#name)
	.map(#parse)
	.unwrap()
	},
	};

	quote_spanned!(field.span()=> #field_name: #field_value )
	}
	}
	});

	quote! {{
	#( #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 {
	#struct_name #field_block
	}
	}
	}

	fn gen_clap(attrs: &[Attribute]) -> GenOutput {
	let name = std::env::var("CARGO_PKG_NAME").ok().unwrap_or_default();

	let attrs = Attrs::from_struct(
	Span::call_site(),
	attrs,
	Name::Assigned(quote!(#name)),
	None,
	Sp::call_site(DEFAULT_CASING),
	Sp::call_site(DEFAULT_ENV_CASING),
	);
	let tokens = {
	let name = attrs.cased_name();
	quote!(::structopt::clap::App::new(#name))
	};

	GenOutput { tokens, attrs }
	}

	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 = #clap_tokens;
	<Self as ::structopt::StructOptInternal>::augment_clap(app)
	}
	};

	GenOutput {
	tokens: augmented_tokens,
	attrs: initial_clap_app_gen.attrs,
	}
	}

	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, parent_attribute);
	quote! {
	fn augment_clap<'a, 'b>(
	#app_var: ::structopt::clap::App<'a, 'b>
	) -> ::structopt::clap::App<'a, 'b> {
	#augmentation
	}
	}
	}

	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 = #clap_tokens
	.setting(::structopt::clap::AppSettings::SubcommandRequiredElseHelp);
	<Self as ::structopt::StructOptInternal>::augment_clap(app)
	}
	};

	GenOutput {
	tokens,
	attrs: initial_clap_app_gen.attrs,
	}
	}

	fn gen_augment_clap_enum(
	variants: &Punctuated<Variant, Comma>,
	parent_attribute: &Attrs,
	) -> TokenStream {
	use syn::Fields::*;

	let subcommands = variants.iter().map(\|variant\| {
	let attrs = Attrs::from_struct(
	variant.span(),
	&variant.attrs,
	Name::Derived(variant.ident.clone()),
	Some(parent_attribute),
	parent_attribute.casing(),
	parent_attribute.env_casing(),
	);

	let kind = attrs.kind();
	match &*kind {
	Kind::ExternalSubcommand => {
	let app_var = Ident::new("app", Span::call_site());
	quote_spanned! { attrs.kind().span()=>
	let #app_var = #app_var.setting(
	::structopt::clap::AppSettings::AllowExternalSubcommands
	);
	}
	},

	Kind::Flatten => {
	match variant.fields {
	Unnamed(FieldsUnnamed { ref unnamed, .. }) if unnamed.len() == 1 => {
	let ty = &unnamed[0];
	quote! {
	let app = <#ty as ::structopt::StructOptInternal>::augment_clap(app);
	}
	},
	_ => abort!(
	variant,
	"`flatten` is usable only with single-typed tuple variants"
	),
	}
	},

	_ => {
	let app_var = Ident::new("subcommand", Span::call_site());
	let arg_block = match variant.fields {
	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];
	quote_spanned! { ty.span()=>
	{
	let #app_var = <#ty as ::structopt::StructOptInternal>::augment_clap(
	#app_var
	);
	if <#ty as ::structopt::StructOptInternal>::is_subcommand() {
	#app_var.setting(
	::structopt::clap::AppSettings::SubcommandRequiredElseHelp
	)
	} else {
	#app_var
	}
	}
	}
	}
	Unnamed(..) => abort!(variant, "non single-typed tuple enums are not supported"),
	};

	let name = attrs.cased_name();
	let from_attrs = attrs.top_level_methods();
	let version = attrs.version();
	quote! {
	let app = app.subcommand({
	let #app_var = ::structopt::clap::SubCommand::with_name(#name);
	let #app_var = #arg_block;
	#app_var#from_attrs#version
	});
	}
	},
	}
	});

	let app_methods = parent_attribute.top_level_methods();
	let version = parent_attribute.version();
	quote! {
	fn augment_clap<'a, 'b>(
	app: ::structopt::clap::App<'a, 'b>
	) -> ::structopt::clap::App<'a, 'b> {
	let app = app #app_methods;
	#( #subcommands )*;
	app #version
	}
	}
	}

	fn gen_from_clap_enum(name: &Ident) -> TokenStream {
	quote! {
	fn from_clap(matches: &::structopt::clap::ArgMatches) -> Self {
	<#name as ::structopt::StructOptInternal>::from_subcommand(matches.subcommand())
	.expect("structopt misuse: You likely tried to #[flatten] a struct \
	that contains #[subcommand]. This is forbidden.")
	}
	}
	}

	fn gen_from_subcommand(
	name: &Ident,
	variants: &Punctuated<Variant, Comma>,
	parent_attribute: &Attrs,
	) -> TokenStream {
	use syn::Fields::*;

	let mut ext_subcmd = None;

	let (flatten_variants, variants): (Vec<_>, Vec<_>) = variants
	.iter()
	.filter_map(\|variant\| {
	let attrs = Attrs::from_struct(
	variant.span(),
	&variant.attrs,
	Name::Derived(variant.ident.clone()),
	Some(parent_attribute),
	parent_attribute.casing(),
	parent_attribute.env_casing(),
	);

	let variant_name = &variant.ident;

	if let Kind::ExternalSubcommand = *attrs.kind() {
	if ext_subcmd.is_some() {
	abort!(
	attrs.kind().span(),
	"Only one variant can be marked with `external_subcommand`, \
	this is the second"
	);
	}

	let ty = match variant.fields {
	Unnamed(ref fields) if fields.unnamed.len() == 1 => &fields.unnamed[0].ty,

	_ => abort!(
	variant,
	"The enum variant marked with `external_attribute` must be \
	a single-typed tuple, and the type must be either `Vec<String>` \
	or `Vec<OsString>`."
	),
	};

	let (span, str_ty, values_of) = match subty_if_name(ty, "Vec") {
	Some(subty) => {
	if is_simple_ty(subty, "String") {
	(
	subty.span(),
	quote!(::std::string::String),
	quote!(values_of),
	)
	} else {
	(
	subty.span(),
	quote!(::std::ffi::OsString),
	quote!(values_of_os),
	)
	}
	}

	None => abort!(
	ty,
	"The type must be either `Vec<String>` or `Vec<OsString>` \
	to be used with `external_subcommand`."
	),
	};

	ext_subcmd = Some((span, variant_name, str_ty, values_of));
	None
	} else {
	Some((variant, attrs))
	}
	})
	.partition(\|(_, attrs)\| match &*attrs.kind() {
	Kind::Flatten => true,
	_ => false,
	});

	let other = format_ident!("other");
	let matches = format_ident!("matches");

	let external = match ext_subcmd {
	Some((span, var_name, str_ty, values_of)) => quote_spanned! { span=>
	match #other {
	("", ::std::option::Option::None) => None,

	(external, Some(#matches)) => {
	::std::option::Option::Some(#name::#var_name(
	::std::iter::once(#str_ty::from(external))
	.chain(
	#matches.#values_of("").into_iter().flatten().map(#str_ty::from)
	)
	.collect::<::std::vec::Vec<_>>()
	))
	}

	(external, None) => {
	::std::option::Option::Some(#name::#var_name(
	::std::iter::once(#str_ty::from(external))
	.collect::<::std::vec::Vec<_>>()
	))
	}
	}
	},

	None => quote!(None),
	};

	let match_arms = variants.iter().map(\|(variant, attrs)\| {
	let sub_name = attrs.cased_name();
	let variant_name = &variant.ident;
	let constructor_block = match variant.fields {
	Named(ref fields) => gen_constructor(&fields.named, &attrs),
	Unit => quote!(),
	Unnamed(ref fields) if fields.unnamed.len() == 1 => {
	let ty = &fields.unnamed[0];
	quote!( ( <#ty as ::structopt::StructOpt>::from_clap(#matches) ) )
	}
	Unnamed(..) => abort!(
	variant.ident,
	"non single-typed tuple enums are not supported"
	),
	};

	quote! {
	(#sub_name, Some(#matches)) => {
	Some(#name :: #variant_name #constructor_block)
	}
	}
	});

	let child_subcommands = flatten_variants.iter().map(\|(variant, _attrs)\| {
	let variant_name = &variant.ident;
	match variant.fields {
	Unnamed(ref fields) if fields.unnamed.len() == 1 => {
	let ty = &fields.unnamed[0];
	quote! {
	if let Some(res) =
	<#ty as ::structopt::StructOptInternal>::from_subcommand(#other)
	{
	return Some(#name :: #variant_name (res));
	}
	}
	}
	_ => abort!(
	variant,
	"`flatten` is usable only with single-typed tuple variants"
	),
	}
	});

	quote! {
	fn from_subcommand<'a, 'b>(
	sub: (&'b str, Option<&'b ::structopt::clap::ArgMatches<'a>>)
	) -> Option<Self> {
	match sub {
	#( #match_arms, )*
	#other => {
	#( #child_subcommands )else*;
	#external
	}
	}
	}
	}
	}

	#[cfg(feature = "paw")]
	fn gen_paw_impl(name: &Ident) -> TokenStream {
	quote! {
	impl ::structopt::paw::ParseArgs for #name {
	type Error = std::io::Error;

	fn parse_args() -> std::result::Result<Self, Self::Error> {
	Ok(<#name as ::structopt::StructOpt>::from_args())
	}
	}
	}
	}
	#[cfg(not(feature = "paw"))]
	fn gen_paw_impl(_: &Ident) -> TokenStream {
	TokenStream::new()
	}

	fn impl_structopt_for_struct(
	name: &Ident,
	fields: &Punctuated<Field, Comma>,
	attrs: &[Attribute],
	) -> TokenStream {
	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 paw_impl = gen_paw_impl(name);

	let clap_tokens = basic_clap_app_gen.tokens;
	quote! {
	#[allow(unused_variables)]
	#[allow(unknown_lints)]
	#[allow(
	clippy::style,
	clippy::complexity,
	clippy::pedantic,
	clippy::restriction,
	clippy::perf,
	clippy::deprecated,
	clippy::nursery,
	clippy::cargo
	)]
	#[deny(clippy::correctness)]
	#[allow(dead_code, unreachable_code)]
	impl ::structopt::StructOpt for #name {
	#clap_tokens
	#from_clap
	}

	#[allow(unused_variables)]
	#[allow(unknown_lints)]
	#[allow(
	clippy::style,
	clippy::complexity,
	clippy::pedantic,
	clippy::restriction,
	clippy::perf,
	clippy::deprecated,
	clippy::nursery,
	clippy::cargo
	)]
	#[deny(clippy::correctness)]
	#[allow(dead_code, unreachable_code)]
	impl ::structopt::StructOptInternal for #name {
	#augment_clap
	fn is_subcommand() -> bool { false }
	}

	#paw_impl
	}
	}

	fn impl_structopt_for_enum(
	name: &Ident,
	variants: &Punctuated<Variant, Comma>,
	attrs: &[Attribute],
	) -> TokenStream {
	let basic_clap_app_gen = gen_clap_enum(attrs);
	let clap_tokens = basic_clap_app_gen.tokens;
	let attrs = basic_clap_app_gen.attrs;

	let augment_clap = gen_augment_clap_enum(variants, &attrs);
	let from_clap = gen_from_clap_enum(name);
	let from_subcommand = gen_from_subcommand(name, variants, &attrs);
	let paw_impl = gen_paw_impl(name);

	quote! {
	#[allow(unknown_lints)]
	#[allow(unused_variables, dead_code, unreachable_code)]
	#[allow(
	clippy::style,
	clippy::complexity,
	clippy::pedantic,
	clippy::restriction,
	clippy::perf,
	clippy::deprecated,
	clippy::nursery,
	clippy::cargo
	)]
	#[deny(clippy::correctness)]
	impl ::structopt::StructOpt for #name {
	#clap_tokens
	#from_clap
	}

	#[allow(unused_variables)]
	#[allow(unknown_lints)]
	#[allow(
	clippy::style,
	clippy::complexity,
	clippy::pedantic,
	clippy::restriction,
	clippy::perf,
	clippy::deprecated,
	clippy::nursery,
	clippy::cargo
	)]
	#[deny(clippy::correctness)]
	#[allow(dead_code, unreachable_code)]
	impl ::structopt::StructOptInternal for #name {
	#augment_clap
	#from_subcommand
	fn is_subcommand() -> bool { true }
	}

	#paw_impl
	}
	}

	fn impl_structopt(input: &DeriveInput) -> TokenStream {
	use syn::Data::*;

	let struct_name = &input.ident;

	set_dummy(quote! {
	impl ::structopt::StructOpt for #struct_name {
	fn clap<'a, 'b>() -> ::structopt::clap::App<'a, 'b> {
	unimplemented!()
	}
	fn from_clap(_matches: &::structopt::clap::ArgMatches) -> Self {
	unimplemented!()
	}
	}

	impl ::structopt::StructOptInternal for #struct_name {}
	});

	match input.data {
	Struct(DataStruct {
	fields: syn::Fields::Named(ref fields),
	..
	}) => impl_structopt_for_struct(struct_name, &fields.named, &input.attrs),
	Enum(ref e) => impl_structopt_for_enum(struct_name, &e.variants, &input.attrs),
	_ => abort_call_site!("structopt only supports non-tuple structs and enums"),
	}
	}