Correctly handle doc items inlining

Author: GuillaumeGomez

src/librustdoc/clean/mod.rs

@@ -196,9 +196,12 @@ fn generate_item_with_correct_attrs(
             // For glob re-exports the item may or may not exist to be re-exported (potentially the
             // cfgs on the path up until the glob can be removed, and only cfgs on the globbed item
             // itself matter), for non-inlined re-exports see #85043.
-            let import_is_inline = find_attr!(inline::load_attrs(cx, import_id.to_def_id()), AttributeKind::Doc(d) if d.inline.is_some())
-                || (is_glob_import(cx.tcx, import_id)
-                    && (cx.document_hidden() || !cx.tcx.is_doc_hidden(def_id)));
+            let import_is_inline = find_attr!(
+                inline::load_attrs(cx, import_id.to_def_id()),
+                AttributeKind::Doc(d)
+                if d.inline.is_some_and(|(inline, _)| inline == DocInline::Inline)
+            ) || (is_glob_import(cx.tcx, import_id)
+                && (cx.document_hidden() || !cx.tcx.is_doc_hidden(def_id)));
             attrs.extend(get_all_import_attributes(cx, import_id, def_id, is_inline));
             is_inline = is_inline || import_is_inline;
         }
@@ -2666,10 +2669,10 @@ fn add_without_unwanted_attributes<'hir>(
                 let DocAttribute { hidden, inline, cfg, .. } = d;
                 let mut attr = DocAttribute::default();
                 if is_inline {
+                    attr.cfg = cfg.clone();
+                } else {
                     attr.inline = inline.clone();
                     attr.hidden = hidden.clone();
-                } else {
-                    attr.cfg = cfg.clone();
                 }
                 attrs.push((
                     Cow::Owned(hir::Attribute::Parsed(AttributeKind::Doc(Box::new(attr)))),
@@ -2914,10 +2917,12 @@ fn clean_extern_crate<'tcx>(
     let attrs = cx.tcx.hir_attrs(krate.hir_id());
     let ty_vis = cx.tcx.visibility(krate.owner_id);
     let please_inline = ty_vis.is_public()
-        && attrs.iter().any(|a| matches!(
+        && attrs.iter().any(|a| {
+            matches!(
             a,
-            hir::Attribute::Parsed(AttributeKind::Doc(d)) if d.inline.is_some_and(|(i, _)| i == DocInline::Inline))
-        )
+            hir::Attribute::Parsed(AttributeKind::Doc(d))
+            if d.inline.is_some_and(|(i, _)| i == DocInline::Inline))
+        })
         && !cx.is_json_output();
 
     let krate_owner_def_id = krate.owner_id.def_id;

src/librustdoc/clean/types.rs

@@ -929,37 +929,6 @@ pub(crate) struct Module {
     pub(crate) span: Span,
 }
 
-pub(crate) fn hir_attr_lists<'a, I: IntoIterator<Item = &'a hir::Attribute>>(
-    attrs: I,
-    name: Symbol,
-) -> impl Iterator<Item = ast::MetaItemInner> + use<'a, I> {
-    attrs
-        .into_iter()
-        .filter(move |attr| attr.has_name(name))
-        .filter_map(ast::attr::AttributeExt::meta_item_list)
-        .flatten()
-}
-
-pub(crate) trait NestedAttributesExt {
-    /// Returns `true` if the attribute list contains a specific `word`
-    fn has_word(self, word: Symbol) -> bool
-    where
-        Self: Sized,
-    {
-        <Self as NestedAttributesExt>::get_word_attr(self, word).is_some()
-    }
-
-    /// Returns `Some(attr)` if the attribute list contains 'attr'
-    /// corresponding to a specific `word`
-    fn get_word_attr(self, word: Symbol) -> Option<ast::MetaItemInner>;
-}
-
-impl<I: Iterator<Item = ast::MetaItemInner>> NestedAttributesExt for I {
-    fn get_word_attr(mut self, word: Symbol) -> Option<ast::MetaItemInner> {
-        self.find(|attr| attr.is_word() && attr.has_name(word))
-    }
-}
-
 /// A link that has not yet been rendered.
 ///
 /// This link will be turned into a rendered link by [`Item::links`].

src/librustdoc/visit_ast.rs

@@ -3,9 +3,10 @@
 
 use std::mem;
 
+use rustc_ast::attr::AttributeExt;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_hir as hir;
-use rustc_hir::attrs::AttributeKind;
+use rustc_hir::attrs::{AttributeKind, DocInline};
 use rustc_hir::def::{DefKind, MacroKinds, Res};
 use rustc_hir::def_id::{DefId, DefIdMap, LocalDefId, LocalDefIdSet};
 use rustc_hir::intravisit::{Visitor, walk_body, walk_item};
@@ -14,11 +15,11 @@ use rustc_middle::hir::nested_filter;
 use rustc_middle::ty::TyCtxt;
 use rustc_span::Span;
 use rustc_span::def_id::{CRATE_DEF_ID, LOCAL_CRATE};
-use rustc_span::symbol::{Symbol, kw, sym};
+use rustc_span::symbol::{Symbol, kw};
 use tracing::debug;
 
+use crate::clean::reexport_chain;
 use crate::clean::utils::{inherits_doc_hidden, should_ignore_res};
-use crate::clean::{NestedAttributesExt, hir_attr_lists, reexport_chain};
 use crate::core;
 
 /// This module is used to store stuff from Rust's AST in a more convenient
@@ -246,8 +247,8 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
         let document_hidden = self.cx.document_hidden();
         let use_attrs = tcx.hir_attrs(tcx.local_def_id_to_hir_id(def_id));
         // Don't inline `doc(hidden)` imports so they can be stripped at a later stage.
-        let is_no_inline = hir_attr_lists(use_attrs, sym::doc).has_word(sym::no_inline)
-            || (document_hidden && hir_attr_lists(use_attrs, sym::doc).has_word(sym::hidden));
+        let is_no_inline = find_attr!(use_attrs, AttributeKind::Doc(d) if d.inline.is_some_and(|(inline, _)| inline == DocInline::NoInline))
+            || (document_hidden && use_attrs.iter().any(|attr| attr.is_doc_hidden()));
 
         if is_no_inline {
             return false;
@@ -464,12 +465,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
                     // If there was a private module in the current path then don't bother inlining
                     // anything as it will probably be stripped anyway.
                     if is_pub && self.inside_public_path {
-                        let please_inline = attrs.iter().any(|item| match item.meta_item_list() {
-                            Some(ref list) if item.has_name(sym::doc) => {
-                                list.iter().any(|i| i.has_name(sym::inline))
-                            }
-                            _ => false,
-                        });
+                        let please_inline = find_attr!(attrs, AttributeKind::Doc(d) if d.inline.is_some_and(|(inline, _)| inline == DocInline::Inline));
                         let ident = match kind {
                             hir::UseKind::Single(ident) => Some(ident.name),
                             hir::UseKind::Glob => None,