Retire MirSource.

Author: cjgillot

compiler/rustc_const_eval/src/transform/promote_consts.rs

@@ -905,7 +905,7 @@ impl<'a, 'tcx> Promoter<'a, 'tcx> {
         feeder.opt_local_def_id_to_hir_id(None);
 
         let def_id = feeder.def_id();
-        self.promoted.source = MirSource::item(def_id.to_def_id());
+        self.promoted.source = ty::InstanceDef::Item(def_id.to_def_id());
         let parent_substs = tcx.erase_regions(InternalSubsts::identity_for_item(
             tcx,
             tcx.typeck_root_def_id(source_def_id.to_def_id()),

compiler/rustc_const_eval/src/transform/validate.rs

@@ -42,7 +42,7 @@ impl<'tcx> MirPass<'tcx> for Validator {
         // terribly important that they pass the validator. However, I think other passes might
         // still see them, in which case they might be surprised. It would probably be better if we
         // didn't put this through the MIR pipeline at all.
-        if matches!(body.source.instance, InstanceDef::Intrinsic(..) | InstanceDef::Virtual(..)) {
+        if matches!(body.source, InstanceDef::Intrinsic(..) | InstanceDef::Virtual(..)) {
             return;
         }
         let def_id = body.source.def_id();
@@ -74,7 +74,7 @@ impl<'tcx> MirPass<'tcx> for Validator {
         checker.check_cleanup_control_flow();
 
         if let MirPhase::Runtime(_) = body.phase {
-            if let ty::InstanceDef::Item(_) = body.source.instance {
+            if let ty::InstanceDef::Item(_) = body.source {
                 if body.has_free_regions() {
                     checker.fail(
                         Location::START,
@@ -109,7 +109,7 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             span,
             format!(
                 "broken MIR in {:?} ({}) at {:?}:\n{}",
-                self.body.source.instance,
+                self.body.source,
                 self.when,
                 location,
                 msg.as_ref()
@@ -1104,7 +1104,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
                 self.body.span,
                 format!(
                     "broken MIR in {:?} ({}):\ninvalid source scope {:?}",
-                    self.body.source.instance, self.when, scope,
+                    self.body.source, self.when, scope,
                 ),
             );
         }

compiler/rustc_middle/src/mir/mod.rs

@@ -179,28 +179,6 @@ impl RuntimePhase {
     }
 }
 
-/// Where a specific `mir::Body` comes from.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
-#[derive(HashStable, TyEncodable, TyDecodable, TypeFoldable, TypeVisitable)]
-pub struct MirSource<'tcx> {
-    pub instance: InstanceDef<'tcx>,
-}
-
-impl<'tcx> MirSource<'tcx> {
-    pub fn item(def_id: DefId) -> Self {
-        MirSource { instance: InstanceDef::Item(def_id) }
-    }
-
-    pub fn from_instance(instance: InstanceDef<'tcx>) -> Self {
-        MirSource { instance }
-    }
-
-    #[inline]
-    pub fn def_id(&self) -> DefId {
-        self.instance.def_id()
-    }
-}
-
 #[derive(Clone, TyEncodable, TyDecodable, Debug, HashStable, TypeFoldable, TypeVisitable)]
 pub struct GeneratorInfo<'tcx> {
     /// The yield type of the function, if it is a generator.
@@ -234,7 +212,7 @@ pub struct Body<'tcx> {
     /// How many passses we have executed since starting the current phase. Used for debug output.
     pub pass_count: usize,
 
-    pub source: MirSource<'tcx>,
+    pub source: InstanceDef<'tcx>,
 
     /// A list of source scopes; these are referenced by statements
     /// and used for debuginfo. Indexed by a `SourceScope`.
@@ -305,7 +283,7 @@ pub struct Body<'tcx> {
 
 impl<'tcx> Body<'tcx> {
     pub fn new(
-        source: MirSource<'tcx>,
+        source: InstanceDef<'tcx>,
         basic_blocks: IndexVec<BasicBlock, BasicBlockData<'tcx>>,
         source_scopes: IndexVec<SourceScope, SourceScopeData<'tcx>>,
         local_decls: IndexVec<Local, LocalDecl<'tcx>>,
@@ -362,7 +340,7 @@ impl<'tcx> Body<'tcx> {
         let mut body = Body {
             phase: MirPhase::Built,
             pass_count: 0,
-            source: MirSource::item(CRATE_DEF_ID.to_def_id()),
+            source: InstanceDef::Item(CRATE_DEF_ID.to_def_id()),
             basic_blocks: BasicBlocks::new(basic_blocks),
             source_scopes: IndexVec::new(),
             generator: None,

compiler/rustc_middle/src/mir/pretty.rs

@@ -176,7 +176,7 @@ fn dump_file_basename<'tcx>(
     let item_name = tcx.def_path(source.def_id()).to_filename_friendly_no_crate();
     // All drop shims have the same DefId, so we have to add the type
     // to get unique file names.
-    let shim_disambiguator = match source.instance {
+    let shim_disambiguator = match source {
         ty::InstanceDef::DropGlue(_, Some(ty)) => {
             // Unfortunately, pretty-printed typed are not very filename-friendly.
             // We dome some filtering.
@@ -976,7 +976,7 @@ fn write_allocation_bytes<'tcx, Prov: Provenance, Extra, Bytes: AllocBytes>(
 fn write_mir_sig(tcx: TyCtxt<'_>, body: &Body<'_>, w: &mut dyn Write) -> io::Result<()> {
     use rustc_hir::def::DefKind;
 
-    trace!("write_mir_sig: {:?}", body.source.instance);
+    trace!("write_mir_sig: {:?}", body.source);
     let def_id = body.source.def_id();
     let kind = tcx.def_kind(def_id);
     let is_function = match kind {

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

@@ -25,7 +25,7 @@ use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::{
     mir::*,
     thir::*,
-    ty::{ParamEnv, Ty, TyCtxt},
+    ty::{InstanceDef, ParamEnv, Ty, TyCtxt},
 };
 use rustc_span::Span;
 
@@ -45,7 +45,7 @@ pub(super) fn build_custom_mir<'tcx>(
 ) -> Body<'tcx> {
     let mut body = Body {
         basic_blocks: BasicBlocks::new(IndexVec::new()),
-        source: MirSource::item(did),
+        source: InstanceDef::Item(did),
         phase: MirPhase::Built,
         source_scopes: IndexVec::new(),
         generator: None,

compiler/rustc_mir_build/src/build/mod.rs

@@ -640,7 +640,7 @@ fn construct_error(tcx: TyCtxt<'_>, def: LocalDefId, err: ErrorGuaranteed) -> Bo
     cfg.terminate(START_BLOCK, source_info, TerminatorKind::Unreachable);
 
     let mut body = Body::new(
-        MirSource::item(def.to_def_id()),
+        ty::InstanceDef::Item(def.to_def_id()),
         cfg.basic_blocks,
         source_scopes,
         local_decls,
@@ -730,7 +730,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         }
 
         Body::new(
-            MirSource::item(self.def_id.to_def_id()),
+            ty::InstanceDef::Item(self.def_id.to_def_id()),
             self.cfg.basic_blocks,
             self.source_scopes,
             self.local_decls,

compiler/rustc_mir_transform/src/check_packed_ref.rs

@@ -39,7 +39,7 @@ impl<'tcx> Visitor<'tcx> for PackedRefChecker<'_, 'tcx> {
     fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, _location: Location) {
         if context.is_borrow() {
             if util::is_disaligned(self.tcx, self.body, self.param_env, *place) {
-                let def_id = self.body.source.instance.def_id();
+                let def_id = self.body.source.def_id();
                 if let Some(impl_def_id) = self.tcx.impl_of_method(def_id)
                     && self.tcx.is_builtin_derived(impl_def_id)
                 {

compiler/rustc_mir_transform/src/shim.rs

@@ -171,7 +171,7 @@ fn build_drop_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, ty: Option<Ty<'tcx>>)
     block(&mut blocks, TerminatorKind::Goto { target: return_block });
     block(&mut blocks, TerminatorKind::Return);
 
-    let source = MirSource::from_instance(ty::InstanceDef::DropGlue(def_id, ty));
+    let source = ty::InstanceDef::DropGlue(def_id, ty);
     let mut body =
         new_body(source, blocks, local_decls_for_sig(&sig, span), sig.inputs().len(), span);
 
@@ -229,7 +229,7 @@ fn build_drop_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, ty: Option<Ty<'tcx>>)
 }
 
 fn new_body<'tcx>(
-    source: MirSource<'tcx>,
+    source: ty::InstanceDef<'tcx>,
     basic_blocks: IndexVec<BasicBlock, BasicBlockData<'tcx>>,
     local_decls: IndexVec<Local, LocalDecl<'tcx>>,
     arg_count: usize,
@@ -343,7 +343,7 @@ fn build_thread_local_shim<'tcx>(tcx: TyCtxt<'tcx>, instance: ty::InstanceDef<'t
     });
 
     new_body(
-        MirSource::from_instance(instance),
+        instance,
         blocks,
         IndexVec::from_raw(vec![LocalDecl::new(tcx.thread_local_ptr_ty(def_id), span)]),
         0,
@@ -407,10 +407,7 @@ impl<'tcx> CloneShimBuilder<'tcx> {
     }
 
     fn into_mir(self) -> Body<'tcx> {
-        let source = MirSource::from_instance(ty::InstanceDef::CloneShim(
-            self.def_id,
-            self.sig.inputs_and_output[0],
-        ));
+        let source = ty::InstanceDef::CloneShim(self.def_id, self.sig.inputs_and_output[0]);
         new_body(source, self.blocks, self.local_decls, self.sig.inputs().len(), self.span)
     }
 
@@ -823,8 +820,7 @@ fn build_call_shim<'tcx>(
         block(&mut blocks, vec![], TerminatorKind::Resume, true);
     }
 
-    let mut body =
-        new_body(MirSource::from_instance(instance), blocks, local_decls, sig.inputs().len(), span);
+    let mut body = new_body(instance, blocks, local_decls, sig.inputs().len(), span);
 
     if let Abi::RustCall = sig.abi {
         body.spread_arg = Some(Local::new(sig.inputs().len()));
@@ -890,7 +886,7 @@ pub fn build_adt_ctor(tcx: TyCtxt<'_>, ctor_id: DefId) -> Body<'_> {
         is_cleanup: false,
     };
 
-    let source = MirSource::item(ctor_id);
+    let source = ty::InstanceDef::Item(ctor_id);
     let body = new_body(
         source,
         IndexVec::from_elem_n(start_block, 1),
@@ -936,6 +932,6 @@ fn build_fn_ptr_addr_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, self_ty: Ty<'t
         terminator: Some(Terminator { source_info, kind: TerminatorKind::Return }),
         is_cleanup: false,
     };
-    let source = MirSource::from_instance(ty::InstanceDef::FnPtrAddrShim(def_id, self_ty));
+    let source = ty::InstanceDef::FnPtrAddrShim(def_id, self_ty);
     new_body(source, IndexVec::from_elem_n(start_block, 1), locals, sig.inputs().len(), span)
 }