Pull mplace validation logic out into an interpreter method

Author: oli-obk

compiler/rustc_const_eval/src/const_eval/eval_queries.rs

@@ -3,7 +3,7 @@ use std::mem;
 use either::{Left, Right};
 
 use rustc_hir::def::DefKind;
-use rustc_middle::mir::interpret::{ErrorHandled, InterpErrorInfo};
+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;
@@ -19,8 +19,8 @@ use crate::errors;
 use crate::errors::ConstEvalError;
 use crate::interpret::eval_nullary_intrinsic;
 use crate::interpret::{
-    intern_const_alloc_recursive, CtfeValidationMode, GlobalId, Immediate, InternKind, InterpCx,
-    InterpError, InterpResult, MPlaceTy, MemoryKind, OpTy, RefTracking, StackPopCleanup,
+    intern_const_alloc_recursive, GlobalId, Immediate, InternKind, InterpCx, InterpError,
+    InterpResult, MPlaceTy, MemoryKind, OpTy, StackPopCleanup,
 };
 
 // Returns a pointer to where the result lives
@@ -331,25 +331,8 @@ pub fn eval_to_allocation_raw_provider<'tcx>(
         Ok(mplace) => {
             // Since evaluation had no errors, validate the resulting constant.
             // This is a separate `try` block to provide more targeted error reporting.
-            let validation: Result<_, InterpErrorInfo<'_>> = try {
-                let mut ref_tracking = RefTracking::new(mplace.clone());
-                let mut inner = false;
-                while let Some((mplace, path)) = ref_tracking.todo.pop() {
-                    let mode = if is_static {
-                        if cid.promoted.is_some() {
-                            // Promoteds in statics are allowed to point to statics.
-                            CtfeValidationMode::Const { inner, allow_static_ptrs: true }
-                        } else {
-                            // a `static`
-                            CtfeValidationMode::Regular
-                        }
-                    } else {
-                        CtfeValidationMode::Const { inner, allow_static_ptrs: false }
-                    };
-                    ecx.const_validate_operand(&mplace.into(), path, &mut ref_tracking, mode)?;
-                    inner = true;
-                }
-            };
+            let validation = ecx.const_validate_mplace(&mplace, is_static, cid.promoted.is_some());
+
             let alloc_id = mplace.ptr().provenance.unwrap();
 
             // Validation failed, report an error.

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -929,7 +929,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     /// - no pointers to statics.
     /// - no `UnsafeCell` or non-ZST `&mut`.
     #[inline(always)]
-    pub fn const_validate_operand(
+    fn const_validate_operand(
         &self,
         op: &OpTy<'tcx, M::Provenance>,
         path: Vec<PathElem>,
@@ -939,6 +939,34 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         self.validate_operand_internal(op, path, Some(ref_tracking), Some(ctfe_mode))
     }
 
+    #[inline(always)]
+    pub fn const_validate_mplace(
+        &self,
+        mplace: &MPlaceTy<'tcx, M::Provenance>,
+        is_static: bool,
+        is_promoted: bool,
+    ) -> InterpResult<'tcx> {
+        let mut ref_tracking = RefTracking::new(mplace.clone());
+        let mut inner = false;
+        while let Some((mplace, path)) = ref_tracking.todo.pop() {
+            let mode = if is_static {
+                if is_promoted {
+                    // Promoteds in statics are allowed to point to statics.
+                    CtfeValidationMode::Const { inner, allow_static_ptrs: true }
+                } else {
+                    // a `static`
+                    CtfeValidationMode::Regular
+                }
+            } else {
+                CtfeValidationMode::Const { inner, allow_static_ptrs: false }
+            };
+            self.const_validate_operand(&mplace.into(), path, &mut ref_tracking, mode)?;
+            inner = true;
+        }
+
+        Ok(())
+    }
+
     /// 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.