Pull out const error reporting into its own function

Author: oli-obk

compiler/rustc_const_eval/src/const_eval/error.rs

@@ -117,7 +117,7 @@ where
 /// This will use the `mk` function for creating the error which will get passed labels according to
 /// the `InterpError` and the span and a stacktrace of current execution according to
 /// `get_span_and_frames`.
-pub(super) fn report<'tcx, C, F, E>(
+pub(crate) fn report<'tcx, C, F, E>(
     tcx: TyCtxt<'tcx>,
     error: InterpError<'tcx>,
     span: Option<Span>,

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -4,7 +4,6 @@ use either::{Left, Right};
 
 use rustc_hir::def::DefKind;
 use rustc_middle::mir::interpret::ErrorHandled;
-use rustc_middle::mir::pretty::write_allocation_bytes;
 use rustc_middle::mir::{self, ConstAlloc, ConstValue};
 use rustc_middle::traits::Reveal;
 use rustc_middle::ty::layout::LayoutOf;
@@ -19,8 +18,8 @@ use crate::errors;
 use crate::errors::ConstEvalError;
 use crate::interpret::eval_nullary_intrinsic;
 use crate::interpret::{
-    intern_const_alloc_recursive, GlobalId, Immediate, InternKind, InterpCx, InterpError,
-    InterpResult, MPlaceTy, MemoryKind, OpTy, StackPopCleanup,
+    intern_const_alloc_recursive, GlobalId, Immediate, InternKind, InterpCx, InterpResult,
+    MPlaceTy, MemoryKind, OpTy, StackPopCleanup,
 };
 
 // Returns a pointer to where the result lives
@@ -337,36 +336,7 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
 
             // Validation failed, report an error.
             if let Err(error) = validation {
-                let (error, backtrace) = error.into_parts();
-                backtrace.print_backtrace();
-
-                let ub_note = matches!(error, InterpError::UndefinedBehavior(_)).then(|| {});
-
-                let alloc = ecx.tcx.global_alloc(alloc_id).unwrap_memory().inner();
-                let mut bytes = String::new();
-                if alloc.size() != abi::Size::ZERO {
-                    bytes = "\n".into();
-                    // FIXME(translation) there might be pieces that are translatable.
-                    write_allocation_bytes(*ecx.tcx, alloc, &mut bytes, "    ").unwrap();
-                }
-                let raw_bytes = errors::RawBytesNote {
-                    size: alloc.size().bytes(),
-                    align: alloc.align.bytes(),
-                    bytes,
-                };
-
-                Err(super::report(
-                    *ecx.tcx,
-                    error,
-                    None,
-                    || super::get_span_and_frames(&ecx),
-                    move |span, frames| errors::UndefinedBehavior {
-                        span,
-                        ub_note,
-                        frames,
-                        raw_bytes,
-                    },
-                ))
+                Err(ecx.const_report_error(error, alloc_id))
             } else {
                 // Convert to raw constant
                 Ok(ConstAlloc { alloc_id, ty: mplace.layout.ty })

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -13,18 +13,21 @@ use rustc_ast::Mutability;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_hir as hir;
 use rustc_middle::mir::interpret::{
-    ExpectedKind, InterpError, InvalidMetaKind, Misalignment, PointerKind, ValidationErrorInfo,
-    ValidationErrorKind, ValidationErrorKind::*,
+    ErrorHandled, ExpectedKind, InterpError, InterpErrorInfo, InvalidMetaKind, Misalignment,
+    PointerKind, ValidationErrorInfo, ValidationErrorKind, ValidationErrorKind::*,
 };
+use rustc_middle::mir::pretty::write_allocation_bytes;
 use rustc_middle::ty;
 use rustc_middle::ty::layout::{LayoutOf, TyAndLayout};
 use rustc_span::symbol::{sym, Symbol};
 use rustc_target::abi::{
-    Abi, FieldIdx, Scalar as ScalarAbi, Size, VariantIdx, Variants, WrappingRange,
+    self, Abi, FieldIdx, Scalar as ScalarAbi, Size, VariantIdx, Variants, WrappingRange,
 };
 
 use std::hash::Hash;
 
+use crate::errors;
+
 use super::{
     AllocId, CheckInAllocMsg, GlobalAlloc, ImmTy, Immediate, InterpCx, InterpResult, MPlaceTy,
     Machine, MemPlaceMeta, OpTy, Pointer, Projectable, Scalar, ValueVisitor,
@@ -967,6 +970,36 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         Ok(())
     }
 
+    #[inline(always)]
+    pub fn const_report_error(
+        &self,
+        error: InterpErrorInfo<'tcx>,
+        alloc_id: AllocId,
+    ) -> ErrorHandled {
+        let (error, backtrace) = error.into_parts();
+        backtrace.print_backtrace();
+
+        let ub_note = matches!(error, InterpError::UndefinedBehavior(_)).then(|| {});
+
+        let alloc = self.tcx.global_alloc(alloc_id).unwrap_memory().inner();
+        let mut bytes = String::new();
+        if alloc.size() != abi::Size::ZERO {
+            bytes = "\n".into();
+            // FIXME(translation) there might be pieces that are translatable.
+            write_allocation_bytes(*self.tcx, alloc, &mut bytes, "    ").unwrap();
+        }
+        let raw_bytes =
+            errors::RawBytesNote { size: alloc.size().bytes(), align: alloc.align.bytes(), bytes };
+
+        crate::const_eval::report(
+            *self.tcx,
+            error,
+            None,
+            || crate::const_eval::get_span_and_frames(self),
+            move |span, frames| errors::UndefinedBehavior { span, ub_note, frames, raw_bytes },
+        )
+    }
+
     /// This function checks the data at `op` to be runtime-valid.
     /// `op` is assumed to cover valid memory if it is an indirect operand.
     /// It will error if the bits at the destination do not match the ones described by the layout.