Make lint diagnostics responsible for providing their primary span

compiler/rustc_borrowck/src/lib.rs

@@ -401,7 +401,7 @@ fn do_mir_borrowck<'tcx>(
 
         let mut_span = tcx.sess.source_map().span_until_non_whitespace(span);
 
-        tcx.emit_node_span_lint(UNUSED_MUT, lint_root, span, VarNeedNotMut { span: mut_span })
+        tcx.emit_node_lint(UNUSED_MUT, lint_root, VarNeedNotMut { span, mut_span })
     }
 
     let tainted_by_errors = mbcx.emit_errors();

compiler/rustc_borrowck/src/session_diagnostics.rs

@@ -50,8 +50,10 @@ pub(crate) struct GenericDoesNotLiveLongEnough {
 #[derive(LintDiagnostic)]
 #[diag(borrowck_var_does_not_need_mut)]
 pub(crate) struct VarNeedNotMut {
-    #[suggestion(style = "short", applicability = "machine-applicable", code = "")]
+    #[primary_span]
     pub span: Span,
+    #[suggestion(style = "short", applicability = "machine-applicable", code = "")]
+    pub mut_span: Span,
 }
 #[derive(Diagnostic)]
 #[diag(borrowck_var_cannot_escape_closure)]

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -170,11 +170,11 @@ pub(super) fn lint<'tcx, L>(
     tcx: TyCtxtAt<'tcx>,
     machine: &CompileTimeMachine<'tcx>,
     lint: &'static rustc_session::lint::Lint,
-    decorator: impl FnOnce(Vec<errors::FrameNote>) -> L,
+    decorator: impl FnOnce(Span, Vec<errors::FrameNote>) -> L,
 ) where
     L: for<'a> rustc_errors::LintDiagnostic<'a, ()>,
 {
     let (span, frames) = get_span_and_frames(tcx, &machine.stack);
 
-    tcx.emit_node_span_lint(lint, machine.best_lint_scope(*tcx), span, decorator(frames));
+    tcx.emit_node_lint(lint, machine.best_lint_scope(*tcx), decorator(span, frames));
 }

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -622,11 +622,10 @@ impl<'tcx> interpret::Machine<'tcx> for CompileTimeMachine<'tcx> {
                     .0
                     .is_error();
                 let span = ecx.cur_span();
-                ecx.tcx.emit_node_span_lint(
+                ecx.tcx.emit_node_lint(
                     rustc_session::lint::builtin::LONG_RUNNING_CONST_EVAL,
                     hir_id,
-                    span,
-                    LongRunning { item_span: ecx.tcx.span },
+                    LongRunning { span, item_span: ecx.tcx.span },
                 );
                 // If this was a hard error, don't bother continuing evaluation.
                 if is_error {

compiler/rustc_const_eval/src/errors.rs

@@ -197,6 +197,8 @@ pub(crate) struct InteriorMutableRefEscaping {
 #[diag(const_eval_long_running)]
 #[note]
 pub struct LongRunning {
+    #[primary_span]
+    pub span: Span,
     #[help]
     pub item_span: Span,
 }

compiler/rustc_errors/src/diagnostic.rs

@@ -195,8 +195,10 @@ pub trait SubdiagMessageOp<G: EmissionGuarantee> =
 /// `#[derive(LintDiagnostic)]` -- see [rustc_macros::LintDiagnostic].
 #[rustc_diagnostic_item = "LintDiagnostic"]
 pub trait LintDiagnostic<'a, G: EmissionGuarantee> {
-    /// Decorate and emit a lint.
+    /// Decorate a lint.
     fn decorate_lint<'b>(self, diag: &'b mut Diag<'a, G>);
+
+    fn span(&self) -> Option<MultiSpan>;
 }
 
 #[derive(Clone, Debug, Encodable, Decodable)]

compiler/rustc_hir_analysis/src/check/compare_impl_item/refine.rs

@@ -297,11 +297,11 @@ fn report_mismatched_rpitit_signature<'tcx>(
         });
 
     let span = unmatched_bound.unwrap_or(span);
-    tcx.emit_node_span_lint(
+    tcx.emit_node_lint(
         if is_internal { REFINING_IMPL_TRAIT_INTERNAL } else { REFINING_IMPL_TRAIT_REACHABLE },
         tcx.local_def_id_to_hir_id(impl_m_def_id.expect_local()),
-        span,
         crate::errors::ReturnPositionImplTraitInTraitRefined {
+            span,
             impl_return_span,
             trait_return_span,
             pre,

compiler/rustc_hir_analysis/src/check/errs.rs

@@ -79,10 +79,6 @@ fn handle_static_mut_ref(
         } else {
             (errors::MutRefSugg::Shared { lo, hi }, "shared")
         };
-        tcx.emit_node_span_lint(STATIC_MUT_REFS, hir_id, span, errors::RefOfMutStatic {
-            span,
-            sugg,
-            shared,
-        });
+        tcx.emit_node_lint(STATIC_MUT_REFS, hir_id, errors::RefOfMutStatic { span, sugg, shared });
     }
 }

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -2334,11 +2334,10 @@ fn lint_redundant_lifetimes<'tcx>(
                 && outlives_env.free_region_map().sub_free_regions(tcx, victim, candidate)
             {
                 shadowed.insert(victim);
-                tcx.emit_node_span_lint(
+                tcx.emit_node_lint(
                     rustc_lint_defs::builtin::REDUNDANT_LIFETIMES,
                     tcx.local_def_id_to_hir_id(def_id.expect_local()),
-                    tcx.def_span(def_id),
-                    RedundantLifetimeArgsLint { candidate, victim },
+                    RedundantLifetimeArgsLint { span: tcx.def_span(def_id), candidate, victim },
                 );
             }
         }
@@ -2349,6 +2348,8 @@ fn lint_redundant_lifetimes<'tcx>(
 #[diag(hir_analysis_redundant_lifetime_args)]
 #[note]
 struct RedundantLifetimeArgsLint<'tcx> {
+    #[primary_span]
+    pub span: Span,
     /// The lifetime we have found to be redundant.
     victim: ty::Region<'tcx>,
     // The lifetime we can replace the victim with.

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -494,18 +494,18 @@ fn lint_uncovered_ty_params<'tcx>(
         let name = tcx.item_name(param_def_id);
 
         match local_ty {
-            Some(local_type) => tcx.emit_node_span_lint(
+            Some(local_type) => tcx.emit_node_lint(
                 UNCOVERED_PARAM_IN_PROJECTION,
                 hir_id,
-                span,
-                errors::TyParamFirstLocalLint { span, note: (), param: name, local_type },
-            ),
-            None => tcx.emit_node_span_lint(
-                UNCOVERED_PARAM_IN_PROJECTION,
-                hir_id,
-                span,
-                errors::TyParamSomeLint { span, note: (), param: name },
+                errors::TyParamFirstLocal { span, note: (), param: name, local_type },
             ),
+            None => {
+                tcx.emit_node_lint(UNCOVERED_PARAM_IN_PROJECTION, hir_id, errors::TyParamSome {
+                    span,
+                    note: (),
+                    param: name,
+                })
+            }
         };
     }
 }

compiler/rustc_hir_analysis/src/errors.rs

@@ -1132,6 +1132,7 @@ pub(crate) enum LateBoundInApit {
 #[diag(hir_analysis_unused_associated_type_bounds)]
 #[note]
 pub(crate) struct UnusedAssociatedTypeBounds {
+    #[primary_span]
     #[suggestion(code = "")]
     pub span: Span,
 }
@@ -1141,6 +1142,8 @@ pub(crate) struct UnusedAssociatedTypeBounds {
 #[note]
 #[note(hir_analysis_feedback_note)]
 pub(crate) struct ReturnPositionImplTraitInTraitRefined<'tcx> {
+    #[primary_span]
+    pub span: Span,
     #[suggestion(applicability = "maybe-incorrect", code = "{pre}{return_ty}{post}")]
     pub impl_return_span: Span,
     #[label]
@@ -1379,9 +1382,7 @@ pub(crate) struct CrossCrateTraitsDefined {
     pub traits: String,
 }
 
-// FIXME(fmease): Deduplicate:
-
-#[derive(Diagnostic)]
+#[derive(Diagnostic, LintDiagnostic)]
 #[diag(hir_analysis_ty_param_first_local, code = E0210)]
 #[note]
 pub(crate) struct TyParamFirstLocal<'tcx> {
@@ -1394,19 +1395,7 @@ pub(crate) struct TyParamFirstLocal<'tcx> {
     pub local_type: Ty<'tcx>,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(hir_analysis_ty_param_first_local, code = E0210)]
-#[note]
-pub(crate) struct TyParamFirstLocalLint<'tcx> {
-    #[label]
-    pub span: Span,
-    #[note(hir_analysis_case_note)]
-    pub note: (),
-    pub param: Symbol,
-    pub local_type: Ty<'tcx>,
-}
-
-#[derive(Diagnostic)]
+#[derive(Diagnostic, LintDiagnostic)]
 #[diag(hir_analysis_ty_param_some, code = E0210)]
 #[note]
 pub(crate) struct TyParamSome {
@@ -1418,17 +1407,6 @@ pub(crate) struct TyParamSome {
     pub param: Symbol,
 }
 
-#[derive(LintDiagnostic)]
-#[diag(hir_analysis_ty_param_some, code = E0210)]
-#[note]
-pub(crate) struct TyParamSomeLint {
-    #[label]
-    pub span: Span,
-    #[note(hir_analysis_only_note)]
-    pub note: (),
-    pub param: Symbol,
-}
-
 #[derive(Diagnostic)]
 pub(crate) enum OnlyCurrentTraits {
     #[diag(hir_analysis_only_current_traits_outside, code = E0117)]

compiler/rustc_hir_analysis/src/hir_ty_lowering/dyn_compatibility.rs

@@ -193,16 +193,15 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         // types's `DefId`, so the following loop removes all the `DefIds` of the associated types that have a
         // corresponding `Projection` clause
         for def_ids in associated_types.values_mut() {
-            for (projection_bound, span) in &projection_bounds {
+            for &(projection_bound, span) in &projection_bounds {
                 let def_id = projection_bound.projection_def_id();
                 // FIXME(#120456) - is `swap_remove` correct?
                 def_ids.swap_remove(&def_id);
                 if tcx.generics_require_sized_self(def_id) {
-                    tcx.emit_node_span_lint(
+                    tcx.emit_node_lint(
                         UNUSED_ASSOCIATED_TYPE_BOUNDS,
                         hir_id,
-                        *span,
-                        crate::errors::UnusedAssociatedTypeBounds { span: *span },
+                        crate::errors::UnusedAssociatedTypeBounds { span },
                     );
                 }
             }

compiler/rustc_hir_typeck/src/cast.rs

@@ -663,7 +663,8 @@ impl<'a, 'tcx> CastCheck<'tcx> {
         };
         let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
         let cast_ty = fcx.resolve_vars_if_possible(self.cast_ty);
-        fcx.tcx.emit_node_span_lint(lint, self.expr.hir_id, self.span, errors::TrivialCast {
+        fcx.tcx.emit_node_lint(lint, self.expr.hir_id, errors::TrivialCast {
+            span: self.span,
             numeric,
             expr_ty,
             cast_ty,
@@ -934,11 +935,11 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                             .collect::<Vec<_>>();
 
                         if !added.is_empty() {
-                            tcx.emit_node_span_lint(
+                            tcx.emit_node_lint(
                                 lint::builtin::PTR_CAST_ADD_AUTO_TO_OBJECT,
                                 self.expr.hir_id,
-                                self.span,
                                 errors::PtrCastAddAutoToObject {
+                                    span: self.span,
                                     traits_len: added.len(),
                                     traits: {
                                         let mut traits: Vec<_> = added
@@ -1097,11 +1098,10 @@ impl<'a, 'tcx> CastCheck<'tcx> {
             let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
             let cast_ty = fcx.resolve_vars_if_possible(self.cast_ty);
 
-            fcx.tcx.emit_node_span_lint(
+            fcx.tcx.emit_node_lint(
                 lint::builtin::CENUM_IMPL_DROP_CAST,
                 self.expr.hir_id,
-                self.span,
-                errors::CastEnumDrop { expr_ty, cast_ty },
+                errors::CastEnumDrop { span: self.span, expr_ty, cast_ty },
             );
         }
     }
@@ -1130,12 +1130,10 @@ impl<'a, 'tcx> CastCheck<'tcx> {
             (false, false) => errors::LossyProvenancePtr2IntSuggestion::Other { cast_span },
         };
 
-        let lint = errors::LossyProvenancePtr2Int { expr_ty, cast_ty, sugg };
-        fcx.tcx.emit_node_span_lint(
+        fcx.tcx.emit_node_lint(
             lint::builtin::LOSSY_PROVENANCE_CASTS,
             self.expr.hir_id,
-            self.span,
-            lint,
+            errors::LossyProvenancePtr2Int { span: self.span, expr_ty, cast_ty, sugg },
         );
     }
 
@@ -1146,12 +1144,10 @@ impl<'a, 'tcx> CastCheck<'tcx> {
         };
         let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
         let cast_ty = fcx.resolve_vars_if_possible(self.cast_ty);
-        let lint = errors::LossyProvenanceInt2Ptr { expr_ty, cast_ty, sugg };
-        fcx.tcx.emit_node_span_lint(
+        fcx.tcx.emit_node_lint(
             lint::builtin::FUZZY_PROVENANCE_CASTS,
             self.expr.hir_id,
-            self.span,
-            lint,
+            errors::LossyProvenanceInt2Ptr { span: self.span, expr_ty, cast_ty, sugg },
         );
     }