Auto merge of #152811 - GuillaumeGomez:rm-lintdiag, r=<try>

Remove `LintDiagnostic`

Author: bors

compiler/rustc_ast_passes/src/errors.rs

@@ -4,7 +4,7 @@ use rustc_abi::ExternAbi;
 use rustc_ast::ParamKindOrd;
 use rustc_errors::codes::*;
 use rustc_errors::{Applicability, Diag, EmissionGuarantee, Subdiagnostic};
-use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
+use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Ident, Span, Symbol};
 
 #[derive(Diagnostic)]
@@ -671,7 +671,7 @@ pub(crate) struct MissingUnsafeOnExtern {
     pub span: Span,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("extern blocks should be unsafe")]
 pub(crate) struct MissingUnsafeOnExternLint {
     #[suggestion(
@@ -1027,7 +1027,7 @@ pub(crate) struct MissingAbi {
     pub span: Span,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("`extern` declarations without an explicit ABI are deprecated")]
 pub(crate) struct MissingAbiSugg {
     #[suggestion(

compiler/rustc_borrowck/src/diagnostics/mod.rs

@@ -56,6 +56,7 @@ mod opaque_types;
 mod region_errors;
 
 pub(crate) use bound_region_errors::{ToUniverseInfo, UniverseInfo};
+pub(crate) use explain_borrow::BorrowExplanation;
 pub(crate) use move_errors::{IllegalMoveOriginKind, MoveError};
 pub(crate) use mutability_errors::AccessKind;
 pub(crate) use outlives_suggestion::OutlivesSuggestionBuilder;

compiler/rustc_borrowck/src/lib.rs

@@ -27,7 +27,7 @@ use rustc_abi::FieldIdx;
 use rustc_data_structures::frozen::Frozen;
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_data_structures::graph::dominators::Dominators;
-use rustc_errors::LintDiagnostic;
+use rustc_errors::Diagnostic;
 use rustc_hir as hir;
 use rustc_hir::CRATE_HIR_ID;
 use rustc_hir::def_id::LocalDefId;
@@ -1397,6 +1397,26 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
         place: Place<'tcx>,
         state: &BorrowckDomain,
     ) {
+        struct Borrowed<'a, 'b, 'infcx, 'tcx> {
+            borrowed: Span,
+            this: &'a MirBorrowckCtxt<'b, 'infcx, 'tcx>,
+            explain: crate::diagnostics::BorrowExplanation<'tcx>,
+        }
+
+        impl<'a, 'b, 'c, 'infcx, 'tcx: 'c> Diagnostic<'a, ()> for Borrowed<'b, 'c, 'infcx, 'tcx> {
+            fn into_diag(
+                self,
+                dcx: rustc_errors::DiagCtxtHandle<'a>,
+                level: rustc_errors::Level,
+            ) -> rustc_errors::Diag<'a, ()> {
+                let Self { borrowed, this, explain } = self;
+                let mut diag =
+                    session_diagnostics::TailExprDropOrder { borrowed }.into_diag(dcx, level);
+                explain.add_explanation_to_diagnostic(this, &mut diag, "", None, None);
+                diag
+            }
+        }
+
         let tcx = self.infcx.tcx;
         // If this type does not need `Drop`, then treat it like a `StorageDead`.
         // This is needed because we track the borrows of refs to thread locals,
@@ -1428,14 +1448,11 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                     borrow,
                     Some((WriteKind::StorageDeadOrDrop, place)),
                 );
-                this.infcx.tcx.node_span_lint(
+                this.infcx.tcx.emit_node_span_lint(
                     TAIL_EXPR_DROP_ORDER,
                     CRATE_HIR_ID,
                     borrowed,
-                    |diag| {
-                        session_diagnostics::TailExprDropOrder { borrowed }.decorate_lint(diag);
-                        explain.add_explanation_to_diagnostic(&this, diag, "", None, None);
-                    },
+                    Borrowed { borrowed, this, explain },
                 );
                 // We may stop at the first case
                 ControlFlow::Break(())

compiler/rustc_borrowck/src/session_diagnostics.rs

@@ -1,6 +1,6 @@
 use rustc_errors::MultiSpan;
 use rustc_errors::codes::*;
-use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
+use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_middle::ty::{GenericArg, Ty};
 use rustc_span::Span;
 
@@ -47,7 +47,7 @@ pub(crate) struct GenericDoesNotLiveLongEnough {
     pub span: Span,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("variable does not need to be mutable")]
 pub(crate) struct VarNeedNotMut {
     #[suggestion(
@@ -595,7 +595,7 @@ pub(crate) struct SimdIntrinsicArgConst {
     pub intrinsic: String,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("relative drop order changing in Rust 2024")]
 pub(crate) struct TailExprDropOrder {
     #[label("this temporary value will be dropped at the end of the block")]

compiler/rustc_builtin_macros/src/errors.rs

@@ -3,26 +3,26 @@ use rustc_errors::{
     Diag, DiagCtxtHandle, Diagnostic, EmissionGuarantee, Level, MultiSpan, SingleLabelManySpans,
     Subdiagnostic, msg,
 };
-use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
+use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Ident, Span, Symbol};
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("avoid using `.intel_syntax`, Intel syntax is the default")]
 pub(crate) struct AvoidIntelSyntax;
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("avoid using `.att_syntax`, prefer using `options(att_syntax)` instead")]
 pub(crate) struct AvoidAttSyntax;
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("include macro expected single expression in source")]
 pub(crate) struct IncompleteInclude;
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("cannot test inner items")]
 pub(crate) struct UnnameableTestItems;
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("duplicated attribute")]
 pub(crate) struct DuplicateMacroAttribute;
 

compiler/rustc_codegen_ssa/src/back/link.rs

@@ -18,11 +18,11 @@ use rustc_attr_parsing::eval_config_entry;
 use rustc_data_structures::fx::{FxHashSet, FxIndexSet};
 use rustc_data_structures::memmap::Mmap;
 use rustc_data_structures::temp_dir::MaybeTempDir;
-use rustc_errors::{DiagCtxtHandle, LintDiagnostic};
+use rustc_errors::DiagCtxtHandle;
 use rustc_fs_util::{TempDirBuilder, fix_windows_verbatim_for_gcc, try_canonicalize};
 use rustc_hir::attrs::NativeLibKind;
 use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
-use rustc_macros::LintDiagnostic;
+use rustc_macros::Diagnostic;
 use rustc_metadata::fs::{METADATA_FILENAME, copy_to_stdout, emit_wrapper_file};
 use rustc_metadata::{
     EncodedMetadata, NativeLibSearchFallback, find_native_static_library,
@@ -662,7 +662,7 @@ fn link_dwarf_object(sess: &Session, cg_results: &CodegenResults, executable_out
     }
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("{$inner}")]
 /// Translating this is kind of useless. We don't pass translation flags to the linker, so we'd just
 /// end up with inconsistent languages within the same diagnostic.
@@ -937,11 +937,8 @@ fn link_natively(
             }
 
             let level = codegen_results.crate_info.lint_levels.linker_messages;
-            let lint = |msg| {
-                lint_level(sess, LINKER_MESSAGES, level, None, |diag| {
-                    LinkerOutput { inner: msg }.decorate_lint(diag)
-                })
-            };
+            let lint =
+                |msg| lint_level(sess, LINKER_MESSAGES, level, None, LinkerOutput { inner: msg });
 
             if !prog.stderr.is_empty() {
                 // We already print `warning:` at the start of the diagnostic. Remove it from the linker output if present.

compiler/rustc_codegen_ssa/src/codegen_attrs.rs

@@ -9,6 +9,7 @@ use rustc_hir::attrs::{
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::{self as hir, Attribute, find_attr};
+use rustc_macros::Diagnostic;
 use rustc_middle::middle::codegen_fn_attrs::{
     CodegenFnAttrFlags, CodegenFnAttrs, PatchableFunctionEntry, SanitizerFnAttrs,
 };
@@ -393,6 +394,17 @@ fn apply_overrides(tcx: TyCtxt<'_>, did: LocalDefId, codegen_fn_attrs: &mut Code
     }
 }
 
+#[derive(Diagnostic)]
+#[diag("non-default `sanitize` will have no effect after inlining")]
+struct NonDefaultSanitize {
+    #[note("inlining requested here")]
+    inline_span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag("the async executor can run blocking code, without realtime sanitizer catching it")]
+struct AsyncExecutorRunningBlockingCode;
+
 fn check_result(
     tcx: TyCtxt<'_>,
     did: LocalDefId,
@@ -433,10 +445,12 @@ fn check_result(
             (interesting_spans.sanitize, interesting_spans.inline)
     {
         let hir_id = tcx.local_def_id_to_hir_id(did);
-        tcx.node_span_lint(lint::builtin::INLINE_NO_SANITIZE, hir_id, sanitize_span, |lint| {
-            lint.primary_message("non-default `sanitize` will have no effect after inlining");
-            lint.span_note(inline_span, "inlining requested here");
-        })
+        tcx.emit_node_span_lint(
+            lint::builtin::INLINE_NO_SANITIZE,
+            hir_id,
+            sanitize_span,
+            NonDefaultSanitize { inline_span },
+        );
     }
 
     // warn for nonblocking async functions, blocks and closures.
@@ -453,13 +467,11 @@ fn check_result(
                     != rustc_hir::ClosureKind::Closure))
     {
         let hir_id = tcx.local_def_id_to_hir_id(did);
-        tcx.node_span_lint(
+        tcx.emit_node_span_lint(
             lint::builtin::RTSAN_NONBLOCKING_ASYNC,
             hir_id,
             sanitize_span,
-            |lint| {
-                lint.primary_message(r#"the async executor can run blocking code, without realtime sanitizer catching it"#);
-            }
+            AsyncExecutorRunningBlockingCode,
         );
     }
 

compiler/rustc_codegen_ssa/src/errors.rs

@@ -10,7 +10,7 @@ use rustc_errors::codes::*;
 use rustc_errors::{
     Diag, DiagArgValue, DiagCtxtHandle, Diagnostic, EmissionGuarantee, IntoDiagArg, Level, msg,
 };
-use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
+use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_middle::ty::layout::LayoutError;
 use rustc_middle::ty::{FloatTy, Ty};
 use rustc_span::{Span, Symbol};
@@ -1164,7 +1164,7 @@ pub(crate) struct XcrunSdkPathWarning {
     pub stderr: String,
 }
 
-#[derive(LintDiagnostic)]
+#[derive(Diagnostic)]
 #[diag("enabling the `neon` target feature on the current target is unsound due to ABI issues")]
 pub(crate) struct Aarch64SoftfloatNeon;
 

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -905,6 +905,13 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         kind: CallKind,
         mergeable_succ: bool,
     ) -> MergingSucc {
+        #[derive(rustc_macros::Diagnostic)]
+        #[diag("tail calling a function marked with `#[track_caller]` has no special effect")]
+        struct TailCallingTrackCallerFn {
+            #[primary_span]
+            fn_span: Span,
+        }
+
         let source_info = mir::SourceInfo { span: fn_span, ..terminator.source_info };
 
         // Create the callee. This is a fn ptr or zero-sized and hence a kind of scalar.
@@ -1020,10 +1027,11 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                         if let Some(hir_id) =
                             terminator.source_info.scope.lint_root(&self.mir.source_scopes)
                         {
-                            let msg = "tail calling a function marked with `#[track_caller]` has no special effect";
-                            bx.tcx().node_lint(TAIL_CALL_TRACK_CALLER, hir_id, |d| {
-                                _ = d.primary_message(msg).span(fn_span)
-                            });
+                            bx.tcx().node_lint(
+                                TAIL_CALL_TRACK_CALLER,
+                                hir_id,
+                                TailCallingTrackCallerFn { fn_span },
+                            );
                         }
 
                         let instance = ty::Instance::resolve_for_fn_ptr(

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -252,7 +252,7 @@ pub(super) fn lint<'tcx, L>(
     lint: &'static rustc_session::lint::Lint,
     decorator: impl FnOnce(Vec<errors::FrameNote>) -> L,
 ) where
-    L: for<'a> rustc_errors::LintDiagnostic<'a, ()>,
+    L: for<'a> rustc_errors::Diagnostic<'a, ()>,
 {
     let (span, frames) = get_span_and_frames(tcx, &machine.stack);