Fix an ICE encountered in clippy that will be possible to trigger in rustc in the future

src/librustc_mir/const_eval.rs

@@ -505,7 +505,7 @@ pub fn const_field<'tcx>(
     trace!("const_field: {:?}, {:?}", field, value);
     let ecx = mk_eval_cx(tcx, DUMMY_SP, param_env);
     // get the operand again
-    let op = ecx.eval_const_to_op(value, None).unwrap();
+    let op = ecx.eval_const_to_op(value.val, value.ty, None).unwrap();
     // downcast
     let down = match variant {
         None => op,
@@ -527,7 +527,7 @@ pub fn const_variant_index<'tcx>(
 ) -> VariantIdx {
     trace!("const_variant_index: {:?}", val);
     let ecx = mk_eval_cx(tcx, DUMMY_SP, param_env);
-    let op = ecx.eval_const_to_op(val, None).unwrap();
+    let op = ecx.eval_const_to_op(val.val, val.ty, None).unwrap();
     ecx.read_discriminant(op).unwrap().1
 }
 

src/librustc_mir/interpret/eval_context.rs

@@ -291,8 +291,9 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         ty.is_freeze(*self.tcx, self.param_env, DUMMY_SP)
     }
 
-    /// Call this whenever you have a value that `needs_subst`. Not guaranteed to actually
-    /// monomorphize the value. If we are e.g. const propagating inside a generic function, some
+    /// Call this whenever you have a value that you took from the current frame's `mir::Body`.
+    /// Not guaranteed to actually monomorphize the value.
+    /// If we are e.g. const propagating inside a generic function, some
     /// things may depend on a generic parameter and thus can never be monomorphized.
     pub(super) fn subst_and_normalize_erasing_regions_in_frame<T: TypeFoldable<'tcx>>(
         &self,
@@ -304,7 +305,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     /// Same thing as `subst_and_normalize_erasing_regions_in_frame` but not taking its substs
     /// from the top stack frame, but requiring you to pass specific substs.
     ///
-    /// Only call this function if you want to compute the substs of a specific frame (that is
+    /// Only call this function if you want to apply the substs of a specific frame (that is
     /// definitely not the frame currently being evaluated). You need to make sure to pass correct
     /// substs.
     fn subst_and_normalize_erasing_regions<T: TypeFoldable<'tcx>>(

src/librustc_mir/interpret/operand.rs

@@ -3,7 +3,7 @@
 
 use std::convert::TryInto;
 
-use rustc::{mir, ty};
+use rustc::{mir, ty::{self, Ty}};
 use rustc::ty::layout::{
     self, Size, LayoutOf, TyLayout, HasDataLayout, IntegerExt, VariantIdx,
 };
@@ -511,7 +511,11 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             Move(ref place) =>
                 self.eval_place_to_op(place, layout)?,
 
-            Constant(ref constant) => self.eval_const_to_op(constant.literal, layout)?,
+            Constant(ref constant) => {
+                let val = self.subst_and_normalize_erasing_regions_in_frame(constant.literal.val)?;
+                let ty = self.subst_and_normalize_erasing_regions_in_frame(constant.ty)?;
+                self.eval_const_to_op(val, ty, layout)?
+            },
         };
         trace!("{:?}: {:?}", mir_op, *op);
         Ok(op)
@@ -531,14 +535,14 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
     // in patterns via the `const_eval` module
     crate fn eval_const_to_op(
         &self,
-        val: &'tcx ty::Const<'tcx>,
+        value: ConstValue<'tcx>,
+        ty: Ty<'tcx>,
         layout: Option<TyLayout<'tcx>>,
     ) -> InterpResult<'tcx, OpTy<'tcx, M::PointerTag>> {
         let tag_scalar = |scalar| match scalar {
             Scalar::Ptr(ptr) => Scalar::Ptr(self.tag_static_base_pointer(ptr)),
             Scalar::Raw { data, size } => Scalar::Raw { data, size },
         };
-        let value = self.subst_and_normalize_erasing_regions_in_frame(val.val)?;
         // Early-return cases.
         match value {
             ConstValue::Param(_) => throw_inval!(TooGeneric),
@@ -552,13 +556,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             _ => {}
         }
         // Other cases need layout.
-        let layout = from_known_layout(layout, || {
-            // Substituting is not a cached or O(1) operation. Substituting the type happens here,
-            // which may not happen if we already have a layout. Or if we use the early abort above.
-            // Thus we do not substitute and normalize `val` above, but only `val.val` and then
-            // substitute `val.ty` here.
-            self.layout_of(self.subst_and_normalize_erasing_regions_in_frame(val.ty)?)
-        })?;
+        let layout = from_known_layout(layout, || self.layout_of(ty))?;
         let op = match value {
             ConstValue::ByRef { alloc, offset } => {
                 let id = self.tcx.alloc_map.lock().create_memory_alloc(alloc);
@@ -586,7 +584,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             ConstValue::Infer(..) |
             ConstValue::Placeholder(..) |
             ConstValue::Unevaluated(..) =>
-                bug!("eval_const_to_op: Unexpected ConstValue {:?}", val),
+                bug!("eval_const_to_op: Unexpected ConstValue {:?}", value),
         };
         Ok(OpTy { op, layout })
     }

src/librustc_mir/transform/const_prop.rs

@@ -287,7 +287,7 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
         c: &Constant<'tcx>,
     ) -> Option<Const<'tcx>> {
         self.ecx.tcx.span = c.span;
-        match self.ecx.eval_const_to_op(c.literal, None) {
+        match self.ecx.eval_const_to_op(c.literal.val, c.literal.ty, None) {
             Ok(op) => {
                 Some(op)
             },