more grouping of the variants in InterpError

src/librustc/mir/interpret/error.rs

@@ -137,12 +137,13 @@ impl<'tcx> ConstEvalErr<'tcx> {
         message: &str,
         lint_root: Option<hir::HirId>,
     ) -> Result<DiagnosticBuilder<'tcx>, ErrorHandled> {
+        use InvalidProgramInfo::*;
         match self.error {
-            InterpError::Layout(LayoutError::Unknown(_)) |
-            InterpError::InvalidProgram(InvalidProgramMessage::TooGeneric) =>
+            InterpError::InvalidProgram(Layout(LayoutError::Unknown(_))) |
+            InterpError::InvalidProgram(TooGeneric) =>
                 return Err(ErrorHandled::TooGeneric),
             InterpError::Layout(LayoutError::SizeOverflow(_)) |
-            InterpError::InvalidProgram(InvalidProgramMessage::TypeckError) =>
+            InterpError::InvalidProgram(TypeckError) =>
                 return Err(ErrorHandled::Reported),
             _ => {},
         }
@@ -312,42 +313,74 @@ impl<O: fmt::Debug> fmt::Debug for PanicMessage<O> {
 }
 
 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable)]
-pub enum InvalidProgramMessage {
+pub enum InvalidProgramInfo<'tcx> {
     /// Resolution can fail if we are in a too generic context
     TooGeneric,
     /// Cannot compute this constant because it depends on another one
     /// which already produced an error
     ReferencedConstant,
     /// Abort in case type errors are reached
     TypeckError,
+    Layout(layout::LayoutError<'tcx>),
 }
 
 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable)]
-pub enum UndefinedBehaviourMessage {
+pub enum UndefinedBehaviourInfo {
+    Unreachable,
 }
 
 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable)]
-pub enum UnsupportedMessage {
+pub enum UnsupportedInfo<'tcx> {
+    FunctionAbiMismatch(Abi, Abi),
+    FunctionArgMismatch(Ty<'tcx>, Ty<'tcx>),
+    FunctionRetMismatch(Ty<'tcx>, Ty<'tcx>),
+    FunctionArgCountMismatch,
+    UnterminatedCString(Pointer),
+    DanglingPointerDeref,
+    DoubleFree,
+    InvalidMemoryAccess,
+    InvalidFunctionPointer,
+    InvalidBool,
+    InvalidDiscriminant(ScalarMaybeUndef),
+    PointerOutOfBounds {
+        ptr: Pointer,
+        msg: CheckInAllocMsg,
+        allocation_size: Size,
+    },
+    InvalidNullPointerUsage,
+    ReadPointerAsBytes,
+    ReadBytesAsPointer,
+    ReadForeignStatic,
+    InvalidPointerMath,
+    ReadUndefBytes(Size),
+    DeadLocal,
+    InvalidBoolOp(mir::BinOp),
+    InlineAsm,
+    UnimplementedTraitSelection,
+    CalledClosureAsFunction,
+    NoMirFor(String),
 }
 
 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable)]
-pub enum ResourceExhaustionMessage {
+pub enum ResourceExhaustionInfo {
+    StackFrameLimitReached,
+    InfiniteLoop,
 }
 
 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable)]
 pub enum InterpError<'tcx> {
     /// The program panicked.
     Panic(PanicMessage<u64>),
     /// The program caused undefined behavior.
-    UndefinedBehaviour(UndefinedBehaviourMessage),
+    UndefinedBehaviour(UndefinedBehaviourInfo),
     /// The program did something the interpreter does not support (some of these *might* be UB
     /// but the interpreter is not sure).
-    Unsupported(UnsupportedMessage),
+    Unsupported(UnsupportedInfo<'tcx>),
     /// The program was invalid (ill-typed, not sufficiently monomorphized, ...).
-    InvalidProgram(InvalidProgramMessage),
+    InvalidProgram(InvalidProgramInfo<'tcx>),
     /// The program exhausted the interpreter's resources (stack/heap too big,
     /// execution takes too long, ..).
-    ResourceExhaustion(ResourceExhaustionMessage),
+    ResourceExhaustion(ResourceExhaustionInfo),
 
     /// THe above 5 variants are what we want to group all the remaining InterpError variants into
 
@@ -359,37 +392,11 @@ pub enum InterpError<'tcx> {
     /// with the given status code.  Used by Miri, but not by CTFE.
     Exit(i32),
 
-    FunctionAbiMismatch(Abi, Abi),
-    FunctionArgMismatch(Ty<'tcx>, Ty<'tcx>),
-    FunctionRetMismatch(Ty<'tcx>, Ty<'tcx>),
-    FunctionArgCountMismatch,
-    NoMirFor(String),
-    UnterminatedCString(Pointer),
-    DanglingPointerDeref,
-    DoubleFree,
-    InvalidMemoryAccess,
-    InvalidFunctionPointer,
-    InvalidBool,
-    InvalidDiscriminant(ScalarMaybeUndef),
-    PointerOutOfBounds {
-        ptr: Pointer,
-        msg: CheckInAllocMsg,
-        allocation_size: Size,
-    },
-    InvalidNullPointerUsage,
-    ReadPointerAsBytes,
-    ReadBytesAsPointer,
-    ReadForeignStatic,
-    InvalidPointerMath,
-    ReadUndefBytes(Size),
-    DeadLocal,
-    InvalidBoolOp(mir::BinOp),
     Unimplemented(String),
     DerefFunctionPointer,
     ExecuteMemory,
     Intrinsic(String),
     InvalidChar(u128),
-    StackFrameLimitReached,
     OutOfTls,
     TlsOutOfBounds,
     AbiViolation(String),
@@ -398,25 +405,20 @@ pub enum InterpError<'tcx> {
         has: Align,
     },
     ValidationFailure(String),
-    CalledClosureAsFunction,
     VtableForArgumentlessMethod,
     ModifiedConstantMemory,
     ModifiedStatic,
     AssumptionNotHeld,
-    InlineAsm,
     TypeNotPrimitive(Ty<'tcx>),
     ReallocatedWrongMemoryKind(String, String),
     DeallocatedWrongMemoryKind(String, String),
     ReallocateNonBasePtr,
     DeallocateNonBasePtr,
     IncorrectAllocationInformation(Size, Size, Align, Align),
-    Layout(layout::LayoutError<'tcx>),
     HeapAllocZeroBytes,
     HeapAllocNonPowerOfTwoAlignment(u64),
-    Unreachable,
     ReadFromReturnPointer,
     PathNotFound(Vec<String>),
-    UnimplementedTraitSelection,
 }
 
 pub type InterpResult<'tcx, T = ()> = Result<T, InterpErrorInfo<'tcx>>;