code review fixes

Author: saleemjaffer

src/librustc/mir/interpret/error.rs

@@ -314,12 +314,12 @@ impl<O: fmt::Debug> fmt::Debug for PanicInfo<O> {
 
 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable)]
 pub enum InvalidProgramInfo<'tcx> {
-    /// Resolution can fail if we are in a too generic context
+    /// 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
+    /// which already produced an error.
     ReferencedConstant,
-    /// Abort in case type errors are reached
+    /// Abort in case type errors are reached.
     TypeckError,
     /// An error occurred during layout computation.
     Layout(layout::LayoutError<'tcx>),
@@ -362,7 +362,7 @@ impl fmt::Debug for UndefinedBehaviourInfo {
 }
 
 #[derive(Clone, RustcEncodable, RustcDecodable, HashStable)]
-pub enum UnsupportedInfo<'tcx> {
+pub enum UnsupportedOpInfo<'tcx> {
     /// Handle cases which for which we do not have a fixed variant.
     Unimplemented(String),
 
@@ -426,9 +426,9 @@ pub enum UnsupportedInfo<'tcx> {
     PathNotFound(Vec<String>),
 }
 
-impl fmt::Debug for UnsupportedInfo<'tcx> {
+impl fmt::Debug for UnsupportedOpInfo<'tcx> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use UnsupportedInfo::*;
+        use UnsupportedOpInfo::*;
         match self {
             PointerOutOfBounds { ptr, msg, allocation_size } => {
                 write!(f, "{} failed: pointer must be in-bounds at offset {}, \
@@ -574,7 +574,7 @@ pub enum InterpError<'tcx> {
     UndefinedBehaviour(UndefinedBehaviourInfo),
     /// The program did something the interpreter does not support (some of these *might* be UB
     /// but the interpreter is not sure).
-    Unsupported(UnsupportedInfo<'tcx>),
+    Unsupported(UnsupportedOpInfo<'tcx>),
     /// The program was invalid (ill-typed, not sufficiently monomorphized, ...).
     InvalidProgram(InvalidProgramInfo<'tcx>),
     /// The program exhausted the interpreter's resources (stack/heap too big,

src/librustc/mir/interpret/mod.rs

@@ -4,7 +4,7 @@
 macro_rules! err {
     ($($tt:tt)*) => {
         Err($crate::mir::interpret::InterpError::Unsupported(
-            $crate::mir::interpret::UnsupportedInfo::$($tt)*
+            $crate::mir::interpret::UnsupportedOpInfo::$($tt)*
         ).into())
     };
 }
@@ -52,7 +52,7 @@ mod pointer;
 
 pub use self::error::{
     InterpErrorInfo, InterpResult, InterpError, AssertMessage, ConstEvalErr, struct_error,
-    FrameInfo, ConstEvalRawResult, ConstEvalResult, ErrorHandled, PanicInfo, UnsupportedInfo,
+    FrameInfo, ConstEvalRawResult, ConstEvalResult, ErrorHandled, PanicInfo, UnsupportedOpInfo,
     InvalidProgramInfo, ResourceExhaustionInfo, UndefinedBehaviourInfo,
 };
 

src/librustc/mir/interpret/pointer.rs

@@ -196,7 +196,7 @@ impl<'tcx, Tag> Pointer<Tag> {
         msg: CheckInAllocMsg,
     ) -> InterpResult<'tcx, ()> {
         if self.offset > allocation_size {
-            err!(PointerOutOfBounds { ptr: self.erase_tag(),msg,allocation_size })
+            err!(PointerOutOfBounds { ptr: self.erase_tag(), msg, allocation_size })
         } else {
             Ok(())
         }

src/librustc_mir/const_eval.rs

@@ -24,8 +24,7 @@ use crate::interpret::{self,
     RawConst, ConstValue,
     InterpResult, InterpErrorInfo, InterpError, GlobalId, InterpCx, StackPopCleanup,
     Allocation, AllocId, MemoryKind,
-    snapshot, RefTracking, intern_const_alloc_recursive, UnsupportedInfo::*,
-    InvalidProgramInfo::*,
+    snapshot, RefTracking, intern_const_alloc_recursive, UnsupportedOpInfo,
 };
 
 /// Number of steps until the detector even starts doing anything.
@@ -184,7 +183,7 @@ fn eval_body_using_ecx<'mir, 'tcx>(
 
 impl<'tcx> Into<InterpErrorInfo<'tcx>> for ConstEvalError {
     fn into(self) -> InterpErrorInfo<'tcx> {
-        InterpError::Unsupported(MachineError(self.to_string())).into()
+        InterpError::Unsupported(UnsupportedOpInfo::MachineError(self.to_string())).into()
     }
 }
 
@@ -361,7 +360,7 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
         Ok(Some(match ecx.load_mir(instance.def) {
             Ok(body) => body,
             Err(err) => {
-                if let InterpError::Unsupported(NoMirFor(ref path)) = err.kind {
+                if let InterpError::Unsupported(UnsupportedOpInfo::NoMirFor(ref path)) = err.kind {
                     return Err(
                         ConstEvalError::NeedsRfc(format!("calling extern function `{}`", path))
                             .into(),
@@ -698,6 +697,7 @@ pub fn const_eval_raw_provider<'tcx>(
                 // promoting runtime code is only allowed to error if it references broken constants
                 // any other kind of error will be reported to the user as a deny-by-default lint
                 _ => if let Some(p) = cid.promoted {
+                    use crate::interpret::InvalidProgramInfo::*;
                     let span = tcx.promoted_mir(def_id)[p].span;
                     if let InterpError::InvalidProgram(ReferencedConstant) = err.error {
                         err.report_as_error(

src/librustc_mir/interpret/cast.rs

@@ -9,8 +9,7 @@ use rustc_apfloat::{Float, FloatConvert};
 use rustc::mir::interpret::{
     Scalar, InterpResult, Pointer, PointerArithmetic, InterpError,
 };
-use rustc::mir::{CastKind, interpret::{InvalidProgramInfo::*}};
-
+use rustc::mir::CastKind;
 
 use super::{InterpCx, Machine, PlaceTy, OpTy, Immediate, FnVal};
 
@@ -75,6 +74,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             }
 
             Pointer(PointerCast::ReifyFnPointer) => {
+                use rustc::mir::interpret::InvalidProgramInfo::TooGeneric;
                 // The src operand does not matter, just its type
                 match src.layout.ty.sty {
                     ty::FnDef(def_id, substs) => {

src/librustc_mir/interpret/eval_context.rs

@@ -17,7 +17,7 @@ use rustc::mir::interpret::{
     ErrorHandled,
     GlobalId, Scalar, Pointer, FrameInfo, AllocId,
     InterpResult, InterpError,
-    truncate, sign_extend, InvalidProgramInfo::*,
+    truncate, sign_extend, InvalidProgramInfo,
 };
 use rustc_data_structures::fx::FxHashMap;
 
@@ -190,8 +190,11 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> LayoutOf for InterpCx<'mir, 'tcx, M> {
 
     #[inline]
     fn layout_of(&self, ty: Ty<'tcx>) -> Self::TyLayout {
-        self.tcx.layout_of(self.param_env.and(ty))
-            .map_err(|layout| InterpError::InvalidProgram(Layout(layout)).into())
+        self.tcx
+            .layout_of(self.param_env.and(ty))
+            .map_err(|layout| {
+                InterpError::InvalidProgram(InvalidProgramInfo::Layout(layout)).into()
+            })
     }
 }
 
@@ -302,7 +305,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 &substs,
             )),
             None => if substs.needs_subst() {
-                err_inval!(TooGeneric).into()
+                err_inval!(TooGeneric)
             } else {
                 Ok(substs)
             },
@@ -323,7 +326,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             self.param_env,
             def_id,
             substs,
-        ).ok_or_else(|| InterpError::InvalidProgram(TooGeneric).into())
+        ).ok_or_else(|| InterpError::InvalidProgram(InvalidProgramInfo::TooGeneric).into())
     }
 
     pub fn load_mir(
@@ -694,8 +697,10 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         // `Memory::get_static_alloc` which has to use `const_eval_raw` to avoid cycles.
         let val = self.tcx.const_eval_raw(param_env.and(gid)).map_err(|err| {
             match err {
-                ErrorHandled::Reported => InterpError::InvalidProgram(ReferencedConstant),
-                ErrorHandled::TooGeneric => InterpError::InvalidProgram(TooGeneric),
+                ErrorHandled::Reported =>
+                    InterpError::InvalidProgram(InvalidProgramInfo::ReferencedConstant),
+                ErrorHandled::TooGeneric =>
+                    InterpError::InvalidProgram(InvalidProgramInfo::TooGeneric),
             }
         })?;
         self.raw_const_to_mplace(val)

src/librustc_mir/interpret/intern.rs

@@ -5,7 +5,7 @@
 
 use rustc::ty::{Ty, TyCtxt, ParamEnv, self};
 use rustc::mir::interpret::{
-    InterpResult, ErrorHandled, UnsupportedInfo::*,
+    InterpResult, ErrorHandled, UnsupportedOpInfo,
 };
 use rustc::hir;
 use rustc::hir::def_id::DefId;
@@ -293,7 +293,7 @@ pub fn intern_const_alloc_recursive(
         if let Err(error) = interned {
             // This can happen when e.g. the tag of an enum is not a valid discriminant. We do have
             // to read enum discriminants in order to find references in enum variant fields.
-            if let InterpError::Unsupported(ValidationFailure(_)) = error.kind {
+            if let InterpError::Unsupported(UnsupportedOpInfo::ValidationFailure(_)) = error.kind {
                 let err = crate::const_eval::error_to_const_error(&ecx, error);
                 match err.struct_error(ecx.tcx, "it is undefined behavior to use this value") {
                     Ok(mut diag) => {

src/librustc_mir/interpret/intrinsics.rs

@@ -7,7 +7,7 @@ use rustc::ty;
 use rustc::ty::layout::{LayoutOf, Primitive, Size};
 use rustc::mir::BinOp;
 use rustc::mir::interpret::{
-    InterpResult, InterpError, Scalar, PanicInfo, UnsupportedInfo::*,
+    InterpResult, InterpError, Scalar, PanicInfo, UnsupportedOpInfo,
 };
 
 use super::{
@@ -100,7 +100,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 let bits = self.read_scalar(args[0])?.to_bits(layout_of.size)?;
                 let kind = match layout_of.abi {
                     ty::layout::Abi::Scalar(ref scalar) => scalar.value,
-                    _ => Err(InterpError::Unsupported(TypeNotPrimitive(ty)))?,
+                    _ => Err(InterpError::Unsupported(UnsupportedOpInfo::TypeNotPrimitive(ty)))?,
                 };
                 let out_val = if intrinsic_name.ends_with("_nonzero") {
                     if bits == 0 {

src/librustc_mir/interpret/machine.rs

@@ -11,7 +11,7 @@ use rustc::ty::{self, TyCtxt};
 
 use super::{
     Allocation, AllocId, InterpResult, InterpError, Scalar, AllocationExtra,
-    InterpCx, PlaceTy, OpTy, ImmTy, MemoryKind, Pointer, Memory, UnsupportedInfo::*
+    InterpCx, PlaceTy, OpTy, ImmTy, MemoryKind, Pointer, Memory, UnsupportedOpInfo,
 };
 
 /// Whether this kind of memory is allowed to leak
@@ -240,9 +240,9 @@ pub trait Machine<'mir, 'tcx>: Sized {
         int: u64,
     ) -> InterpResult<'tcx, Pointer<Self::PointerTag>> {
         Err((if int == 0 {
-            InterpError::Unsupported(InvalidNullPointerUsage)
+            InterpError::Unsupported(UnsupportedOpInfo::InvalidNullPointerUsage)
         } else {
-            InterpError::Unsupported(ReadBytesAsPointer)
+            InterpError::Unsupported(UnsupportedOpInfo::ReadBytesAsPointer)
         }).into())
     }
 

src/librustc_mir/interpret/memory.rs

@@ -19,8 +19,7 @@ use syntax::ast::Mutability;
 use super::{
     Pointer, AllocId, Allocation, GlobalId, AllocationExtra,
     InterpResult, Scalar, InterpError, GlobalAlloc, PointerArithmetic,
-    Machine, AllocMap, MayLeak, ErrorHandled, CheckInAllocMsg, UnsupportedInfo::*,
-    InvalidProgramInfo::*
+    Machine, AllocMap, MayLeak, ErrorHandled, CheckInAllocMsg, InvalidProgramInfo,
 };
 
 #[derive(Debug, PartialEq, Eq, Copy, Clone, Hash)]
@@ -438,9 +437,11 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
                             assert!(tcx.is_static(def_id));
                             match err {
                                 ErrorHandled::Reported =>
-                                    InterpError::InvalidProgram(ReferencedConstant),
+                                    InterpError::InvalidProgram(
+                                        InvalidProgramInfo::ReferencedConstant
+                                    ),
                                 ErrorHandled::TooGeneric =>
-                                    InterpError::InvalidProgram(TooGeneric),
+                                    InterpError::InvalidProgram(InvalidProgramInfo::TooGeneric),
                             }
                         })?;
                     // Make sure we use the ID of the resolved memory, not the lazy one!
@@ -590,7 +591,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> Memory<'mir, 'tcx, M> {
         } else {
             match self.tcx.alloc_map.lock().get(id) {
                 Some(GlobalAlloc::Function(instance)) => Ok(FnVal::Instance(instance)),
-                _ => Err(InterpError::Unsupported(ExecuteMemory).into()),
+                _ => err!(ExecuteMemory),
             }
         }
     }