Merge pull request #961 from dtolnay/hidden

Do nonexhaustive detection based on doc(hidden) attribute

Author: dtolnay

codegen/src/parse.rs

@@ -17,7 +17,6 @@ const SYN_CRATE_ROOT: &str = "../src/lib.rs";
 const TOKEN_SRC: &str = "../src/token.rs";
 const IGNORED_MODS: &[&str] = &["fold", "visit", "visit_mut"];
 const EXTRA_TYPES: &[&str] = &["Lifetime"];
-const NONEXHAUSTIVE: &str = "__Nonexhaustive";
 
 // NOTE: BTreeMap is used here instead of HashMap to have deterministic output.
 type ItemLookup = BTreeMap<Ident, AstItem>;
@@ -63,7 +62,7 @@ fn introspect_item(item: &AstItem, items: &ItemLookup, tokens: &TokenLookup) ->
             ident: item.ast.ident.to_string(),
             features,
             data: types::Data::Enum(introspect_enum(data, items, tokens)),
-            exhaustive: data.variants.iter().all(|v| v.ident != NONEXHAUSTIVE),
+            exhaustive: !data.variants.iter().any(|v| is_doc_hidden(&v.attrs)),
         },
         Data::Struct(ref data) => types::Node {
             ident: item.ast.ident.to_string(),
@@ -85,7 +84,7 @@ fn introspect_enum(item: &DataEnum, items: &ItemLookup, tokens: &TokenLookup) ->
     item.variants
         .iter()
         .filter_map(|variant| {
-            if variant.ident == NONEXHAUSTIVE {
+            if is_doc_hidden(&variant.attrs) {
                 return None;
             }
             let fields = match &variant.fields {
@@ -215,6 +214,20 @@ fn is_pub(vis: &Visibility) -> bool {
     }
 }
 
+fn is_doc_hidden(attrs: &[Attribute]) -> bool {
+    for attr in attrs {
+        if attr.path.is_ident("doc") {
+            if parsing::parse_doc_hidden_attr
+                .parse2(attr.tokens.clone())
+                .is_ok()
+            {
+                return true;
+            }
+        }
+    }
+    false
+}
+
 fn first_arg(params: &PathArguments) -> &syn::Type {
     let data = match *params {
         PathArguments::AngleBracketed(ref data) => data,
@@ -331,11 +344,12 @@ mod parsing {
 
     // A single variant of an ast_enum_of_structs!
     struct EosVariant {
+        attrs: Vec<Attribute>,
         name: Ident,
         member: Option<Path>,
     }
     fn eos_variant(input: ParseStream) -> Result<EosVariant> {
-        input.call(Attribute::parse_outer)?;
+        let attrs = input.call(Attribute::parse_outer)?;
         let variant: Ident = input.parse()?;
         let member = if input.peek(token::Paren) {
             let content;
@@ -347,6 +361,7 @@ mod parsing {
         };
         input.parse::<Token![,]>()?;
         Ok(EosVariant {
+            attrs,
             name: variant,
             member,
         })
@@ -371,10 +386,11 @@ mod parsing {
 
         let enum_item = {
             let variants = variants.iter().map(|v| {
-                let name = v.name.clone();
+                let attrs = &v.attrs;
+                let name = &v.name;
                 match v.member {
-                    Some(ref member) => quote!(#name(#member)),
-                    None => quote!(#name),
+                    Some(ref member) => quote!(#(#attrs)* #name(#member)),
+                    None => quote!(#(#attrs)* #name),
                 }
             });
             parse_quote! {
@@ -390,6 +406,7 @@ mod parsing {
     }
 
     mod kw {
+        syn::custom_keyword!(hidden);
         syn::custom_keyword!(macro_rules);
         syn::custom_keyword!(Token);
     }
@@ -489,6 +506,13 @@ mod parsing {
         }
         Ok(None)
     }
+
+    pub fn parse_doc_hidden_attr(input: ParseStream) -> Result<()> {
+        let content;
+        parenthesized!(content in input);
+        content.parse::<kw::hidden>()?;
+        Ok(())
+    }
 }
 
 fn clone_features(features: &[Attribute]) -> Vec<Attribute> {