summaryrefslogtreecommitdiffstats
path: root/vendor/clap_derive/src/derives/args.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/clap_derive/src/derives/args.rs')
-rw-r--r--vendor/clap_derive/src/derives/args.rs801
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)))?
}
}
};
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-24 21:54:12 +0000