fixing fallout due to InterpError refactor

Author: saleemjaffer

src/librustc/mir/interpret/allocation.rs

@@ -4,6 +4,7 @@ use super::{
     Pointer, InterpResult, AllocId, ScalarMaybeUndef, write_target_uint, read_target_uint, Scalar,
 };
 
+use super::error::UnsupportedInfo::*;
 use crate::ty::layout::{Size, Align};
 use syntax::ast::Mutability;
 use std::iter;
@@ -244,7 +245,7 @@ impl<'tcx, Tag: Copy, Extra: AllocationExtra<Tag>> Allocation<Tag, Extra> {
                 Ok(&self.get_bytes(cx, ptr, size_with_null)?[..size])
             }
             // This includes the case where `offset` is out-of-bounds to begin with.
-            None => err!(UnterminatedCString(ptr.erase_tag())),
+            None => err!(Unsupported(UnterminatedCString(ptr.erase_tag()))),
         }
     }
 
@@ -446,7 +447,7 @@ impl<'tcx, Tag: Copy, Extra> Allocation<Tag, Extra> {
         if self.relocations(cx, ptr, size).is_empty() {
             Ok(())
         } else {
-            err!(ReadPointerAsBytes)
+            err!(Unsupported(ReadPointerAsBytes))
         }
     }
 
@@ -516,7 +517,7 @@ impl<'tcx, Tag, Extra> Allocation<Tag, Extra> {
         self.undef_mask.is_range_defined(
             ptr.offset,
             ptr.offset + size,
-        ).or_else(|idx| err!(ReadUndefBytes(idx)))
+        ).or_else(|idx| err!(Unsupported(ReadUndefBytes(idx))))
     }
 
     pub fn mark_definedness(

src/librustc/mir/interpret/error.rs

@@ -142,7 +142,7 @@ impl<'tcx> ConstEvalErr<'tcx> {
             InterpError::InvalidProgram(Layout(LayoutError::Unknown(_))) |
             InterpError::InvalidProgram(TooGeneric) =>
                 return Err(ErrorHandled::TooGeneric),
-            InterpError::Layout(LayoutError::SizeOverflow(_)) |
+            InterpError::InvalidProgram(Layout(LayoutError::SizeOverflow(_))) |
             InterpError::InvalidProgram(TypeckError) =>
                 return Err(ErrorHandled::Reported),
             _ => {},
@@ -325,16 +325,47 @@ pub enum InvalidProgramInfo<'tcx> {
     Layout(layout::LayoutError<'tcx>),
 }
 
+impl fmt::Debug for InvalidProgramInfo<'tcx> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use InvalidProgramInfo::*;
+        match self {
+            TooGeneric =>
+                write!(f, "encountered overly generic constant"),
+            ReferencedConstant =>
+                write!(f, "referenced constant has errors"),
+            TypeckError =>
+                write!(f, "encountered constants with type errors, stopping evaluation"),
+            Layout(ref err) =>
+                write!(f, "rustc layout computation failed: {:?}", err),
+        }
+    }
+}
+
 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable)]
 pub enum UndefinedBehaviourInfo {
-    /// Handle cases which for which we do not have a fixed variant
+    /// Handle cases which for which we do not have a fixed variant.
     Ub(String),
+    /// Unreachable code was executed.
     Unreachable,
 }
 
+impl fmt::Debug for UndefinedBehaviourInfo {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use UndefinedBehaviourInfo::*;
+        match self {
+            Ub(ref msg) =>
+                write!(f, "{}", msg),
+            Unreachable =>
+                write!(f, "entered unreachable code"),
+        }
+    }
+}
+
 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable)]
 pub enum UnsupportedInfo<'tcx> {
     Unimplemented(String),
+
+    // -- Everything below is not classified yet --
     FunctionAbiMismatch(Abi, Abi),
     FunctionArgMismatch(Ty<'tcx>, Ty<'tcx>),
     FunctionRetMismatch(Ty<'tcx>, Ty<'tcx>),
@@ -400,6 +431,19 @@ pub enum ResourceExhaustionInfo {
     InfiniteLoop,
 }
 
+impl fmt::Debug for ResourceExhaustionInfo {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        use ResourceExhaustionInfo::*;
+        match self {
+            StackFrameLimitReached =>
+                write!(f, "reached the configured maximum number of stack frames"),
+            InfiniteLoop =>
+                write!(f, "duplicate interpreter state observed here, const evaluation will never \
+                    terminate"),
+        }
+    }
+}
+
 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable)]
 pub enum InterpError<'tcx> {
     /// The program panicked.
@@ -431,139 +475,131 @@ impl fmt::Display for InterpError<'_> {
 impl fmt::Debug for InterpError<'_> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         use InterpError::*;
+        use UnsupportedInfo::*;
         match *self {
-            PointerOutOfBounds { ptr, msg, allocation_size } => {
+            Unsupported(PointerOutOfBounds { ptr, msg, allocation_size }) => {
                 write!(f, "{} failed: pointer must be in-bounds at offset {}, \
                           but is outside bounds of allocation {} which has size {}",
                     msg, ptr.offset.bytes(), ptr.alloc_id, allocation_size.bytes())
             },
-            ValidationFailure(ref err) => {
+            Unsupported(ValidationFailure(ref err)) => {
                 write!(f, "type validation failed: {}", err)
             }
-            NoMirFor(ref func) => write!(f, "no mir for `{}`", func),
-            FunctionAbiMismatch(caller_abi, callee_abi) =>
+            Unsupported(NoMirFor(ref func)) => write!(f, "no mir for `{}`", func),
+            Unsupported(FunctionAbiMismatch(caller_abi, callee_abi)) =>
                 write!(f, "tried to call a function with ABI {:?} using caller ABI {:?}",
                     callee_abi, caller_abi),
-            FunctionArgMismatch(caller_ty, callee_ty) =>
+            Unsupported(FunctionArgMismatch(caller_ty, callee_ty)) =>
                 write!(f, "tried to call a function with argument of type {:?} \
                            passing data of type {:?}",
                     callee_ty, caller_ty),
-            FunctionRetMismatch(caller_ty, callee_ty) =>
+            Unsupported(FunctionRetMismatch(caller_ty, callee_ty)) =>
                 write!(f, "tried to call a function with return type {:?} \
                            passing return place of type {:?}",
                     callee_ty, caller_ty),
-            FunctionArgCountMismatch =>
+            Unsupported(FunctionArgCountMismatch) =>
                 write!(f, "tried to call a function with incorrect number of arguments"),
-            ReallocatedWrongMemoryKind(ref old, ref new) =>
+            Unsupported(ReallocatedWrongMemoryKind(ref old, ref new)) =>
                 write!(f, "tried to reallocate memory from {} to {}", old, new),
-            DeallocatedWrongMemoryKind(ref old, ref new) =>
+            Unsupported(DeallocatedWrongMemoryKind(ref old, ref new)) =>
                 write!(f, "tried to deallocate {} memory but gave {} as the kind", old, new),
-            InvalidChar(c) =>
+            Unsupported(InvalidChar(c)) =>
                 write!(f, "tried to interpret an invalid 32-bit value as a char: {}", c),
-            AlignmentCheckFailed { required, has } =>
+            Unsupported(AlignmentCheckFailed { required, has }) =>
                write!(f, "tried to access memory with alignment {}, but alignment {} is required",
                       has.bytes(), required.bytes()),
-            TypeNotPrimitive(ty) =>
+            Unsupported(TypeNotPrimitive(ty)) =>
                 write!(f, "expected primitive type, got {}", ty),
-            Layout(ref err) =>
-                write!(f, "rustc layout computation failed: {:?}", err),
-            PathNotFound(ref path) =>
+            Unsupported(PathNotFound(ref path)) =>
                 write!(f, "Cannot find path {:?}", path),
-            IncorrectAllocationInformation(size, size2, align, align2) =>
+            Unsupported(IncorrectAllocationInformation(size, size2, align, align2)) =>
                 write!(f, "incorrect alloc info: expected size {} and align {}, \
                            got size {} and align {}",
                     size.bytes(), align.bytes(), size2.bytes(), align2.bytes()),
-            InvalidDiscriminant(val) =>
+            Unsupported(InvalidDiscriminant(val)) =>
                 write!(f, "encountered invalid enum discriminant {}", val),
-            Exit(code) =>
-                write!(f, "exited with status code {}", code),
-            InvalidMemoryAccess =>
+            Unsupported(InvalidMemoryAccess) =>
                 write!(f, "tried to access memory through an invalid pointer"),
-            DanglingPointerDeref =>
+            Unsupported(DanglingPointerDeref) =>
                 write!(f, "dangling pointer was dereferenced"),
-            DoubleFree =>
+            Unsupported(DoubleFree) =>
                 write!(f, "tried to deallocate dangling pointer"),
-            InvalidFunctionPointer =>
+            Unsupported(InvalidFunctionPointer) =>
                 write!(f, "tried to use a function pointer after offsetting it"),
-            InvalidBool =>
+            Unsupported(InvalidBool) =>
                 write!(f, "invalid boolean value read"),
-            InvalidNullPointerUsage =>
+            Unsupported(InvalidNullPointerUsage) =>
                 write!(f, "invalid use of NULL pointer"),
-            ReadPointerAsBytes =>
+            Unsupported(ReadPointerAsBytes) =>
                 write!(f, "a raw memory access tried to access part of a pointer value as raw \
                     bytes"),
-            ReadBytesAsPointer =>
+            Unsupported(ReadBytesAsPointer) =>
                 write!(f, "a memory access tried to interpret some bytes as a pointer"),
-            ReadForeignStatic =>
+            Unsupported(ReadForeignStatic) =>
                 write!(f, "tried to read from foreign (extern) static"),
-            InvalidPointerMath =>
+            Unsupported(InvalidPointerMath) =>
                 write!(f, "attempted to do invalid arithmetic on pointers that would leak base \
                     addresses, e.g., comparing pointers into different allocations"),
-            DeadLocal =>
+            Unsupported(DeadLocal) =>
                 write!(f, "tried to access a dead local variable"),
-            DerefFunctionPointer =>
+            Unsupported(DerefFunctionPointer) =>
                 write!(f, "tried to dereference a function pointer"),
-            ExecuteMemory =>
+            Unsupported(ExecuteMemory) =>
                 write!(f, "tried to treat a memory pointer as a function pointer"),
-            StackFrameLimitReached =>
-                write!(f, "reached the configured maximum number of stack frames"),
-            OutOfTls =>
+            Unsupported(OutOfTls) =>
                 write!(f, "reached the maximum number of representable TLS keys"),
-            TlsOutOfBounds =>
+            Unsupported(TlsOutOfBounds) =>
                 write!(f, "accessed an invalid (unallocated) TLS key"),
-            CalledClosureAsFunction =>
+            Unsupported(CalledClosureAsFunction) =>
                 write!(f, "tried to call a closure through a function pointer"),
-            VtableForArgumentlessMethod =>
+            Unsupported(VtableForArgumentlessMethod) =>
                 write!(f, "tried to call a vtable function without arguments"),
-            ModifiedConstantMemory =>
+            Unsupported(ModifiedConstantMemory) =>
                 write!(f, "tried to modify constant memory"),
-            ModifiedStatic =>
+            Unsupported(ModifiedStatic) =>
                 write!(f, "tried to modify a static's initial value from another static's \
                     initializer"),
-            AssumptionNotHeld =>
+            Unsupported(AssumptionNotHeld) =>
                 write!(f, "`assume` argument was false"),
-            InlineAsm =>
+            Unsupported(InlineAsm) =>
                 write!(f, "miri does not support inline assembly"),
-            ReallocateNonBasePtr =>
+            Unsupported(ReallocateNonBasePtr) =>
                 write!(f, "tried to reallocate with a pointer not to the beginning of an \
                     existing object"),
-            DeallocateNonBasePtr =>
+            Unsupported(DeallocateNonBasePtr) =>
                 write!(f, "tried to deallocate with a pointer not to the beginning of an \
                     existing object"),
-            HeapAllocZeroBytes =>
+            Unsupported(HeapAllocZeroBytes) =>
                 write!(f, "tried to re-, de- or allocate zero bytes on the heap"),
-            Unreachable =>
-                write!(f, "entered unreachable code"),
-            ReadFromReturnPointer =>
+            Unsupported(ReadFromReturnPointer) =>
                 write!(f, "tried to read from the return pointer"),
-            UnimplementedTraitSelection =>
+            Unsupported(UnimplementedTraitSelection) =>
                 write!(f, "there were unresolved type arguments during trait selection"),
-            TypeckError =>
-                write!(f, "encountered constants with type errors, stopping evaluation"),
-            TooGeneric =>
-                write!(f, "encountered overly generic constant"),
-            ReferencedConstant =>
-                write!(f, "referenced constant has errors"),
-            InfiniteLoop =>
-                write!(f, "duplicate interpreter state observed here, const evaluation will never \
-                    terminate"),
-            InvalidBoolOp(_) =>
+            Unsupported(InvalidBoolOp(_)) =>
                 write!(f, "invalid boolean operation"),
-            UnterminatedCString(_) =>
+            Unsupported(UnterminatedCString(_)) =>
                 write!(f, "attempted to get length of a null terminated string, but no null \
                     found before end of allocation"),
-            ReadUndefBytes(_) =>
+            Unsupported(ReadUndefBytes(_)) =>
                 write!(f, "attempted to read undefined bytes"),
-            HeapAllocNonPowerOfTwoAlignment(_) =>
+            Unsupported(HeapAllocNonPowerOfTwoAlignment(_)) =>
                 write!(f, "tried to re-, de-, or allocate heap memory with alignment that is \
                     not a power of two"),
-            MachineError(ref msg) |
-            Unimplemented(ref msg) |
-            AbiViolation(ref msg) |
-            Intrinsic(ref msg) =>
+            Unsupported(MachineError(ref msg)) |
+            Unsupported(Unimplemented(ref msg)) |
+            Unsupported(AbiViolation(ref msg)) |
+            Unsupported(Intrinsic(ref msg)) =>
                 write!(f, "{}", msg),
+            InvalidProgram(ref msg) =>
+                write!(f, "{:?}", msg),
+            UndefinedBehaviour(ref msg) =>
+                write!(f, "{:?}", msg),
+            ResourceExhaustion(ref msg) =>
+                write!(f, "{:?}", msg),
             Panic(ref msg) =>
                 write!(f, "{:?}", msg),
+            Exit(code) =>
+                write!(f, "exited with status code {}", code),
         }
     }
 }

src/librustc/mir/interpret/mod.rs

@@ -12,7 +12,8 @@ mod pointer;
 
 pub use self::error::{
     InterpErrorInfo, InterpResult, InterpError, AssertMessage, ConstEvalErr, struct_error,
-    FrameInfo, ConstEvalRawResult, ConstEvalResult, ErrorHandled, PanicMessage
+    FrameInfo, ConstEvalRawResult, ConstEvalResult, ErrorHandled, PanicMessage, UnsupportedInfo,
+    InvalidProgramInfo, ResourceExhaustionInfo, UndefinedBehaviourInfo,
 };
 
 pub use self::value::{Scalar, ScalarMaybeUndef, RawConst, ConstValue};

src/librustc/mir/interpret/pointer.rs

@@ -1,5 +1,6 @@
 use std::fmt::{self, Display};
 
+use super::error::UnsupportedInfo::*;
 use crate::mir;
 use crate::ty::layout::{self, HasDataLayout, Size};
 use rustc_macros::HashStable;
@@ -198,11 +199,11 @@ impl<'tcx, Tag> Pointer<Tag> {
         msg: CheckInAllocMsg,
     ) -> InterpResult<'tcx, ()> {
         if self.offset > allocation_size {
-            err!(PointerOutOfBounds {
+            err!(Unsupported(PointerOutOfBounds {
                 ptr: self.erase_tag(),
                 msg,
                 allocation_size,
-            })
+            }))
         } else {
             Ok(())
         }

src/librustc/mir/interpret/value.rs

@@ -2,6 +2,7 @@ use std::fmt;
 use rustc_macros::HashStable;
 use rustc_apfloat::{Float, ieee::{Double, Single}};
 
+use super::error::UnsupportedInfo::*;
 use crate::ty::{Ty, InferConst, ParamConst, layout::{HasDataLayout, Size, Align}, subst::SubstsRef};
 use crate::ty::PlaceholderConst;
 use crate::hir::def_id::DefId;
@@ -360,7 +361,7 @@ impl<'tcx, Tag> Scalar<Tag> {
                 Scalar::check_data(data, size);
                 Ok(data)
             }
-            Scalar::Ptr(_) => err!(ReadPointerAsBytes),
+            Scalar::Ptr(_) => err!(Unsupported(ReadPointerAsBytes)),
         }
     }
 
@@ -373,8 +374,8 @@ impl<'tcx, Tag> Scalar<Tag> {
     #[inline]
     pub fn to_ptr(self) -> InterpResult<'tcx, Pointer<Tag>> {
         match self {
-            Scalar::Raw { data: 0, .. } => err!(InvalidNullPointerUsage),
-            Scalar::Raw { .. } => err!(ReadBytesAsPointer),
+            Scalar::Raw { data: 0, .. } => err!(Unsupported(InvalidNullPointerUsage)),
+            Scalar::Raw { .. } => err!(Unsupported(ReadBytesAsPointer)),
             Scalar::Ptr(p) => Ok(p),
         }
     }
@@ -406,15 +407,15 @@ impl<'tcx, Tag> Scalar<Tag> {
         match self {
             Scalar::Raw { data: 0, size: 1 } => Ok(false),
             Scalar::Raw { data: 1, size: 1 } => Ok(true),
-            _ => err!(InvalidBool),
+            _ => err!(Unsupported(InvalidBool)),
         }
     }
 
     pub fn to_char(self) -> InterpResult<'tcx, char> {
         let val = self.to_u32()?;
         match ::std::char::from_u32(val) {
             Some(c) => Ok(c),
-            None => err!(InvalidChar(val as u128)),
+            None => err!(Unsupported(InvalidChar(val as u128))),
         }
     }
 
@@ -537,7 +538,7 @@ impl<'tcx, Tag> ScalarMaybeUndef<Tag> {
     pub fn not_undef(self) -> InterpResult<'static, Scalar<Tag>> {
         match self {
             ScalarMaybeUndef::Scalar(scalar) => Ok(scalar),
-            ScalarMaybeUndef::Undef => err!(ReadUndefBytes(Size::from_bytes(0))),
+            ScalarMaybeUndef::Undef => err!(Unsupported(ReadUndefBytes(Size::from_bytes(0)))),
         }
     }