Fix warning messages

Author: GuillaumeGomez

compiler/rustc_attr_parsing/src/attributes/doc.rs

@@ -2,7 +2,6 @@
 #![allow(unused_imports)]
 
 use rustc_ast::ast::{AttrStyle, LitKind, MetaItemLit};
-use rustc_errors::MultiSpan;
 use rustc_feature::template;
 use rustc_hir::attrs::{
     AttributeKind, CfgEntry, CfgHideShow, CfgInfo, DocAttribute, DocInline, HideOrShow,
@@ -18,7 +17,7 @@ use crate::fluent_generated as fluent;
 use crate::parser::{ArgParser, MetaItemOrLitParser, MetaItemParser, PathParser};
 use crate::session_diagnostics::{
     DocAliasBadChar, DocAliasEmpty, DocAliasMalformed, DocAliasStartEnd, DocAttributeNotAttribute,
-    DocKeywordConflict, DocKeywordNotKeyword,
+    DocKeywordNotKeyword,
 };
 
 fn check_keyword<S: Stage>(cx: &mut AcceptContext<'_, '_, S>, keyword: Symbol, span: Span) -> bool {
@@ -204,19 +203,7 @@ impl DocParser {
             return;
         }
 
-        let span = path.span();
-
-        if let Some((prev_inline, prev_span)) = self.attribute.inline {
-            if prev_inline == inline {
-                let mut spans = MultiSpan::from_spans(vec![prev_span, span]);
-                spans.push_span_label(prev_span, fluent::attr_parsing_doc_inline_conflict_first);
-                spans.push_span_label(span, fluent::attr_parsing_doc_inline_conflict_second);
-                cx.emit_err(DocKeywordConflict { spans });
-                return;
-            }
-        }
-
-        self.attribute.inline = Some((inline, span));
+        self.attribute.inline.push((inline, path.span()));
     }
 
     fn parse_cfg<'c, S: Stage>(

compiler/rustc_attr_parsing/src/session_diagnostics.rs

@@ -4,7 +4,6 @@ use rustc_ast::{self as ast, Path};
 use rustc_errors::codes::*;
 use rustc_errors::{
     Applicability, Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level,
-    MultiSpan,
 };
 use rustc_feature::AttributeTemplate;
 use rustc_hir::{AttrPath, Target};
@@ -631,14 +630,6 @@ pub(crate) struct DocAliasDuplicated {
     pub first_defn: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(attr_parsing_doc_inline_conflict)]
-#[help]
-pub(crate) struct DocKeywordConflict {
-    #[primary_span]
-    pub spans: MultiSpan,
-}
-
 #[derive(Diagnostic)]
 #[diag(attr_parsing_link_ordinal_out_of_range)]
 #[note]

compiler/rustc_hir/src/attrs/data_structures.rs

@@ -476,7 +476,9 @@ pub struct CfgHideShow {
 pub struct DocAttribute {
     pub aliases: FxIndexMap<Symbol, Span>,
     pub hidden: Option<Span>,
-    pub inline: Option<(DocInline, Span)>,
+    // Because we need to emit the error if there is more than one `inline` attribute on an item
+    // at the same time as the other doc attributes, we store a list instead of using `Option`.
+    pub inline: ThinVec<(DocInline, Span)>,
 
     // unstable
     pub cfg: ThinVec<CfgEntry>,
@@ -511,7 +513,7 @@ impl Default for DocAttribute {
         Self {
             aliases: FxIndexMap::default(),
             hidden: None,
-            inline: None,
+            inline: ThinVec::new(),
             cfg: ThinVec::new(),
             auto_cfg: ThinVec::new(),
             auto_cfg_change: ThinVec::new(),

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -880,7 +880,7 @@ fn analyze_attr(attr: &hir::Attribute, state: &mut AnalyzeAttrState<'_>) -> bool
     } else if let hir::Attribute::Parsed(AttributeKind::Doc(d)) = attr {
         // If this is a `doc` attribute that doesn't have anything except maybe `inline` (as in
         // `#[doc(inline)]`), then we can remove it. It won't be inlinable in downstream crates.
-        if d.inline.is_none() {
+        if d.inline.is_empty() {
             should_encode = true;
             if d.hidden.is_some() {
                 state.is_doc_hidden = true;

compiler/rustc_passes/messages.ftl

@@ -106,18 +106,26 @@ passes_diagnostic_item_first_defined =
     the diagnostic item is first defined here
 
 passes_doc_alias_bad_location =
-    doc alias attribute isn't allowed on {$location}
+    `#[doc(alias = "...")]` isn't allowed on {$location}
 
 passes_doc_alias_not_an_alias =
-    {$attr_str} is the same as the item's name
+    `#[doc(alias = "{$attr_str}"]` is the same as the item's name
 
 passes_doc_attr_not_crate_level =
     `#![doc({$attr_name} = "...")]` isn't allowed as a crate-level attribute
 
 passes_doc_fake_variadic_not_valid =
     `#[doc(fake_variadic)]` must be used on the first of a set of tuple or fn pointer trait impls with varying arity
 
+passes_doc_inline_conflict =
+    conflicting doc inlining attributes
+    .help = remove one of the conflicting attributes
 
+passes_doc_inline_conflict_first =
+    this attribute...
+
+passes_doc_inline_conflict_second =
+    {"."}..conflicts with this attribute
 
 passes_doc_inline_only_use =
     this attribute can only be applied to a `use` item

compiler/rustc_passes/src/check_attr.rs

@@ -13,13 +13,14 @@ use rustc_abi::{Align, ExternAbi, Size};
 use rustc_ast::{AttrStyle, LitKind, MetaItemKind, ast};
 use rustc_attr_parsing::{AttributeParser, Late};
 use rustc_data_structures::fx::FxHashMap;
-use rustc_errors::{DiagCtxtHandle, IntoDiagArg, StashKey};
+use rustc_errors::{DiagCtxtHandle, IntoDiagArg, MultiSpan, StashKey};
 use rustc_feature::{
     ACCEPTED_LANG_FEATURES, AttributeDuplicates, AttributeType, BUILTIN_ATTRIBUTE_MAP,
     BuiltinAttribute,
 };
 use rustc_hir::attrs::{
-    AttributeKind, DocAttribute, InlineAttr, MirDialect, MirPhase, ReprAttr, SanitizerSet,
+    AttributeKind, DocAttribute, DocInline, InlineAttr, MirDialect, MirPhase, ReprAttr,
+    SanitizerSet,
 };
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::LocalModDefId;
@@ -877,7 +878,24 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
     /// already seen an inlining attribute for this item.
     /// If so, `specified_inline` holds the value and the span of
     /// the first `inline`/`no_inline` attribute.
-    fn check_doc_inline(&self, span: Span, hir_id: HirId, target: Target) {
+    fn check_doc_inline(&self, hir_id: HirId, target: Target, inline: &[(DocInline, Span)]) {
+        let span = match inline {
+            [] => return,
+            [(_, span)] => *span,
+            [(inline, span), rest @ ..] => {
+                for (inline2, span2) in rest {
+                    if inline2 != inline {
+                        let mut spans = MultiSpan::from_spans(vec![*span, *span2]);
+                        spans.push_span_label(*span, fluent::passes_doc_inline_conflict_first);
+                        spans.push_span_label(*span2, fluent::passes_doc_inline_conflict_second);
+                        self.dcx().emit_err(errors::DocInlineConflict { spans });
+                        return;
+                    }
+                }
+                *span
+            }
+        };
+
         match target {
             Target::Use | Target::ExternCrate => {}
             _ => {
@@ -1046,9 +1064,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
         }
 
-        if let Some((_, span)) = inline {
-            self.check_doc_inline(*span, hir_id, target)
-        }
+        self.check_doc_inline(hir_id, target, inline);
 
         if let Some(span) = rust_logo {
             if self.check_attr_crate_level(*span, hir_id)

compiler/rustc_passes/src/errors.rs

@@ -176,6 +176,14 @@ pub(crate) struct DocSearchUnboxInvalid {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(passes_doc_inline_conflict)]
+#[help]
+pub(crate) struct DocInlineConflict {
+    #[primary_span]
+    pub spans: MultiSpan,
+}
+
 #[derive(LintDiagnostic)]
 #[diag(passes_doc_inline_only_use)]
 #[note]

src/librustdoc/clean/mod.rs

@@ -199,7 +199,7 @@ fn generate_item_with_correct_attrs(
             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)
+                if d.inline.first().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));
@@ -2921,7 +2921,7 @@ fn clean_extern_crate<'tcx>(
             matches!(
             a,
             hir::Attribute::Parsed(AttributeKind::Doc(d))
-            if d.inline.is_some_and(|(i, _)| i == DocInline::Inline))
+            if d.inline.first().is_some_and(|(i, _)| *i == DocInline::Inline))
         })
         && !cx.is_json_output();
 
@@ -2986,9 +2986,9 @@ fn clean_use_statement_inner<'tcx>(
     let attrs = cx.tcx.hir_attrs(import.hir_id());
     let inline_attr = find_attr!(
         attrs,
-        AttributeKind::Doc(d) if d.inline.is_some_and(|(i, _)| i == DocInline::Inline) => d
+        AttributeKind::Doc(d) if d.inline.first().is_some_and(|(i, _)| *i == DocInline::Inline) => d
     )
-    .and_then(|d| d.inline);
+    .and_then(|d| d.inline.first());
     let pub_underscore = visibility.is_public() && name == Some(kw::Underscore);
     let current_mod = cx.tcx.parent_module_from_def_id(import.owner_id.def_id);
     let import_def_id = import.owner_id.def_id;
@@ -3009,7 +3009,7 @@ fn clean_use_statement_inner<'tcx>(
     if pub_underscore && let Some((_, inline_span)) = inline_attr {
         struct_span_code_err!(
             cx.tcx.dcx(),
-            inline_span,
+            *inline_span,
             E0780,
             "anonymous imports cannot be inlined"
         )
@@ -3026,7 +3026,9 @@ fn clean_use_statement_inner<'tcx>(
         || pub_underscore
         || attrs.iter().any(|a| matches!(
             a,
-            hir::Attribute::Parsed(AttributeKind::Doc(d)) if d.hidden.is_some() || d.inline.is_some_and(|(i, _)| i == DocInline::NoInline)));
+            hir::Attribute::Parsed(AttributeKind::Doc(d))
+            if d.hidden.is_some() || d.inline.first().is_some_and(|(i, _)| *i == DocInline::NoInline)
+        ));
 
     // Also check whether imports were asked to be inlined, in case we're trying to re-export a
     // crate in Rust 2018+

src/librustdoc/lib.rs

@@ -32,6 +32,7 @@
 extern crate rustc_abi;
 extern crate rustc_ast;
 extern crate rustc_ast_pretty;
+extern crate rustc_attr_parsing;
 extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_errors;
@@ -75,6 +76,7 @@ use std::process;
 
 use rustc_errors::DiagCtxtHandle;
 use rustc_hir::def_id::LOCAL_CRATE;
+use rustc_hir::lints::DelayedLint;
 use rustc_interface::interface;
 use rustc_middle::ty::TyCtxt;
 use rustc_session::config::{ErrorOutputType, RustcOptGroup, make_crate_type_option};
@@ -900,6 +902,18 @@ fn main_args(early_dcx: &mut EarlyDiagCtxt, at_args: &[String]) {
                 return;
             }
 
+            for owner_id in tcx.hir_crate_items(()).delayed_lint_items() {
+                if let Some(delayed_lints) = tcx.opt_ast_lowering_delayed_lints(owner_id) {
+                    for lint in &delayed_lints.lints {
+                        match lint {
+                            DelayedLint::AttributeParsing(attribute_lint) => {
+                                rustc_attr_parsing::emit_attribute_lint(attribute_lint, tcx)
+                            }
+                        }
+                    }
+                }
+            }
+
             if render_opts.dep_info().is_some() {
                 rustc_interface::passes::write_dep_info(tcx);
             }

src/librustdoc/visit_ast.rs

@@ -247,8 +247,12 @@ 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 = 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()));
+        let is_no_inline = find_attr!(
+            use_attrs,
+            AttributeKind::Doc(d)
+            if d.inline.first().is_some_and(|(inline, _)| *inline == DocInline::NoInline)
+        ) || (document_hidden
+            && use_attrs.iter().any(|attr| attr.is_doc_hidden()));
 
         if is_no_inline {
             return false;
@@ -465,7 +469,11 @@ 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 = find_attr!(attrs, AttributeKind::Doc(d) if d.inline.is_some_and(|(inline, _)| inline == DocInline::Inline));
+                        let please_inline = find_attr!(
+                            attrs,
+                            AttributeKind::Doc(d)
+                            if d.inline.first().is_some_and(|(inline, _)| *inline == DocInline::Inline)
+                        );
                         let ident = match kind {
                             hir::UseKind::Single(ident) => Some(ident.name),
                             hir::UseKind::Glob => None,