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

src/librustc_mir/interpret/cast.rs

@@ -67,7 +67,6 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
                 // The src operand does not matter, just its type
                 match src.layout.ty.sty {
                     ty::Closure(def_id, substs) => {
-                        let substs = self.subst_and_normalize_erasing_regions(substs)?;
                         let instance = ty::Instance::resolve_closure(
                             *self.tcx,
                             def_id,

src/librustc_mir/interpret/eval_context.rs

@@ -9,7 +9,7 @@ use rustc::mir;
 use rustc::ty::layout::{
     self, Size, Align, HasDataLayout, LayoutOf, TyLayout
 };
-use rustc::ty::subst::{Subst, SubstsRef};
+use rustc::ty::subst::{SubstsRef, Subst};
 use rustc::ty::{self, Ty, TyCtxt, TypeFoldable};
 use rustc::ty::query::TyCtxtAt;
 use rustc_data_structures::indexed_vec::IndexVec;
@@ -291,22 +291,37 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         ty.is_freeze(*self.tcx, self.param_env, DUMMY_SP)
     }
 
-    pub(super) fn subst_and_normalize_erasing_regions<T: TypeFoldable<'tcx>>(
+    /// 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
+    /// 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,
-        substs: T,
+        value: T,
     ) -> InterpResult<'tcx, T> {
-        match self.stack.last() {
-            Some(frame) => Ok(self.tcx.subst_and_normalize_erasing_regions(
-                frame.instance.substs,
-                self.param_env,
-                &substs,
-            )),
-            None => if substs.needs_subst() {
-                throw_inval!(TooGeneric)
-            } else {
-                Ok(substs)
-            },
+        self.subst_and_normalize_erasing_regions(self.frame().instance.substs, value)
+    }
+
+    /// 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
+    /// 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>>(
+        &self,
+        param_substs: SubstsRef<'tcx>,
+        value: T,
+    ) -> InterpResult<'tcx, T> {
+        let substituted = value.subst(self.tcx.tcx, param_substs);
+        // we duplicate the body of `TyCtxt::subst_and_normalize_erasing_regions` here, because
+        // we can't normalize values with generic parameters. The difference between this function
+        // and the `TyCtxt` version is this early abort
+        if substituted.needs_subst() {
+            // FIXME(oli-obk): This aborts evaluating `fn foo<T>() -> i32 { 42 }` inside an
+            // associated constant of a generic trait, even though that should be doable.
+            throw_inval!(TooGeneric);
         }
+        Ok(self.tcx.normalize_erasing_regions(self.param_env, substituted))
     }
 
     pub(super) fn resolve(
@@ -315,9 +330,6 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         substs: SubstsRef<'tcx>
     ) -> InterpResult<'tcx, ty::Instance<'tcx>> {
         trace!("resolve: {:?}, {:#?}", def_id, substs);
-        trace!("param_env: {:#?}", self.param_env);
-        let substs = self.subst_and_normalize_erasing_regions(substs)?;
-        trace!("substs: {:#?}", substs);
         ty::Instance::resolve(
             *self.tcx,
             self.param_env,
@@ -349,36 +361,6 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         }
     }
 
-    pub(super) fn monomorphize<T: TypeFoldable<'tcx> + Subst<'tcx>>(
-        &self,
-        t: T,
-    ) -> InterpResult<'tcx, T> {
-        match self.stack.last() {
-            Some(frame) => Ok(self.monomorphize_with_substs(t, frame.instance.substs)?),
-            None => if t.needs_subst() {
-                throw_inval!(TooGeneric)
-            } else {
-                Ok(t)
-            },
-        }
-    }
-
-    fn monomorphize_with_substs<T: TypeFoldable<'tcx> + Subst<'tcx>>(
-        &self,
-        t: T,
-        substs: SubstsRef<'tcx>
-    ) -> InterpResult<'tcx, T> {
-        // miri doesn't care about lifetimes, and will choke on some crazy ones
-        // let's simply get rid of them
-        let substituted = t.subst(*self.tcx, substs);
-
-        if substituted.needs_subst() {
-            throw_inval!(TooGeneric)
-        }
-
-        Ok(self.tcx.normalize_erasing_regions(ty::ParamEnv::reveal_all(), substituted))
-    }
-
     pub fn layout_of_local(
         &self,
         frame: &Frame<'mir, 'tcx, M::PointerTag, M::FrameExtra>,
@@ -391,7 +373,9 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             None => {
                 let layout = crate::interpret::operand::from_known_layout(layout, || {
                     let local_ty = frame.body.local_decls[local].ty;
-                    let local_ty = self.monomorphize_with_substs(local_ty, frame.instance.substs)?;
+                    let local_ty = self.subst_and_normalize_erasing_regions(
+                        frame.instance.substs, local_ty,
+                    )?;
                     self.layout_of(local_ty)
                 })?;
                 if let Some(state) = frame.locals.get(local) {

src/librustc_mir/interpret/operand.rs

@@ -538,11 +538,10 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             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 val.val {
-            ConstValue::Param(_) =>
-                // FIXME(oli-obk): try to monomorphize
-                throw_inval!(TooGeneric),
+        match value {
+            ConstValue::Param(_) => throw_inval!(TooGeneric),
             ConstValue::Unevaluated(def_id, substs) => {
                 let instance = self.resolve(def_id, substs)?;
                 return Ok(OpTy::from(self.const_eval_raw(GlobalId {
@@ -554,9 +553,13 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         }
         // Other cases need layout.
         let layout = from_known_layout(layout, || {
-            self.layout_of(self.monomorphize(val.ty)?)
+            // 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 op = match val.val {
+        let op = match value {
             ConstValue::ByRef { alloc, offset } => {
                 let id = self.tcx.alloc_map.lock().create_memory_alloc(alloc);
                 // We rely on mutability being set correctly in that allocation to prevent writes

src/librustc_mir/interpret/place.rs

@@ -616,10 +616,11 @@ where
                     Some(return_place) => {
                         // We use our layout to verify our assumption; caller will validate
                         // their layout on return.
+                        let ret_ty = self.frame().body.return_ty();
+                        let ret_ty = self.subst_and_normalize_erasing_regions_in_frame(ret_ty)?;
                         PlaceTy {
                             place: *return_place,
-                            layout: self
-                                .layout_of(self.monomorphize(self.frame().body.return_ty())?)?,
+                            layout: self.layout_of(ret_ty)?,
                         }
                     }
                     None => throw_unsup!(InvalidNullPointerUsage),

src/librustc_mir/interpret/step.rs

@@ -249,7 +249,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
             }
 
             NullaryOp(mir::NullOp::SizeOf, ty) => {
-                let ty = self.monomorphize(ty)?;
+                let ty = self.subst_and_normalize_erasing_regions_in_frame(ty)?;
                 let layout = self.layout_of(ty)?;
                 assert!(!layout.is_unsized(),
                         "SizeOf nullary MIR operator called for unsized type");

src/librustc_mir/interpret/traits.rs

@@ -77,7 +77,7 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         for (i, method) in methods.iter().enumerate() {
             if let Some((def_id, substs)) = *method {
                 // resolve for vtable: insert shims where needed
-                let substs = self.subst_and_normalize_erasing_regions(substs)?;
+                let substs = self.subst_and_normalize_erasing_regions_in_frame(substs)?;
                 let instance = ty::Instance::resolve_for_vtable(
                     *self.tcx,
                     self.param_env,

src/librustc_mir/transform/const_prop.rs

@@ -162,11 +162,12 @@ impl<'mir, 'tcx> ConstPropagator<'mir, 'tcx> {
         let def_id = source.def_id();
         let param_env = tcx.param_env(def_id);
         let span = tcx.def_span(def_id);
+        let substs = InternalSubsts::identity_for_item(tcx, def_id);
         let mut ecx = mk_eval_cx(tcx, span, param_env);
         let can_const_prop = CanConstProp::check(body);
 
         ecx.push_stack_frame(
-            Instance::new(def_id, &InternalSubsts::identity_for_item(tcx, def_id)),
+            Instance::new(def_id, &substs),
             span,
             dummy_body,
             None,

src/test/incremental/no_mangle2.rs

@@ -0,0 +1,10 @@
+// revisions:cfail1 cfail2
+// check-pass
+// compile-flags: --crate-type staticlib
+
+#![deny(unused_attributes)]
+
+#[no_mangle]
+pub extern "C" fn rust_no_mangle() -> i32 {
+    42
+}

src/test/ui/consts/too_generic_eval_ice.rs

@@ -0,0 +1,13 @@
+pub struct Foo<A, B>(A, B);
+
+impl<A, B> Foo<A, B> {
+    const HOST_SIZE: usize = std::mem::size_of::<B>();
+
+    pub fn crash() -> bool {
+        [5; Self::HOST_SIZE] == [6; 0] //~ ERROR no associated item named `HOST_SIZE`
+        //~^ the size for values of type `A` cannot be known
+        //~| the size for values of type `B` cannot be known
+    }
+}
+
+fn main() {}

src/test/ui/consts/too_generic_eval_ice.stderr

@@ -0,0 +1,47 @@
+error[E0599]: no associated item named `HOST_SIZE` found for type `Foo<A, B>` in the current scope
+  --> $DIR/too_generic_eval_ice.rs:7:19
+   |
+LL | pub struct Foo<A, B>(A, B);
+   | --------------------------- associated item `HOST_SIZE` not found for this
+...
+LL |         [5; Self::HOST_SIZE] == [6; 0]
+   |                   ^^^^^^^^^ associated item not found in `Foo<A, B>`
+   |
+   = note: the method `HOST_SIZE` exists but the following trait bounds were not satisfied:
+           `A : std::marker::Sized`
+           `B : std::marker::Sized`
+
+error[E0277]: the size for values of type `A` cannot be known at compilation time
+  --> $DIR/too_generic_eval_ice.rs:7:13
+   |
+LL |         [5; Self::HOST_SIZE] == [6; 0]
+   |             ^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `std::marker::Sized` is not implemented for `A`
+   = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+   = help: consider adding a `where A: std::marker::Sized` bound
+note: required by `Foo`
+  --> $DIR/too_generic_eval_ice.rs:1:1
+   |
+LL | pub struct Foo<A, B>(A, B);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0277]: the size for values of type `B` cannot be known at compilation time
+  --> $DIR/too_generic_eval_ice.rs:7:13
+   |
+LL |         [5; Self::HOST_SIZE] == [6; 0]
+   |             ^^^^^^^^^^^^^^^ doesn't have a size known at compile-time
+   |
+   = help: the trait `std::marker::Sized` is not implemented for `B`
+   = note: to learn more, visit <https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait>
+   = help: consider adding a `where B: std::marker::Sized` bound
+note: required by `Foo`
+  --> $DIR/too_generic_eval_ice.rs:1:1
+   |
+LL | pub struct Foo<A, B>(A, B);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0277, E0599.
+For more information about an error, try `rustc --explain E0277`.

src/test/ui/issues/issue-58435-ice-with-assoc-const.rs

@@ -1,6 +1,6 @@
 // run-pass
-// The const-evaluator was at one point ICE'ing while trying to
-// evaluate the body of `fn id` during the `s.id()` call in main.
+// The const propagator was at one point ICE'ing while trying to
+// propagate constants in the body of `fn id` during the `s.id()` call in main.
 
 struct S<T>(T);