Extra cfg_hide a bit to handle inner cfgs

src/librustdoc/clean/cfg.rs

@@ -8,6 +8,7 @@
 use std::ops;
 
 use rustc_ast::{LitKind, MetaItem, MetaItemKind, NestedMetaItem};
+use rustc_data_structures::fx::FxHashSet;
 use rustc_feature::Features;
 use rustc_session::parse::ParseSess;
 use rustc_span::symbol::{sym, Symbol};
@@ -45,7 +46,7 @@ impl Cfg {
     /// Parses a `NestedMetaItem` into a `Cfg`.
     fn parse_nested(
         nested_cfg: &NestedMetaItem,
-        exclude: &[Symbol],
+        exclude: &FxHashSet<Cfg>,
     ) -> Result<Option<Cfg>, InvalidCfgError> {
         match nested_cfg {
             NestedMetaItem::MetaItem(ref cfg) => Cfg::parse_without(cfg, exclude),
@@ -57,7 +58,7 @@ fn parse_nested(
 
     crate fn parse_without(
         cfg: &MetaItem,
-        exclude: &[Symbol],
+        exclude: &FxHashSet<Cfg>,
     ) -> Result<Option<Cfg>, InvalidCfgError> {
         let name = match cfg.ident() {
             Some(ident) => ident.name,
@@ -70,19 +71,13 @@ fn parse_nested(
         };
         match cfg.kind {
             MetaItemKind::Word => {
-                if exclude.contains(&name) {
-                    Ok(None)
-                } else {
-                    Ok(Some(Cfg::Cfg(name, None)))
-                }
+                let cfg = Cfg::Cfg(name, None);
+                if exclude.contains(&cfg) { Ok(None) } else { Ok(Some(cfg)) }
             }
             MetaItemKind::NameValue(ref lit) => match lit.kind {
                 LitKind::Str(value, _) => {
-                    if exclude.contains(&name) {
-                        Ok(None)
-                    } else {
-                        Ok(Some(Cfg::Cfg(name, Some(value))))
-                    }
+                    let cfg = Cfg::Cfg(name, Some(value));
+                    if exclude.contains(&cfg) { Ok(None) } else { Ok(Some(cfg)) }
                 }
                 _ => Err(InvalidCfgError {
                     // FIXME: if the main #[cfg] syntax decided to support non-string literals,
@@ -126,7 +121,7 @@ fn parse_nested(
     /// If the content is not properly formatted, it will return an error indicating what and where
     /// the error is.
     crate fn parse(cfg: &MetaItem) -> Result<Cfg, InvalidCfgError> {
-        Self::parse_without(cfg, &[]).map(|ret| ret.unwrap())
+        Self::parse_without(cfg, &FxHashSet::default()).map(|ret| ret.unwrap())
     }
 
     /// Checks whether the given configuration can be matched in the current session.

src/librustdoc/clean/types.rs

@@ -831,11 +831,10 @@ fn single<T: IntoIterator>(it: T) -> Option<T::Item> {
                 self.iter()
                     .filter(|attr| attr.has_name(sym::cfg))
                     .filter_map(|attr| single(attr.meta_item_list()?))
-                    .filter_map(|attr| match Cfg::parse_without(attr.meta_item()?, &[sym::test]) {
+                    .filter_map(|attr| match Cfg::parse_without(attr.meta_item()?, hidden_cfg) {
                         Ok(Some(c)) => Some(c),
                         _ => None,
                     })
-                    .filter(|cfg| !hidden_cfg.contains(cfg))
                     .fold(Cfg::True, |cfg, new_cfg| cfg & new_cfg)
             } else {
                 Cfg::True

src/librustdoc/visit_ast.rs

@@ -141,6 +141,7 @@ fn store_path(&mut self, did: DefId) {
                     })
                     .collect::<Vec<_>>()
             })
+            .chain([Cfg::Cfg(sym::test, None)].into_iter())
             .collect();
 
         self.cx.cache.exact_paths = self.exact_paths;

src/test/rustdoc/doc-cfg-hide.rs

@@ -26,7 +26,7 @@
 
 // @has 'oud/struct.Oystercatcher.html'
 // @count   - '//*[@class="stab portability"]' 1
-// @matches - '//*[@class="stab portability"]' 'crate features solecism and oystercatcher'
+// @matches - '//*[@class="stab portability"]' 'crate feature oystercatcher only'
 // compile-flags:--cfg feature="oystercatcher"
 #[cfg(all(feature = "solecism", feature = "oystercatcher"))]
 pub struct Oystercatcher;