Report monomorphization time errors in dead code, too

compiler/rustc_codegen_cranelift/src/constant.rs

@@ -35,9 +35,11 @@ impl ConstantCx {
 
 pub(crate) fn check_constants(fx: &mut FunctionCx<'_, '_, '_>) -> bool {
     let mut all_constants_ok = true;
-    for constant in &fx.mir.required_consts {
-        if eval_mir_constant(fx, constant).is_none() {
-            all_constants_ok = false;
+    for (item, _) in &fx.mir.required_items {
+        if let rustc_middle::mir::MonoItem::Const(constant) = item {
+            if eval_mir_constant(fx, constant).is_none() {
+                all_constants_ok = false;
+            }
         }
     }
     all_constants_ok

compiler/rustc_codegen_ssa/src/mir/mod.rs

@@ -2,6 +2,7 @@ use crate::base;
 use crate::traits::*;
 use rustc_middle::mir;
 use rustc_middle::mir::interpret::ErrorHandled;
+use rustc_middle::mir::MonoItem;
 use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, TyAndLayout};
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt, TypeFoldable, TypeVisitableExt};
 use rustc_target::abi::call::{FnAbi, PassMode};
@@ -202,14 +203,20 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 
     // Evaluate all required consts; codegen later assumes that CTFE will never fail.
     let mut all_consts_ok = true;
-    for const_ in &mir.required_consts {
-        if let Err(err) = fx.eval_mir_constant(const_) {
-            all_consts_ok = false;
-            match err {
-                // errored or at least linted
-                ErrorHandled::Reported(_) => {}
-                ErrorHandled::TooGeneric => {
-                    span_bug!(const_.span, "codegen encountered polymorphic constant: {:?}", err)
+    for (const_, _) in &mir.required_items {
+        if let MonoItem::Const(const_) = const_ {
+            if let Err(err) = fx.eval_mir_constant(const_) {
+                all_consts_ok = false;
+                match err {
+                    // errored or at least linted
+                    ErrorHandled::Reported(_) => {}
+                    ErrorHandled::TooGeneric => {
+                        span_bug!(
+                            const_.span,
+                            "codegen encountered polymorphic constant: {:?}",
+                            err
+                        )
+                    }
                 }
             }
         }

compiler/rustc_const_eval/src/interpret/eval_context.rs

@@ -703,10 +703,19 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         self.stack_mut().push(frame);
 
         // Make sure all the constants required by this frame evaluate successfully (post-monomorphization check).
-        for ct in &body.required_consts {
-            let span = ct.span;
-            let ct = self.subst_from_current_frame_and_normalize_erasing_regions(ct.literal)?;
-            self.eval_mir_constant(&ct, Some(span), None)?;
+        for (ct, span) in &body.required_items {
+            if let mir::MonoItem::Const(ct) = ct {
+                match ct.literal {
+                    mir::ConstantKind::Ty(c) => match c.kind() {
+                        ty::ConstKind::Unevaluated(_) => {}
+                        _ => continue,
+                    },
+                    mir::ConstantKind::Unevaluated(_, _) => {}
+                    mir::ConstantKind::Val(_, _) => continue,
+                }
+                let ct = self.subst_from_current_frame_and_normalize_erasing_regions(ct.literal)?;
+                self.eval_mir_constant(&ct, Some(*span), None)?;
+            }
         }
 
         // Most locals are initially dead.

compiler/rustc_middle/src/mir/mod.rs

@@ -220,6 +220,23 @@ pub struct GeneratorInfo<'tcx> {
     pub generator_kind: GeneratorKind,
 }
 
+#[derive(Clone, TyEncodable, TyDecodable, Debug, HashStable, TypeFoldable, TypeVisitable)]
+/// Items that the monomorphization collector needs to walk into.
+pub enum MonoItem<'tcx> {
+    /// The `bool` states whether this is a direct call or not.
+    Fn(DefId, SubstsRef<'tcx>, bool),
+    Static(DefId),
+    Vtable {
+        source_ty: Ty<'tcx>,
+        target_ty: Ty<'tcx>,
+    },
+    Const(Constant<'tcx>),
+    Drop(Ty<'tcx>),
+    Closure(DefId, SubstsRef<'tcx>),
+}
+
+pub type MonoItems<'tcx> = Vec<(MonoItem<'tcx>, Span)>;
+
 /// The lowered representation of a single function.
 #[derive(Clone, TyEncodable, TyDecodable, Debug, HashStable, TypeFoldable, TypeVisitable)]
 pub struct Body<'tcx> {
@@ -275,9 +292,11 @@ pub struct Body<'tcx> {
     /// A span representing this MIR, for error reporting.
     pub span: Span,
 
-    /// Constants that are required to evaluate successfully for this MIR to be well-formed.
-    /// We hold in this field all the constants we are not able to evaluate yet.
-    pub required_consts: Vec<Constant<'tcx>>,
+    /// Items that this body needs to monomorphize if monomorphized itself.
+    /// This field avoids the issue that optimizations can remove function calls in dead code
+    /// causing differences in monomorphization time errors depending on the optimizations
+    /// enabled.
+    pub required_items: MonoItems<'tcx>,
 
     /// Does this body use generic parameters. This is used for the `ConstEvaluatable` check.
     ///
@@ -347,7 +366,7 @@ impl<'tcx> Body<'tcx> {
             spread_arg: None,
             var_debug_info,
             span,
-            required_consts: Vec::new(),
+            required_items: Vec::new(),
             is_polymorphic: false,
             injection_phase: None,
             tainted_by_errors,
@@ -374,7 +393,7 @@ impl<'tcx> Body<'tcx> {
             arg_count: 0,
             spread_arg: None,
             span: DUMMY_SP,
-            required_consts: Vec::new(),
+            required_items: Vec::new(),
             var_debug_info: Vec::new(),
             is_polymorphic: false,
             injection_phase: None,

compiler/rustc_middle/src/mir/visit.rs

@@ -1039,9 +1039,14 @@ macro_rules! super_body {
 
         $self.visit_span($(& $mutability)? $body.span);
 
-        for const_ in &$($mutability)? $body.required_consts {
+        for (item, _) in &$($mutability)? $body.required_items {
             let location = Location::START;
-            $self.visit_constant(const_, location);
+            match item {
+                MonoItem::Const(const_) => if let ConstantKind::Unevaluated(..) = const_.literal {
+                    $self.visit_constant(const_, location)
+                },
+                _ => {}
+            }
         }
     }
 }

compiler/rustc_mir_build/src/build/custom/mod.rs

@@ -55,7 +55,7 @@ pub(super) fn build_custom_mir<'tcx>(
         spread_arg: None,
         var_debug_info: Vec::new(),
         span,
-        required_consts: Vec::new(),
+        required_items: Vec::new(),
         is_polymorphic: false,
         tainted_by_errors: None,
         injection_phase: None,

compiler/rustc_mir_transform/src/inline.rs

@@ -625,18 +625,7 @@ impl<'tcx> Inliner<'tcx> {
                     kind: TerminatorKind::Goto { target: integrator.map_block(START_BLOCK) },
                 });
 
-                // Copy only unevaluated constants from the callee_body into the caller_body.
-                // Although we are only pushing `ConstKind::Unevaluated` consts to
-                // `required_consts`, here we may not only have `ConstKind::Unevaluated`
-                // because we are calling `subst_and_normalize_erasing_regions`.
-                caller_body.required_consts.extend(
-                    callee_body.required_consts.iter().copied().filter(|&ct| match ct.literal {
-                        ConstantKind::Ty(_) => {
-                            bug!("should never encounter ty::UnevaluatedConst in `required_consts`")
-                        }
-                        ConstantKind::Val(..) | ConstantKind::Unevaluated(..) => true,
-                    }),
-                );
+                caller_body.required_items.extend(callee_body.required_items.iter().cloned());
             }
             kind => bug!("unexpected terminator kind {:?}", kind),
         }

compiler/rustc_mir_transform/src/lib.rs

@@ -19,7 +19,6 @@ extern crate tracing;
 #[macro_use]
 extern crate rustc_middle;
 
-use required_consts::RequiredConstsVisitor;
 use rustc_const_eval::util;
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_data_structures::steal::Steal;
@@ -303,12 +302,13 @@ fn mir_promoted(
         body.tainted_by_errors = Some(error_reported);
     }
 
-    let mut required_consts = Vec::new();
-    let mut required_consts_visitor = RequiredConstsVisitor::new(&mut required_consts);
+    let param_env = tcx.param_env(def);
+    let mut required_consts_visitor =
+        required_consts::MirNeighborCollector { tcx, body: &body, output: vec![], param_env };
     for (bb, bb_data) in traversal::reverse_postorder(&body) {
         required_consts_visitor.visit_basic_block_data(bb, bb_data);
     }
-    body.required_consts = required_consts;
+    body.required_items = required_consts_visitor.output;
 
     // What we need to run borrowck etc.
     let promote_pass = promote_consts::PromoteTemps::default();