Merge pull request #2593 from epage/skip

feat(derive): Allow skipping ArgEnum variants

Author: pksunkara

clap_derive/src/attrs.rs

@@ -561,6 +561,40 @@ impl Attrs {
         res
     }
 
+    pub fn from_arg_enum_variant(
+        variant: &Variant,
+        argument_casing: Sp<CasingStyle>,
+        env_casing: Sp<CasingStyle>,
+    ) -> Self {
+        let mut res = Self::new(
+            variant.span(),
+            Name::Derived(variant.ident.clone()),
+            None,
+            argument_casing,
+            env_casing,
+        );
+        res.push_attrs(&variant.attrs);
+        res.push_doc_comment(&variant.attrs, "about");
+
+        if res.has_custom_parser {
+            abort!(
+                res.parser.span(),
+                "`parse` attribute is only allowed on fields"
+            );
+        }
+        match &*res.kind {
+            Kind::Subcommand(_) => abort!(res.kind.span(), "subcommand is only allowed on fields"),
+            Kind::Skip(_) => res,
+            Kind::Arg(_) => res,
+            Kind::FromGlobal(_) => abort!(res.kind.span(), "from_global is only allowed on fields"),
+            Kind::Flatten => abort!(res.kind.span(), "flatten is only allowed on fields"),
+            Kind::ExternalSubcommand => abort!(
+                res.kind.span(),
+                "external_subcommand is only allowed on fields"
+            ),
+        }
+    }
+
     pub fn from_field(
         field: &Field,
         struct_casing: Sp<CasingStyle>,

clap_derive/src/derives/arg_enum.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use crate::{
-    attrs::{Attrs, Name, DEFAULT_CASING, DEFAULT_ENV_CASING},
+    attrs::{Attrs, Kind, Name, DEFAULT_CASING, DEFAULT_ENV_CASING},
     dummies,
     utils::Sp,
 };
@@ -18,8 +18,8 @@ use proc_macro2::{Span, TokenStream};
 use proc_macro_error::abort_call_site;
 use quote::quote;
 use syn::{
-    punctuated::Punctuated, spanned::Spanned, token::Comma, Attribute, Data, DataEnum, DeriveInput,
-    Fields, Ident, Variant,
+    punctuated::Punctuated, token::Comma, Attribute, Data, DataEnum, DeriveInput, Fields, Ident,
+    Variant,
 };
 
 pub fn derive_arg_enum(input: &DeriveInput) -> TokenStream {
@@ -76,15 +76,19 @@ fn lits(
 ) -> Vec<(TokenStream, Ident)> {
     variants
         .iter()
-        .flat_map(|variant| {
-            let attrs = Attrs::from_struct(
-                variant.span(),
-                &variant.attrs,
-                Name::Derived(variant.ident.clone()),
+        .filter_map(|variant| {
+            let attrs = Attrs::from_arg_enum_variant(
+                variant,
                 parent_attribute.casing(),
                 parent_attribute.env_casing(),
             );
-
+            if let Kind::Skip(_) = &*attrs.kind() {
+                None
+            } else {
+                Some((variant, attrs))
+            }
+        })
+        .flat_map(|(variant, attrs)| {
             let mut ret = vec![(attrs.cased_name(), variant.ident.clone())];
 
             attrs

clap_derive/tests/arg_enum.rs

@@ -310,6 +310,23 @@ fn vector() {
     assert!(Opt::try_parse_from(&["", "-a", "fOo"]).is_err());
 }
 
+#[test]
+fn skip_variant() {
+    #[derive(ArgEnum, PartialEq, Debug)]
+    #[allow(dead_code)] // silence warning about `Baz` being unused
+    enum ArgChoice {
+        Foo,
+        Bar,
+        #[clap(skip)]
+        Baz,
+    }
+
+    assert_eq!(ArgChoice::VARIANTS, ["foo", "bar"]);
+    assert!(ArgChoice::from_str("foo", true).is_ok());
+    assert!(ArgChoice::from_str("bar", true).is_ok());
+    assert!(ArgChoice::from_str("baz", true).is_err());
+}
+
 #[test]
 fn from_str_invalid() {
     #[derive(ArgEnum, PartialEq, Debug)]