diff options
Diffstat (limited to 'vendor/clap_derive/src/derives/args.rs')
-rw-r--r-- | vendor/clap_derive/src/derives/args.rs | 801 |
1 files changed, 370 insertions, 431 deletions
diff --git a/vendor/clap_derive/src/derives/args.rs b/vendor/clap_derive/src/derives/args.rs index 4195a0810..b5d51bfca 100644 --- a/vendor/clap_derive/src/derives/args.rs +++ b/vendor/clap_derive/src/derives/args.rs @@ -12,20 +12,19 @@ // commit#ea76fa1b1b273e65e3b0b1046643715b49bec51f which is licensed under the // MIT/Apache 2.0 license. -use crate::{ - attrs::{Attrs, Kind, Name, ParserKind, DEFAULT_CASING, DEFAULT_ENV_CASING}, - dummies, - utils::{inner_type, is_simple_ty, sub_type, Sp, Ty}, -}; - use proc_macro2::{Ident, Span, TokenStream}; use proc_macro_error::{abort, abort_call_site}; use quote::{format_ident, quote, quote_spanned}; +use syn::ext::IdentExt; use syn::{ - punctuated::Punctuated, spanned::Spanned, token::Comma, Attribute, Data, DataStruct, - DeriveInput, Field, Fields, Generics, Type, + punctuated::Punctuated, spanned::Spanned, token::Comma, Data, DataStruct, DeriveInput, Field, + Fields, Generics, }; +use crate::dummies; +use crate::item::{Item, Kind, Name}; +use crate::utils::{inner_type, sub_type, Sp, Ty}; + pub fn derive_args(input: &DeriveInput) -> TokenStream { let ident = &input.ident; @@ -35,87 +34,68 @@ pub fn derive_args(input: &DeriveInput) -> TokenStream { Data::Struct(DataStruct { fields: Fields::Named(ref fields), .. - }) => gen_for_struct(ident, &input.generics, &fields.named, &input.attrs), + }) => { + let name = Name::Derived(ident.clone()); + let item = Item::from_args_struct(input, name); + let fields = fields + .named + .iter() + .map(|field| { + let item = Item::from_args_field(field, item.casing(), item.env_casing()); + (field, item) + }) + .collect::<Vec<_>>(); + gen_for_struct(&item, ident, &input.generics, &fields) + } Data::Struct(DataStruct { fields: Fields::Unit, .. - }) => gen_for_struct( - ident, - &input.generics, - &Punctuated::<Field, Comma>::new(), - &input.attrs, - ), + }) => { + let name = Name::Derived(ident.clone()); + let item = Item::from_args_struct(input, name); + let fields = Punctuated::<Field, Comma>::new(); + let fields = fields + .iter() + .map(|field| { + let item = Item::from_args_field(field, item.casing(), item.env_casing()); + (field, item) + }) + .collect::<Vec<_>>(); + gen_for_struct(&item, ident, &input.generics, &fields) + } _ => abort_call_site!("`#[derive(Args)]` only supports non-tuple structs"), } } pub fn gen_for_struct( - struct_name: &Ident, + item: &Item, + item_name: &Ident, generics: &Generics, - fields: &Punctuated<Field, Comma>, - attrs: &[Attribute], + fields: &[(&Field, Item)], ) -> TokenStream { - let from_arg_matches = gen_from_arg_matches_for_struct(struct_name, generics, fields, attrs); - - let attrs = Attrs::from_struct( - Span::call_site(), - attrs, - Name::Derived(struct_name.clone()), - Sp::call_site(DEFAULT_CASING), - Sp::call_site(DEFAULT_ENV_CASING), - ); - let app_var = Ident::new("__clap_app", Span::call_site()); - let augmentation = gen_augment(fields, &app_var, &attrs, false); - let augmentation_update = gen_augment(fields, &app_var, &attrs, true); - - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); - - quote! { - #from_arg_matches - - #[allow(dead_code, unreachable_code, unused_variables, unused_braces)] - #[allow( - clippy::style, - clippy::complexity, - clippy::pedantic, - clippy::restriction, - clippy::perf, - clippy::deprecated, - clippy::nursery, - clippy::cargo, - clippy::suspicious_else_formatting, - )] - #[deny(clippy::correctness)] - impl #impl_generics clap::Args for #struct_name #ty_generics #where_clause { - fn augment_args<'b>(#app_var: clap::Command<'b>) -> clap::Command<'b> { - #augmentation - } - fn augment_args_for_update<'b>(#app_var: clap::Command<'b>) -> clap::Command<'b> { - #augmentation_update - } + if !matches!(&*item.kind(), Kind::Command(_)) { + abort! { item.kind().span(), + "`{}` cannot be used with `command`", + item.kind().name(), } } -} -pub fn gen_from_arg_matches_for_struct( - struct_name: &Ident, - generics: &Generics, - fields: &Punctuated<Field, Comma>, - attrs: &[Attribute], -) -> TokenStream { - let attrs = Attrs::from_struct( - Span::call_site(), - attrs, - Name::Derived(struct_name.clone()), - Sp::call_site(DEFAULT_CASING), - Sp::call_site(DEFAULT_ENV_CASING), - ); - - let constructor = gen_constructor(fields, &attrs); - let updater = gen_updater(fields, &attrs, true); + let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); + + let constructor = gen_constructor(fields); + let updater = gen_updater(fields, true); let raw_deprecated = raw_deprecated(); - let (impl_generics, ty_generics, where_clause) = generics.split_for_impl(); + let app_var = Ident::new("__clap_app", Span::call_site()); + let augmentation = gen_augment(fields, &app_var, item, false); + let augmentation_update = gen_augment(fields, &app_var, item, true); + + let group_id = if item.skip_group() { + quote!(None) + } else { + let group_id = item.ident().unraw().to_string(); + quote!(Some(clap::Id::from(#group_id))) + }; quote! { #[allow(dead_code, unreachable_code, unused_variables, unused_braces)] @@ -131,14 +111,14 @@ pub fn gen_from_arg_matches_for_struct( clippy::suspicious_else_formatting, )] #[deny(clippy::correctness)] - impl #impl_generics clap::FromArgMatches for #struct_name #ty_generics #where_clause { + impl #impl_generics clap::FromArgMatches for #item_name #ty_generics #where_clause { fn from_arg_matches(__clap_arg_matches: &clap::ArgMatches) -> ::std::result::Result<Self, clap::Error> { Self::from_arg_matches_mut(&mut __clap_arg_matches.clone()) } fn from_arg_matches_mut(__clap_arg_matches: &mut clap::ArgMatches) -> ::std::result::Result<Self, clap::Error> { #raw_deprecated - let v = #struct_name #constructor; + let v = #item_name #constructor; ::std::result::Result::Ok(v) } @@ -152,229 +132,149 @@ pub fn gen_from_arg_matches_for_struct( ::std::result::Result::Ok(()) } } + + #[allow(dead_code, unreachable_code, unused_variables, unused_braces)] + #[allow( + clippy::style, + clippy::complexity, + clippy::pedantic, + clippy::restriction, + clippy::perf, + clippy::deprecated, + clippy::nursery, + clippy::cargo, + clippy::suspicious_else_formatting, + )] + #[deny(clippy::correctness)] + impl #impl_generics clap::Args for #item_name #ty_generics #where_clause { + fn group_id() -> Option<clap::Id> { + #group_id + } + fn augment_args<'b>(#app_var: clap::Command) -> clap::Command { + #augmentation + } + fn augment_args_for_update<'b>(#app_var: clap::Command) -> clap::Command { + #augmentation_update + } + } } } /// Generate a block of code to add arguments/subcommands corresponding to /// the `fields` to an cmd. pub fn gen_augment( - fields: &Punctuated<Field, Comma>, + fields: &[(&Field, Item)], app_var: &Ident, - parent_attribute: &Attrs, + parent_item: &Item, override_required: bool, ) -> TokenStream { - let mut subcmds = fields.iter().filter_map(|field| { - let attrs = Attrs::from_field( - field, - 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()=> - #[allow(deprecated)] - let #app_var = #app_var.setting( - clap::AppSettings::SubcommandRequiredElseHelp - ); + let mut subcommand_specified = false; + let args = fields.iter().filter_map(|(field, item)| { + let kind = item.kind(); + match &*kind { + Kind::Command(_) + | Kind::Value + | Kind::Skip(_, _) + | Kind::FromGlobal(_) + | Kind::ExternalSubcommand => None, + Kind::Subcommand(ty) => { + if subcommand_specified { + abort!(field.span(), "`#[command(subcommand)]` can only be used once per container"); } - }; + subcommand_specified = true; - let span = field.span(); - let ts = if override_required { - quote! { - let #app_var = <#subcmd_type as clap::Subcommand>::augment_subcommands_for_update( #app_var ); - } - } else{ - quote! { + let subcmd_type = match (**ty, sub_type(&field.ty)) { + (Ty::Option, Some(sub_type)) => sub_type, + _ => &field.ty, + }; + let implicit_methods = if **ty == Ty::Option { + quote!() + } else { + quote_spanned! { kind.span()=> + .subcommand_required(true) + .arg_required_else_help(true) + } + }; + + let override_methods = if override_required { + quote_spanned! { kind.span()=> + .subcommand_required(false) + .arg_required_else_help(false) + } + } else { + quote!() + }; + + Some(quote! { let #app_var = <#subcmd_type as clap::Subcommand>::augment_subcommands( #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 #app_var = #app_var + #implicit_methods + #override_methods; + }) + } + Kind::Flatten(ty) => { + let inner_type = match (**ty, sub_type(&field.ty)) { + (Ty::Option, Some(sub_type)) => sub_type, + _ => &field.ty, + }; - let args = fields.iter().filter_map(|field| { - let attrs = Attrs::from_field( - field, - parent_attribute.casing(), - parent_attribute.env_casing(), - ); - let kind = attrs.kind(); - match &*kind { - Kind::Subcommand(_) - | Kind::Skip(_) - | Kind::FromGlobal(_) - | Kind::ExternalSubcommand => None, - Kind::Flatten => { - let ty = &field.ty; - let old_heading_var = format_ident!("__clap_old_heading"); - let next_help_heading = attrs.next_help_heading(); - let next_display_order = attrs.next_display_order(); + let next_help_heading = item.next_help_heading(); + let next_display_order = item.next_display_order(); if override_required { Some(quote_spanned! { kind.span()=> - let #old_heading_var = #app_var.get_next_help_heading(); - let #app_var = #app_var #next_help_heading #next_display_order; - let #app_var = <#ty as clap::Args>::augment_args_for_update(#app_var); - let #app_var = #app_var.next_help_heading(#old_heading_var); + let #app_var = #app_var + #next_help_heading + #next_display_order; + let #app_var = <#inner_type as clap::Args>::augment_args_for_update(#app_var); }) } else { Some(quote_spanned! { kind.span()=> - let #old_heading_var = #app_var.get_next_help_heading(); - let #app_var = #app_var #next_help_heading #next_display_order; - let #app_var = <#ty as clap::Args>::augment_args(#app_var); - let #app_var = #app_var.next_help_heading(#old_heading_var); + let #app_var = #app_var + #next_help_heading + #next_display_order; + let #app_var = <#inner_type as clap::Args>::augment_args(#app_var); }) } } Kind::Arg(ty) => { - let convert_type = inner_type(&field.ty); - - let parser = attrs.parser(&field.ty); - - let value_parser = attrs.value_parser(&field.ty); - let action = attrs.action(&field.ty); - let func = &parser.func; - - let mut occurrences = false; - let mut flag = false; - let validator = match *parser.kind { - _ if attrs.ignore_parser() || attrs.is_enum() => quote!(), - ParserKind::TryFromStr => quote_spanned! { func.span()=> - .validator(|s| { - #func(s) - .map(|_: #convert_type| ()) - }) - }, - ParserKind::TryFromOsStr => quote_spanned! { func.span()=> - .validator_os(|s| #func(s).map(|_: #convert_type| ())) - }, - ParserKind::FromStr | ParserKind::FromOsStr => quote!(), - ParserKind::FromFlag => { - flag = true; - quote!() - } - ParserKind::FromOccurrences => { - occurrences = true; - quote!() - } - }; - let parse_deprecation = match *parser.kind { - _ if !attrs.explicit_parser() || cfg!(not(feature = "deprecated")) => quote!(), - ParserKind::FromStr => quote_spanned! { func.span()=> - #[deprecated(since = "3.2.0", note = "Replaced with `#[clap(value_parser = ...)]`")] - fn parse_from_str() { - } - parse_from_str(); - }, - ParserKind::TryFromStr => quote_spanned! { func.span()=> - #[deprecated(since = "3.2.0", note = "Replaced with `#[clap(value_parser = ...)]`")] - fn parse_try_from_str() { - } - parse_try_from_str(); - }, - ParserKind::FromOsStr => quote_spanned! { func.span()=> - #[deprecated(since = "3.2.0", note = "Replaced with `#[clap(value_parser)]` for `PathBuf` or `#[clap(value_parser = ...)]` with a custom `TypedValueParser`")] - fn parse_from_os_str() { - } - parse_from_os_str(); - }, - ParserKind::TryFromOsStr => quote_spanned! { func.span()=> - #[deprecated(since = "3.2.0", note = "Replaced with `#[clap(value_parser = ...)]` with a custom `TypedValueParser`")] - fn parse_try_from_os_str() { - } - parse_try_from_os_str(); - }, - ParserKind::FromFlag => quote_spanned! { func.span()=> - #[deprecated(since = "3.2.0", note = "Replaced with `#[clap(action = ArgAction::SetTrue)]`")] - fn parse_from_flag() { - } - parse_from_flag(); - }, - ParserKind::FromOccurrences => quote_spanned! { func.span()=> - #[deprecated(since = "3.2.0", note = "Replaced with `#[clap(action = ArgAction::Count)]` with a field type of `u8`")] - fn parse_from_occurrences() { - } - parse_from_occurrences(); - }, - }; - - let value_name = attrs.value_name(); - let possible_values = if attrs.is_enum() && !attrs.ignore_parser() { - gen_value_enum_possible_values(convert_type) - } else { - quote!() - }; + let value_parser = item.value_parser(&field.ty); + let action = item.action(&field.ty); + let value_name = item.value_name(); let implicit_methods = match **ty { + Ty::Unit => { + // Leaving out `value_parser` as it will always fail + quote_spanned! { ty.span()=> + .value_name(#value_name) + #action + } + } Ty::Option => { quote_spanned! { ty.span()=> - .takes_value(true) .value_name(#value_name) - #possible_values - #validator #value_parser #action } } Ty::OptionOption => quote_spanned! { ty.span()=> - .takes_value(true) .value_name(#value_name) - .min_values(0) - .max_values(1) - .multiple_values(false) - #possible_values - #validator + .num_args(0..=1) #value_parser #action }, Ty::OptionVec => { - if attrs.ignore_parser() { - if attrs.is_positional() { - quote_spanned! { ty.span()=> - .takes_value(true) - .value_name(#value_name) - .multiple_values(true) // action won't be sufficient for getting multiple - #possible_values - #validator - #value_parser - #action - } - } else { - quote_spanned! { ty.span()=> - .takes_value(true) - .value_name(#value_name) - #possible_values - #validator - #value_parser - #action - } + if item.is_positional() { + quote_spanned! { ty.span()=> + .value_name(#value_name) + .num_args(1..) // action won't be sufficient for getting multiple + #value_parser + #action } } else { quote_spanned! { ty.span()=> - .takes_value(true) .value_name(#value_name) - .multiple_occurrences(true) - #possible_values - #validator #value_parser #action } @@ -382,72 +282,63 @@ pub fn gen_augment( } Ty::Vec => { - if attrs.ignore_parser() { - if attrs.is_positional() { - quote_spanned! { ty.span()=> - .takes_value(true) - .value_name(#value_name) - .multiple_values(true) // action won't be sufficient for getting multiple - #possible_values - #validator - #value_parser - #action - } - } else { - quote_spanned! { ty.span()=> - .takes_value(true) - .value_name(#value_name) - #possible_values - #validator - #value_parser - #action - } + if item.is_positional() { + quote_spanned! { ty.span()=> + .value_name(#value_name) + .num_args(1..) // action won't be sufficient for getting multiple + #value_parser + #action } } else { quote_spanned! { ty.span()=> - .takes_value(true) .value_name(#value_name) - .multiple_occurrences(true) - #possible_values - #validator #value_parser #action } } } - Ty::Other if occurrences => quote_spanned! { ty.span()=> - .multiple_occurrences(true) - }, - - Ty::Other if flag => quote_spanned! { ty.span()=> - .takes_value(false) - }, + Ty::VecVec | Ty::OptionVecVec => { + quote_spanned! { ty.span() => + .value_name(#value_name) + #value_parser + #action + } + } Ty::Other => { - let required = attrs.find_default_method().is_none() && !override_required; + let required = item.find_default_method().is_none(); // `ArgAction::takes_values` is assuming `ArgAction::default_value` will be // set though that won't always be true but this should be good enough, // otherwise we'll report an "arg required" error when unwrapping. let action_value = action.args(); quote_spanned! { ty.span()=> - .takes_value(true) .value_name(#value_name) .required(#required && #action_value.takes_values()) - #possible_values - #validator #value_parser #action } } }; - let id = attrs.id(); - let explicit_methods = attrs.field_methods(true); + let id = item.id(); + let explicit_methods = item.field_methods(); + let deprecations = if !override_required { + item.deprecations() + } else { + quote!() + }; + let override_methods = if override_required { + quote_spanned! { kind.span()=> + .required(false) + } + } else { + quote!() + }; Some(quote_spanned! { field.span()=> let #app_var = #app_var.arg({ - #parse_deprecation + #deprecations #[allow(deprecated)] let arg = clap::Arg::new(#id) @@ -455,6 +346,10 @@ pub fn gen_augment( let arg = arg #explicit_methods; + + let arg = arg + #override_methods; + arg }); }) @@ -462,36 +357,80 @@ pub fn gen_augment( } }); - let initial_app_methods = parent_attribute.initial_top_level_methods(); - let final_app_methods = parent_attribute.final_top_level_methods(); + let deprecations = if !override_required { + parent_item.deprecations() + } else { + quote!() + }; + let initial_app_methods = parent_item.initial_top_level_methods(); + let final_app_methods = parent_item.final_top_level_methods(); + let group_app_methods = if parent_item.skip_group() { + quote!() + } else { + let group_id = parent_item.ident().unraw().to_string(); + let literal_group_members = fields + .iter() + .filter_map(|(_field, item)| { + let kind = item.kind(); + if matches!(*kind, Kind::Arg(_)) { + Some(item.id()) + } else { + None + } + }) + .collect::<Vec<_>>(); + let literal_group_members_len = literal_group_members.len(); + let mut literal_group_members = quote! {{ + let members: [clap::Id; #literal_group_members_len] = [#( clap::Id::from(#literal_group_members) ),* ]; + members + }}; + // HACK: Validation isn't ready yet for nested arg groups, so just don't populate the group in + // that situation + let possible_group_members_len = fields + .iter() + .filter(|(_field, item)| { + let kind = item.kind(); + matches!(*kind, Kind::Flatten(_)) + }) + .count(); + if 0 < possible_group_members_len { + literal_group_members = quote! {{ + let members: [clap::Id; 0] = []; + members + }}; + } + + quote!( + .group( + clap::ArgGroup::new(#group_id) + .multiple(true) + .args(#literal_group_members) + ) + ) + }; quote! {{ - let #app_var = #app_var #initial_app_methods; + #deprecations + let #app_var = #app_var + #initial_app_methods + #group_app_methods + ; #( #args )* - #subcmd #app_var #final_app_methods }} } -fn gen_value_enum_possible_values(ty: &Type) -> TokenStream { - quote_spanned! { ty.span()=> - .possible_values(<#ty as clap::ValueEnum>::value_variants().iter().filter_map(clap::ValueEnum::to_possible_value)) - } -} - -pub fn gen_constructor(fields: &Punctuated<Field, Comma>, parent_attribute: &Attrs) -> TokenStream { - let fields = fields.iter().map(|field| { - let attrs = Attrs::from_field( - field, - parent_attribute.casing(), - parent_attribute.env_casing(), - ); +pub fn gen_constructor(fields: &[(&Field, Item)]) -> TokenStream { + let fields = fields.iter().map(|(field, item)| { let field_name = field.ident.as_ref().unwrap(); - let kind = attrs.kind(); + let kind = item.kind(); let arg_matches = format_ident!("__clap_arg_matches"); match &*kind { - Kind::ExternalSubcommand => { + Kind::Command(_) + | Kind::Value + | Kind::ExternalSubcommand => { abort! { kind.span(), - "`external_subcommand` can be used only on enum variants" + "`{}` cannot be used with `arg`", + kind.name(), } } Kind::Subcommand(ty) => { @@ -511,27 +450,76 @@ pub fn gen_constructor(fields: &Punctuated<Field, Comma>, parent_attribute: &Att } } }, - _ => { + Ty::Other => { quote_spanned! { kind.span()=> #field_name: { <#subcmd_type as clap::FromArgMatches>::from_arg_matches_mut(#arg_matches)? } } }, + Ty::Unit | + Ty::Vec | + Ty::OptionOption | + Ty::OptionVec | + Ty::VecVec | + Ty::OptionVecVec => { + abort!( + ty.span(), + "{} types are not supported for subcommand", + ty.as_str() + ); + } } } - Kind::Flatten => quote_spanned! { kind.span()=> - #field_name: clap::FromArgMatches::from_arg_matches_mut(#arg_matches)? + Kind::Flatten(ty) => { + let inner_type = match (**ty, sub_type(&field.ty)) { + (Ty::Option, Some(sub_type)) => sub_type, + _ => &field.ty, + }; + match **ty { + Ty::Other => { + quote_spanned! { kind.span()=> + #field_name: <#inner_type as clap::FromArgMatches>::from_arg_matches_mut(#arg_matches)? + } + }, + Ty::Option => { + quote_spanned! { kind.span()=> + #field_name: { + let group_id = <#inner_type as clap::Args>::group_id() + .expect("`#[arg(flatten)]`ed field type implements `Args::group_id`"); + if #arg_matches.contains_id(group_id.as_str()) { + Some( + <#inner_type as clap::FromArgMatches>::from_arg_matches_mut(#arg_matches)? + ) + } else { + None + } + } + } + }, + Ty::Unit | + Ty::Vec | + Ty::OptionOption | + Ty::OptionVec | + Ty::VecVec | + Ty::OptionVecVec => { + abort!( + ty.span(), + "{} types are not supported for flatten", + ty.as_str() + ); + } + } }, - Kind::Skip(val) => match val { + 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) | Kind::FromGlobal(ty) => { - gen_parsers(&attrs, ty, field_name, field, None) + gen_parsers(item, ty, field_name, field, None) } } }); @@ -541,19 +529,10 @@ pub fn gen_constructor(fields: &Punctuated<Field, Comma>, parent_attribute: &Att }} } -pub fn gen_updater( - fields: &Punctuated<Field, Comma>, - parent_attribute: &Attrs, - use_self: bool, -) -> TokenStream { - let fields = fields.iter().map(|field| { - let attrs = Attrs::from_field( - field, - parent_attribute.casing(), - parent_attribute.env_casing(), - ); +pub fn gen_updater(fields: &[(&Field, Item)], use_self: bool) -> TokenStream { + let fields = fields.iter().map(|(field, item)| { let field_name = field.ident.as_ref().unwrap(); - let kind = attrs.kind(); + let kind = item.kind(); let access = if use_self { quote! { @@ -566,9 +545,12 @@ pub fn gen_updater( let arg_matches = format_ident!("__clap_arg_matches"); match &*kind { - Kind::ExternalSubcommand => { + Kind::Command(_) + | Kind::Value + | Kind::ExternalSubcommand => { abort! { kind.span(), - "`external_subcommand` can be used only on enum variants" + "`{}` cannot be used with `arg`", + kind.name(), } } Kind::Subcommand(ty) => { @@ -604,15 +586,42 @@ pub fn gen_updater( } } - Kind::Flatten => quote_spanned! { kind.span()=> { - #access - clap::FromArgMatches::update_from_arg_matches_mut(#field_name, #arg_matches)?; + Kind::Flatten(ty) => { + let inner_type = match (**ty, sub_type(&field.ty)) { + (Ty::Option, Some(sub_type)) => sub_type, + _ => &field.ty, + }; + + let updater = quote_spanned! { ty.span()=> + <#inner_type as clap::FromArgMatches>::update_from_arg_matches_mut(#field_name, #arg_matches)?; + }; + + let updater = match **ty { + Ty::Option => quote_spanned! { kind.span()=> + if let Some(#field_name) = #field_name.as_mut() { + #updater + } else { + *#field_name = Some(<#inner_type as clap::FromArgMatches>::from_arg_matches_mut( + #arg_matches + )?); + } + }, + _ => quote_spanned! { kind.span()=> + #updater + }, + }; + + quote_spanned! { kind.span()=> + { + #access + #updater + } } }, - Kind::Skip(_) => quote!(), + Kind::Skip(_, _) => quote!(), - Kind::Arg(ty) | Kind::FromGlobal(ty) => gen_parsers(&attrs, ty, field_name, field, Some(&access)), + Kind::Arg(ty) | Kind::FromGlobal(ty) => gen_parsers(item, ty, field_name, field, Some(&access)), } }); @@ -622,78 +631,18 @@ pub fn gen_updater( } fn gen_parsers( - attrs: &Attrs, + item: &Item, ty: &Sp<Ty>, field_name: &Ident, field: &Field, update: Option<&TokenStream>, ) -> TokenStream { - use self::ParserKind::*; - - let parser = attrs.parser(&field.ty); - let func = &parser.func; - let span = parser.kind.span(); + let span = ty.span(); let convert_type = inner_type(&field.ty); - let id = attrs.id(); - let mut flag = false; - let mut occurrences = false; - let (get_one, get_many, deref, mut parse) = match *parser.kind { - _ if attrs.ignore_parser() => ( - quote_spanned!(span=> remove_one::<#convert_type>), - quote_spanned!(span=> remove_many::<#convert_type>), - quote!(|s| s), - quote_spanned!(func.span()=> |s| ::std::result::Result::Ok::<_, clap::Error>(s)), - ), - FromOccurrences => { - occurrences = true; - ( - quote_spanned!(span=> occurrences_of), - quote!(), - quote!(|s| ::std::ops::Deref::deref(s)), - func.clone(), - ) - } - FromFlag => { - flag = true; - ( - quote!(), - quote!(), - quote!(|s| ::std::ops::Deref::deref(s)), - func.clone(), - ) - } - FromStr => ( - quote_spanned!(span=> get_one::<String>), - quote_spanned!(span=> get_many::<String>), - quote!(|s| ::std::ops::Deref::deref(s)), - quote_spanned!(func.span()=> |s| ::std::result::Result::Ok::<_, clap::Error>(#func(s))), - ), - TryFromStr => ( - quote_spanned!(span=> get_one::<String>), - quote_spanned!(span=> get_many::<String>), - quote!(|s| ::std::ops::Deref::deref(s)), - quote_spanned!(func.span()=> |s| #func(s).map_err(|err| clap::Error::raw(clap::ErrorKind::ValueValidation, format!("Invalid value for {}: {}", #id, err)))), - ), - FromOsStr => ( - quote_spanned!(span=> get_one::<::std::ffi::OsString>), - quote_spanned!(span=> get_many::<::std::ffi::OsString>), - quote!(|s| ::std::ops::Deref::deref(s)), - quote_spanned!(func.span()=> |s| ::std::result::Result::Ok::<_, clap::Error>(#func(s))), - ), - TryFromOsStr => ( - quote_spanned!(span=> get_one::<::std::ffi::OsString>), - quote_spanned!(span=> get_many::<::std::ffi::OsString>), - quote!(|s| ::std::ops::Deref::deref(s)), - quote_spanned!(func.span()=> |s| #func(s).map_err(|err| clap::Error::raw(clap::ErrorKind::ValueValidation, format!("Invalid value for {}: {}", #id, err)))), - ), - }; - if attrs.is_enum() && !attrs.ignore_parser() { - let ci = attrs.ignore_case(); - - parse = quote_spanned! { convert_type.span()=> - |s| <#convert_type as clap::ValueEnum>::from_str(s, #ci).map_err(|err| clap::Error::raw(clap::ErrorKind::ValueValidation, format!("Invalid value for {}: {}", #id, err))) - } - } + let id = item.id(); + let get_one = quote_spanned!(span=> remove_one::<#convert_type>); + let get_many = quote_spanned!(span=> remove_many::<#convert_type>); + let get_occurrences = quote_spanned!(span=> remove_occurrences::<#convert_type>); // Give this identifier the same hygiene // as the `arg_matches` parameter definition. This @@ -701,12 +650,15 @@ fn gen_parsers( let arg_matches = format_ident!("__clap_arg_matches"); let field_value = match **ty { + Ty::Unit => { + quote_spanned! { ty.span()=> + () + } + } + Ty::Option => { quote_spanned! { ty.span()=> #arg_matches.#get_one(#id) - .map(#deref) - .map(#parse) - .transpose()? } } @@ -714,8 +666,6 @@ fn gen_parsers( if #arg_matches.contains_id(#id) { Some( #arg_matches.#get_one(#id) - .map(#deref) - .map(#parse).transpose()? ) } else { None @@ -725,8 +675,7 @@ fn gen_parsers( Ty::OptionVec => quote_spanned! { ty.span()=> if #arg_matches.contains_id(#id) { Some(#arg_matches.#get_many(#id) - .map(|v| v.map(#deref).map::<::std::result::Result<#convert_type, clap::Error>, _>(#parse).collect::<::std::result::Result<Vec<_>, clap::Error>>()) - .transpose()? + .map(|v| v.collect::<Vec<_>>()) .unwrap_or_else(Vec::new)) } else { None @@ -736,36 +685,26 @@ fn gen_parsers( Ty::Vec => { quote_spanned! { ty.span()=> #arg_matches.#get_many(#id) - .map(|v| v.map(#deref).map::<::std::result::Result<#convert_type, clap::Error>, _>(#parse).collect::<::std::result::Result<Vec<_>, clap::Error>>()) - .transpose()? + .map(|v| v.collect::<Vec<_>>()) .unwrap_or_else(Vec::new) } } - Ty::Other if occurrences => quote_spanned! { ty.span()=> - #parse( - #arg_matches.#get_one(#id) - ) + Ty::VecVec => quote_spanned! { ty.span()=> + #arg_matches.#get_occurrences(#id) + .map(|g| g.map(::std::iter::Iterator::collect).collect::<Vec<Vec<_>>>()) + .unwrap_or_else(Vec::new) }, - Ty::Other if flag => { - if update.is_some() && is_simple_ty(&field.ty, "bool") { - quote_spanned! { ty.span()=> - *#field_name || #arg_matches.is_present(#id) - } - } else { - quote_spanned! { ty.span()=> - #parse(#arg_matches.is_present(#id)) - } - } - } + Ty::OptionVecVec => quote_spanned! { ty.span()=> + #arg_matches.#get_occurrences(#id) + .map(|g| g.map(::std::iter::Iterator::collect).collect::<Vec<Vec<_>>>()) + }, Ty::Other => { quote_spanned! { ty.span()=> #arg_matches.#get_one(#id) - .map(#deref) - .ok_or_else(|| clap::Error::raw(clap::ErrorKind::MissingRequiredArgument, format!("The following required argument was not provided: {}", #id))) - .and_then(#parse)? + .ok_or_else(|| clap::Error::raw(clap::error::ErrorKind::MissingRequiredArgument, format!("The following required argument was not provided: {}", #id)))? } } }; |