introduce new type for required items of a MIR body

Author: RalfJung

compiler/rustc_middle/src/mir/mod.rs

@@ -9,7 +9,7 @@ use crate::ty::fold::{FallibleTypeFolder, TypeFoldable};
 use crate::ty::print::{pretty_print_const, with_no_trimmed_paths};
 use crate::ty::print::{FmtPrinter, Printer};
 use crate::ty::visit::TypeVisitableExt;
-use crate::ty::{self, Instance, List, Ty, TyCtxt};
+use crate::ty::{self, List, Ty, TyCtxt};
 use crate::ty::{AdtDef, InstanceDef, UserTypeAnnotationIndex};
 use crate::ty::{GenericArg, GenericArgsRef};
 
@@ -310,6 +310,13 @@ impl<'tcx> CoroutineInfo<'tcx> {
     }
 }
 
+/// Some item that needs to monomorphize successfully for a MIR body to be considered well-formed.
+#[derive(Clone, TyEncodable, TyDecodable, Debug, HashStable, TypeFoldable, TypeVisitable)]
+pub enum RequiredItem<'tcx> {
+    Fn(DefId, GenericArgsRef<'tcx>),
+    Drop(Ty<'tcx>),
+}
+
 /// The lowered representation of a single function.
 #[derive(Clone, TyEncodable, TyDecodable, Debug, HashStable, TypeFoldable, TypeVisitable)]
 pub struct Body<'tcx> {
@@ -375,8 +382,8 @@ pub struct Body<'tcx> {
     /// We hold in this field all the constants we are not able to evaluate yet.
     pub required_consts: Vec<ConstOperand<'tcx>>,
 
-    /// Functions that need to monomorphize successfully for this MIR to be well-formed.
-    pub required_fns: Vec<Instance<'tcx>>,
+    /// Further items that need to monomorphize successfully for this MIR to be well-formed.
+    pub required_items: Vec<RequiredItem<'tcx>>,
 
     /// Does this body use generic parameters. This is used for the `ConstEvaluatable` check.
     ///
@@ -448,7 +455,7 @@ impl<'tcx> Body<'tcx> {
             var_debug_info,
             span,
             required_consts: Vec::new(),
-            required_fns: Vec::new(),
+            required_items: Vec::new(),
             is_polymorphic: false,
             injection_phase: None,
             tainted_by_errors,
@@ -477,7 +484,7 @@ impl<'tcx> Body<'tcx> {
             spread_arg: None,
             span: DUMMY_SP,
             required_consts: Vec::new(),
-            required_fns: Vec::new(),
+            required_items: Vec::new(),
             var_debug_info: Vec::new(),
             is_polymorphic: false,
             injection_phase: None,

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

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

compiler/rustc_mir_transform/src/lib.rs

@@ -344,14 +344,14 @@ fn mir_promoted(
     }
 
     let mut required_consts = Vec::new();
-    let mut required_fns = Vec::new();
+    let mut required_items = Vec::new();
     let mut required_consts_visitor =
-        RequiredConstsVisitor::new(tcx, &body, &mut required_consts, &mut required_fns);
+        RequiredConstsVisitor::new(tcx, &body, &mut required_consts, &mut required_items);
     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_fns = required_fns;
+    body.required_items = required_items;
 
     // What we need to run borrowck etc.
     let promote_pass = promote_consts::PromoteTemps::default();

compiler/rustc_mir_transform/src/required_consts.rs

@@ -1,23 +1,22 @@
-use rustc_hir::LangItem;
 use rustc_middle::mir::visit::Visitor;
-use rustc_middle::mir::{self, Const, ConstOperand, Location};
-use rustc_middle::ty::{self, ConstKind, Instance, InstanceDef, TyCtxt};
+use rustc_middle::mir::{self, Const, ConstOperand, Location, RequiredItem};
+use rustc_middle::ty::{self, ConstKind, TyCtxt};
 
 pub struct RequiredConstsVisitor<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
     body: &'a mir::Body<'tcx>,
     required_consts: &'a mut Vec<ConstOperand<'tcx>>,
-    required_fns: &'a mut Vec<Instance<'tcx>>,
+    required_items: &'a mut Vec<RequiredItem<'tcx>>,
 }
 
 impl<'a, 'tcx> RequiredConstsVisitor<'a, 'tcx> {
     pub fn new(
         tcx: TyCtxt<'tcx>,
         body: &'a mir::Body<'tcx>,
         required_consts: &'a mut Vec<ConstOperand<'tcx>>,
-        required_fns: &'a mut Vec<Instance<'tcx>>,
+        required_items: &'a mut Vec<RequiredItem<'tcx>>,
     ) -> Self {
-        RequiredConstsVisitor { tcx, body, required_consts, required_fns }
+        RequiredConstsVisitor { tcx, body, required_consts, required_items }
     }
 }
 
@@ -33,11 +32,8 @@ impl<'tcx> Visitor<'tcx> for RequiredConstsVisitor<'_, 'tcx> {
             Const::Val(_val, ty) => {
                 // This is how function items get referenced: via zero-sized constants of `FnDef` type
                 if let ty::FnDef(def_id, args) = ty.kind() {
-                    debug!("adding to required_fns: {def_id:?}");
-                    // FIXME maybe we shouldn't use `Instance`? We can't use `Instance::new`, it is
-                    // for codegen. But `Instance` feels like the right representation... Check what
-                    // the regular collector does.
-                    self.required_fns.push(Instance { def: InstanceDef::Item(*def_id), args });
+                    debug!("adding to required_items: {def_id:?}");
+                    self.required_items.push(RequiredItem::Fn(*def_id, args));
                 }
             }
         }
@@ -51,11 +47,7 @@ impl<'tcx> Visitor<'tcx> for RequiredConstsVisitor<'_, 'tcx> {
             // `visit_constant`. But we do need to handle `Drop`.
             mir::TerminatorKind::Drop { place, .. } => {
                 let ty = place.ty(self.body, self.tcx).ty;
-                let def_id = self.tcx.require_lang_item(LangItem::DropInPlace, None);
-                let args = self.tcx.mk_args(&[ty.into()]);
-                // FIXME: same as above (we cannot use `Instance::resolve_drop_in_place` as this is
-                // still generic).
-                self.required_fns.push(Instance { def: InstanceDef::Item(def_id), args });
+                self.required_items.push(RequiredItem::Drop(ty));
             }
             _ => {}
         }