Update all lint diagnostics to store their span

Author: fmease

compiler/rustc_borrowck/src/lib.rs

@@ -408,7 +408,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

@@ -49,8 +49,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

@@ -164,18 +164,17 @@ pub(super) fn lint<'tcx, 'mir, L>(
     tcx: TyCtxtAt<'tcx>,
     machine: &CompileTimeInterpreter<'mir, '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(
+    tcx.emit_node_lint(
         lint,
         // We use the root frame for this so the crate that defines the const defines whether the
         // lint is emitted.
         machine.stack.first().and_then(|frame| frame.lint_root()).unwrap_or(CRATE_HIR_ID),
-        span,
-        decorator(frames),
+        decorator(span, frames),
     );
 }

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -109,12 +109,10 @@ fn eval_body_using_ecx<'mir, 'tcx, R: InterpretationResult<'tcx>>(
         }
         Err(InternResult::FoundBadMutablePointer) => {
             // only report mutable pointers if there were no dangling pointers
-            let err_diag = errors::MutablePtrInFinal { span: ecx.tcx.span, kind: intern_kind };
-            ecx.tcx.emit_node_span_lint(
+            ecx.tcx.emit_node_lint(
                 lint::builtin::CONST_EVAL_MUTABLE_PTR_IN_FINAL_VALUE,
                 ecx.best_lint_scope(),
-                err_diag.span,
-                err_diag,
+                errors::MutablePtrInFinal { span: ecx.tcx.span, kind: intern_kind },
             )
         }
     }

compiler/rustc_const_eval/src/const_eval/machine.rs

@@ -620,11 +620,10 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
                     .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 {
@@ -745,8 +744,8 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
         }
         // Reject writes through immutable pointers.
         if immutable {
-            super::lint(tcx, machine, WRITES_THROUGH_IMMUTABLE_POINTER, |frames| {
-                crate::errors::WriteThroughImmutablePointer { frames }
+            super::lint(tcx, machine, WRITES_THROUGH_IMMUTABLE_POINTER, |span, frames| {
+                crate::errors::WriteThroughImmutablePointer { span, frames }
             });
         }
         // Everything else is fine.

compiler/rustc_const_eval/src/errors.rs

@@ -35,10 +35,7 @@ pub(crate) struct NestedStaticInThreadLocal {
 #[derive(LintDiagnostic)]
 #[diag(const_eval_mutable_ptr_in_final)]
 pub(crate) struct MutablePtrInFinal {
-    // rust-lang/rust#122153: This was marked as `#[primary_span]` under
-    // `derive(Diagnostic)`. Since we expect we may hard-error in future, we are
-    // keeping the field (and skipping it under `derive(LintDiagnostic)`).
-    #[skip_arg]
+    #[primary_span]
     pub span: Span,
     pub kind: InternKind,
 }
@@ -228,6 +225,8 @@ pub(crate) struct InteriorMutabilityBorrow {
 #[diag(const_eval_long_running)]
 #[note]
 pub struct LongRunning {
+    #[primary_span]
+    pub span: Span,
     #[help]
     pub item_span: Span,
 }
@@ -407,6 +406,8 @@ pub struct ConstEvalError {
 #[derive(LintDiagnostic)]
 #[diag(const_eval_write_through_immutable_pointer)]
 pub struct WriteThroughImmutablePointer {
+    #[primary_span]
+    pub span: Span,
     #[subdiagnostic]
     pub frames: Vec<FrameNote>,
 }

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

@@ -287,11 +287,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

@@ -69,11 +69,6 @@ fn handle_static_mut_ref(
         } else {
             (errors::RefOfMutStaticSugg::Shared { span, var }, "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

@@ -2114,11 +2114,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 },
                 );
             }
         }
@@ -2129,6 +2128,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

@@ -510,16 +510,14 @@ 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(
+            None => tcx.emit_node_lint(
                 UNCOVERED_PARAM_IN_PROJECTION,
                 hir_id,
-                span,
                 errors::TyParamSomeLint { span, note: (), param: name },
             ),
         };