Remove AttributeLintKind::UnusedDuplicate

Author: GuillaumeGomez

compiler/rustc_attr_parsing/src/attributes/doc.rs

@@ -1,4 +1,5 @@
 use rustc_ast::ast::{AttrStyle, LitKind, MetaItemLit};
+use rustc_errors::Diagnostic;
 use rustc_feature::template;
 use rustc_hir::Target;
 use rustc_hir::attrs::{
@@ -169,12 +170,15 @@ impl DocParser {
 
                 if let Some(used_span) = self.attribute.no_crate_inject {
                     let unused_span = path.span();
-                    cx.emit_lint(
+                    cx.emit_dyn_lint(
                         rustc_session::lint::builtin::INVALID_DOC_ATTRIBUTES,
-                        AttributeLintKind::UnusedDuplicate {
-                            this: unused_span,
-                            other: used_span,
-                            warning: true,
+                        move |dcx, level| {
+                            rustc_errors::lints::UnusedDuplicate {
+                                this: unused_span,
+                                other: used_span,
+                                warning: true,
+                            }
+                            .into_diag(dcx, level)
                         },
                         unused_span,
                     );

compiler/rustc_attr_parsing/src/context.rs

@@ -6,7 +6,8 @@ use std::sync::LazyLock;
 
 use private::Sealed;
 use rustc_ast::{AttrStyle, MetaItemLit, NodeId};
-use rustc_errors::{Diag, Diagnostic, Level};
+use rustc_data_structures::sync::{DynSend, DynSync};
+use rustc_errors::{Diag, DiagCtxtHandle, Diagnostic, Level};
 use rustc_feature::{AttrSuggestionStyle, AttributeTemplate};
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::lints::AttributeLintKind;
@@ -448,22 +449,43 @@ impl<'f, 'sess: 'f, S: Stage> SharedContext<'f, 'sess, S> {
     /// must be delayed until after HIR is built. This method will take care of the details of
     /// that.
     pub(crate) fn emit_lint(&mut self, lint: &'static Lint, kind: AttributeLintKind, span: Span) {
+        self.emit_lint_inner(lint, EmitAttribute::Static(kind), span);
+    }
+
+    /// Emit a lint. This method is somewhat special, since lints emitted during attribute parsing
+    /// must be delayed until after HIR is built. This method will take care of the details of
+    /// that.
+    pub(crate) fn emit_dyn_lint<
+        F: for<'a> Fn(DiagCtxtHandle<'a>, Level) -> Diag<'a, ()> + DynSend + DynSync + 'static,
+    >(
+        &mut self,
+        lint: &'static Lint,
+        callback: F,
+        span: Span,
+    ) {
+        self.emit_lint_inner(lint, EmitAttribute::Dynamic(Box::new(callback)), span);
+    }
+
+    fn emit_lint_inner(&mut self, lint: &'static Lint, kind: EmitAttribute, span: Span) {
         if !matches!(
             self.stage.should_emit(),
             ShouldEmit::ErrorsAndLints { .. } | ShouldEmit::EarlyFatal { also_emit_lints: true }
         ) {
             return;
         }
-        (self.emit_lint)(LintId::of(lint), span, EmitAttribute::Static(kind));
+        (self.emit_lint)(LintId::of(lint), span, kind);
     }
 
     pub(crate) fn warn_unused_duplicate(&mut self, used_span: Span, unused_span: Span) {
-        self.emit_lint(
+        self.emit_dyn_lint(
             rustc_session::lint::builtin::UNUSED_ATTRIBUTES,
-            AttributeLintKind::UnusedDuplicate {
-                this: unused_span,
-                other: used_span,
-                warning: false,
+            move |dcx, level| {
+                rustc_errors::lints::UnusedDuplicate {
+                    this: unused_span,
+                    other: used_span,
+                    warning: false,
+                }
+                .into_diag(dcx, level)
             },
             unused_span,
         )
@@ -474,12 +496,15 @@ impl<'f, 'sess: 'f, S: Stage> SharedContext<'f, 'sess, S> {
         used_span: Span,
         unused_span: Span,
     ) {
-        self.emit_lint(
+        self.emit_dyn_lint(
             rustc_session::lint::builtin::UNUSED_ATTRIBUTES,
-            AttributeLintKind::UnusedDuplicate {
-                this: unused_span,
-                other: used_span,
-                warning: true,
+            move |dcx, level| {
+                rustc_errors::lints::UnusedDuplicate {
+                    this: unused_span,
+                    other: used_span,
+                    warning: true,
+                }
+                .into_diag(dcx, level)
             },
             unused_span,
         )

compiler/rustc_errors/src/lib.rs

@@ -77,6 +77,7 @@ mod diagnostic_impls;
 pub mod emitter;
 pub mod formatting;
 pub mod json;
+pub mod lints;
 mod lock;
 pub mod markdown;
 pub mod timings;

compiler/rustc_lint/src/early/diagnostics.rs

@@ -172,9 +172,6 @@ pub struct DecorateAttrLint<'a, 'sess, 'tcx> {
 impl<'a> Diagnostic<'a, ()> for DecorateAttrLint<'_, '_, '_> {
     fn into_diag(self, dcx: DiagCtxtHandle<'a>, level: Level) -> Diag<'a, ()> {
         match self.diagnostic {
-            &AttributeLintKind::UnusedDuplicate { this, other, warning } => {
-                lints::UnusedDuplicate { this, other, warning }.into_diag(dcx, level)
-            }
             AttributeLintKind::IllFormedAttributeInput { suggestions, docs } => {
                 lints::IllFormedAttributeInput {
                     num_suggestions: suggestions.len(),

compiler/rustc_lint/src/lints.rs

@@ -3422,19 +3422,6 @@ pub(crate) struct InvalidAttrStyle {
     pub target: &'static str,
 }
 
-#[derive(Diagnostic)]
-#[diag("unused attribute")]
-pub(crate) struct UnusedDuplicate {
-    #[suggestion("remove this attribute", code = "", applicability = "machine-applicable")]
-    pub this: Span,
-    #[note("attribute also specified here")]
-    pub other: Span,
-    #[warning(
-        "this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!"
-    )]
-    pub warning: bool,
-}
-
 #[derive(Diagnostic)]
 #[diag("malformed `doc` attribute input")]
 #[warning(

compiler/rustc_lint_defs/src/lib.rs

@@ -695,11 +695,6 @@ pub enum BuiltinLintDiag {
 
 #[derive(Debug, HashStable_Generic)]
 pub enum AttributeLintKind {
-    UnusedDuplicate {
-        this: Span,
-        other: Span,
-        warning: bool,
-    },
     IllFormedAttributeInput {
         suggestions: Vec<String>,
         docs: Option<&'static str>,