make const_err a hard error

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -2,7 +2,6 @@ use std::error::Error;
 use std::fmt;
 
 use rustc_errors::Diagnostic;
-use rustc_hir as hir;
 use rustc_middle::mir::AssertKind;
 use rustc_middle::ty::{layout::LayoutError, query::TyCtxtAt, ConstInt};
 use rustc_span::{Span, Symbol};
@@ -23,11 +22,7 @@ pub enum ConstEvalErrKind {
     Abort(String),
 }
 
-impl MachineStopType for ConstEvalErrKind {
-    fn is_hard_err(&self) -> bool {
-        matches!(self, Self::Panic { .. })
-    }
-}
+impl MachineStopType for ConstEvalErrKind {}
 
 // The errors become `MachineStop` with plain strings when being raised.
 // `ConstEvalErr` (in `librustc_middle/mir/interpret/error.rs`) knows to
@@ -87,48 +82,10 @@ impl<'tcx> ConstEvalErr<'tcx> {
         ConstEvalErr { error: error.into_kind(), stacktrace, span }
     }
 
-    pub fn struct_error(
-        &self,
-        tcx: TyCtxtAt<'tcx>,
-        message: &str,
-        decorate: impl FnOnce(&mut Diagnostic),
-    ) -> ErrorHandled {
-        self.struct_generic(tcx, message, decorate, None)
-    }
-
     pub fn report_as_error(&self, tcx: TyCtxtAt<'tcx>, message: &str) -> ErrorHandled {
         self.struct_error(tcx, message, |_| {})
     }
 
-    pub fn report_as_lint(
-        &self,
-        tcx: TyCtxtAt<'tcx>,
-        message: &str,
-        lint_root: hir::HirId,
-        span: Option<Span>,
-    ) -> ErrorHandled {
-        self.struct_generic(
-            tcx,
-            message,
-            |lint: &mut Diagnostic| {
-                // Apply the span.
-                if let Some(span) = span {
-                    let primary_spans = lint.span.primary_spans().to_vec();
-                    // point at the actual error as the primary span
-                    lint.replace_span_with(span);
-                    // point to the `const` statement as a secondary span
-                    // they don't have any label
-                    for sp in primary_spans {
-                        if sp != span {
-                            lint.span_label(sp, "");
-                        }
-                    }
-                }
-            },
-            Some(lint_root),
-        )
-    }
-
     /// Create a diagnostic for this const eval error.
     ///
     /// Sets the message passed in via `message` and adds span labels with detailed error
@@ -137,13 +94,12 @@ impl<'tcx> ConstEvalErr<'tcx> {
     ///
     /// If `lint_root.is_some()` report it as a lint, else report it as a hard error.
     /// (Except that for some errors, we ignore all that -- see `must_error` below.)
-    #[instrument(skip(self, tcx, decorate, lint_root), level = "debug")]
-    fn struct_generic(
+    #[instrument(skip(self, tcx, decorate), level = "debug")]
+    pub fn struct_error(
         &self,
         tcx: TyCtxtAt<'tcx>,
         message: &str,
         decorate: impl FnOnce(&mut Diagnostic),
-        lint_root: Option<hir::HirId>,
     ) -> ErrorHandled {
         let finish = |err: &mut Diagnostic, span_msg: Option<String>| {
             trace!("reporting const eval failure at {:?}", self.span);
@@ -224,27 +180,9 @@ impl<'tcx> ConstEvalErr<'tcx> {
 
         let err_msg = self.error.to_string();
 
-        // Regular case - emit a lint.
-        if let Some(lint_root) = lint_root {
-            // Report as lint.
-            let hir_id =
-                self.stacktrace.iter().rev().find_map(|frame| frame.lint_root).unwrap_or(lint_root);
-            tcx.struct_span_lint_hir(
-                rustc_session::lint::builtin::CONST_ERR,
-                hir_id,
-                tcx.span,
-                message,
-                |lint| {
-                    finish(lint, Some(err_msg));
-                    lint
-                },
-            );
-            ErrorHandled::Linted
-        } else {
-            // Report as hard error.
-            let mut err = struct_error(tcx, message);
-            finish(&mut err, Some(err_msg));
-            ErrorHandled::Reported(err.emit())
-        }
+        // Report as hard error.
+        let mut err = struct_error(tcx, message);
+        finish(&mut err, Some(err_msg));
+        ErrorHandled::Reported(err.emit())
     }
 }