Create new Item::is_fake_item method as equivalent to check for is_primitive, is_keyword and is_attribute methods

Author: GuillaumeGomez

compiler/rustc_passes/src/check_attr.rs

@@ -99,6 +99,21 @@ impl IntoDiagArg for ProcMacroKind {
     }
 }
 
+#[derive(Clone, Copy)]
+enum DocFakeItemKind {
+    Attribute,
+    Keyword,
+}
+
+impl DocFakeItemKind {
+    fn name(self) -> &'static str {
+        match self {
+            Self::Attribute => "attribute",
+            Self::Keyword => "keyword",
+        }
+    }
+}
+
 struct CheckAttrVisitor<'tcx> {
     tcx: TyCtxt<'tcx>,
 
@@ -855,7 +870,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         &self,
         meta: &MetaItemInner,
         hir_id: HirId,
-        is_keyword: bool,
+        attr_kind: DocFakeItemKind,
     ) {
         fn is_doc_keyword(s: Symbol) -> bool {
             // FIXME: Once rustdoc can handle URL conflicts on case insensitive file systems, we
@@ -868,13 +883,9 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             rustc_feature::BUILTIN_ATTRIBUTE_MAP.contains_key(&s)
         }
 
-        fn get_attr_name(is_keyword: bool) -> &'static str {
-            if is_keyword { "keyword" } else { "attribute" }
-        }
-
         let value = match meta.value_str() {
             Some(value) if value != sym::empty => value,
-            _ => return self.doc_attr_str_error(meta, get_attr_name(is_keyword)),
+            _ => return self.doc_attr_str_error(meta, attr_kind.name()),
         };
 
         let item_kind = match self.tcx.hir_node(hir_id) {
@@ -886,31 +897,36 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 if !module.item_ids.is_empty() {
                     self.dcx().emit_err(errors::DocKeywordAttributeEmptyMod {
                         span: meta.span(),
-                        attr_name: get_attr_name(is_keyword),
+                        attr_name: attr_kind.name(),
                     });
                     return;
                 }
             }
             _ => {
                 self.dcx().emit_err(errors::DocKeywordAttributeNotMod {
                     span: meta.span(),
-                    attr_name: get_attr_name(is_keyword),
+                    attr_name: attr_kind.name(),
                 });
                 return;
             }
         }
-        if is_keyword {
-            if !is_doc_keyword(value) {
-                self.dcx().emit_err(errors::DocKeywordNotKeyword {
-                    span: meta.name_value_literal_span().unwrap_or_else(|| meta.span()),
-                    keyword: value,
-                });
+        match attr_kind {
+            DocFakeItemKind::Keyword => {
+                if !is_doc_keyword(value) {
+                    self.dcx().emit_err(errors::DocKeywordNotKeyword {
+                        span: meta.name_value_literal_span().unwrap_or_else(|| meta.span()),
+                        keyword: value,
+                    });
+                }
+            }
+            DocFakeItemKind::Attribute => {
+                if !is_builtin_attr(value) {
+                    self.dcx().emit_err(errors::DocAttributeNotAttribute {
+                        span: meta.name_value_literal_span().unwrap_or_else(|| meta.span()),
+                        attribute: value,
+                    });
+                }
             }
-        } else if !is_builtin_attr(value) {
-            self.dcx().emit_err(errors::DocAttributeNotAttribute {
-                span: meta.name_value_literal_span().unwrap_or_else(|| meta.span()),
-                attribute: value,
-            });
         }
     }
 
@@ -1170,13 +1186,21 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
 
                         Some(sym::keyword) => {
                             if self.check_attr_not_crate_level(meta, hir_id, "keyword") {
-                                self.check_doc_keyword_and_attribute(meta, hir_id, true);
+                                self.check_doc_keyword_and_attribute(
+                                    meta,
+                                    hir_id,
+                                    DocFakeItemKind::Keyword,
+                                );
                             }
                         }
 
                         Some(sym::attribute) => {
                             if self.check_attr_not_crate_level(meta, hir_id, "attribute") {
-                                self.check_doc_keyword_and_attribute(meta, hir_id, false);
+                                self.check_doc_keyword_and_attribute(
+                                    meta,
+                                    hir_id,
+                                    DocFakeItemKind::Attribute,
+                                );
                             }
                         }
 

src/librustdoc/clean/types.rs

@@ -608,6 +608,17 @@ impl Item {
     pub(crate) fn is_attribute(&self) -> bool {
         self.type_() == ItemType::Attribute
     }
+    /// Returns `true` if the item kind is one of the following:
+    ///
+    /// * `ItemType::Primitive`
+    /// * `ItemType::Keyword`
+    /// * `ItemType::Attribute`
+    ///
+    /// They are considered fake because they only exist thanks to their
+    /// `#[doc(primitive|keyword|attribute)]` attribute.
+    pub(crate) fn is_fake_item(&self) -> bool {
+        matches!(self.type_(), ItemType::Primitive | ItemType::Keyword | ItemType::Attribute)
+    }
     pub(crate) fn is_stripped(&self) -> bool {
         match self.kind {
             StrippedItem(..) => true,

src/librustdoc/html/render/context.rs

@@ -218,7 +218,7 @@ impl<'tcx> Context<'tcx> {
         } else {
             it.name.as_ref().unwrap().as_str()
         };
-        if !it.is_primitive() && !it.is_keyword() && !it.is_attribute() {
+        if !it.is_fake_item() {
             if !is_module {
                 title.push_str(" in ");
             }

src/librustdoc/html/render/print_item.rs

@@ -194,7 +194,7 @@ pub(super) fn print_item(cx: &Context<'_>, item: &clean::Item) -> impl fmt::Disp
         let src_href =
             if cx.info.include_sources && !item.is_primitive() { cx.src_href(item) } else { None };
 
-        let path_components = if item.is_primitive() || item.is_keyword() || item.is_attribute() {
+        let path_components = if item.is_fake_item() {
             vec![]
         } else {
             let cur = &cx.current;