let rustc_smir host stable_mir for refactoring.

Author: makai410

Diff for: Cargo.lock

@@ -4432,7 +4432,7 @@ dependencies = [
  "rustc_span",
  "rustc_target",
  "scoped-tls",
- "stable_mir",
+ "serde",
  "tracing",
 ]
 
@@ -4990,8 +4990,7 @@ checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
 name = "stable_mir"
 version = "0.1.0-preview"
 dependencies = [
- "scoped-tls",
- "serde",
+ "rustc_smir",
 ]
 
 [[package]]

Diff for: compiler/rustc_smir/Cargo.toml

@@ -14,6 +14,6 @@ rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 scoped-tls = "1.0"
-stable_mir = {path = "../stable_mir" }
+serde = { version = "1.0.125", features = [ "derive" ] }
 tracing = "0.1"
 # tidy-alphabetical-end

Diff for: compiler/rustc_smir/src/lib.rs

@@ -22,3 +22,5 @@ pub mod rustc_internal;
 
 // Make this module private for now since external users should not call these directly.
 mod rustc_smir;
+
+pub mod stable_mir;

Diff for: compiler/rustc_smir/src/rustc_internal/internal.rs

@@ -7,20 +7,20 @@
 
 use rustc_middle::ty::{self as rustc_ty, Const as InternalConst, Ty as InternalTy, TyCtxt};
 use rustc_span::Symbol;
-use stable_mir::abi::Layout;
-use stable_mir::mir::alloc::AllocId;
-use stable_mir::mir::mono::{Instance, MonoItem, StaticDef};
-use stable_mir::mir::{BinOp, Mutability, Place, ProjectionElem, RawPtrKind, Safety, UnOp};
-use stable_mir::ty::{
+
+use super::RustcInternal;
+use crate::rustc_smir::Tables;
+use crate::stable_mir::abi::Layout;
+use crate::stable_mir::mir::alloc::AllocId;
+use crate::stable_mir::mir::mono::{Instance, MonoItem, StaticDef};
+use crate::stable_mir::mir::{BinOp, Mutability, Place, ProjectionElem, RawPtrKind, Safety, UnOp};
+use crate::stable_mir::ty::{
     Abi, AdtDef, Binder, BoundRegionKind, BoundTyKind, BoundVariableKind, ClosureKind, DynKind,
     ExistentialPredicate, ExistentialProjection, ExistentialTraitRef, FloatTy, FnSig,
     GenericArgKind, GenericArgs, IndexedVal, IntTy, MirConst, Movability, Pattern, Region, RigidTy,
     Span, TermKind, TraitRef, Ty, TyConst, UintTy, VariantDef, VariantIdx,
 };
-use stable_mir::{CrateItem, CrateNum, DefId};
-
-use super::RustcInternal;
-use crate::rustc_smir::Tables;
+use crate::stable_mir::{CrateItem, CrateNum, DefId};
 
 impl RustcInternal for CrateItem {
     type T<'tcx> = rustc_span::def_id::DefId;

Diff for: compiler/rustc_smir/src/rustc_internal/mod.rs

@@ -16,12 +16,12 @@ use rustc_middle::ty::TyCtxt;
 use rustc_span::Span;
 use rustc_span::def_id::{CrateNum, DefId};
 use scoped_tls::scoped_thread_local;
-use stable_mir::Error;
-use stable_mir::abi::Layout;
-use stable_mir::ty::IndexedVal;
 
 use crate::rustc_smir::context::TablesWrapper;
 use crate::rustc_smir::{Stable, Tables};
+use crate::stable_mir::Error;
+use crate::stable_mir::abi::Layout;
+use crate::stable_mir::ty::IndexedVal;
 
 mod internal;
 pub mod pretty;
@@ -60,126 +60,135 @@ where
     with_tables(|tables| item.internal(tables, tcx))
 }
 
-impl<'tcx> Index<stable_mir::DefId> for Tables<'tcx> {
+impl<'tcx> Index<crate::stable_mir::DefId> for Tables<'tcx> {
     type Output = DefId;
 
     #[inline(always)]
-    fn index(&self, index: stable_mir::DefId) -> &Self::Output {
+    fn index(&self, index: crate::stable_mir::DefId) -> &Self::Output {
         &self.def_ids[index]
     }
 }
 
-impl<'tcx> Index<stable_mir::ty::Span> for Tables<'tcx> {
+impl<'tcx> Index<crate::stable_mir::ty::Span> for Tables<'tcx> {
     type Output = Span;
 
     #[inline(always)]
-    fn index(&self, index: stable_mir::ty::Span) -> &Self::Output {
+    fn index(&self, index: crate::stable_mir::ty::Span) -> &Self::Output {
         &self.spans[index]
     }
 }
 
 impl<'tcx> Tables<'tcx> {
-    pub fn crate_item(&mut self, did: DefId) -> stable_mir::CrateItem {
-        stable_mir::CrateItem(self.create_def_id(did))
+    pub fn crate_item(&mut self, did: DefId) -> crate::stable_mir::CrateItem {
+        crate::stable_mir::CrateItem(self.create_def_id(did))
     }
 
-    pub fn adt_def(&mut self, did: DefId) -> stable_mir::ty::AdtDef {
-        stable_mir::ty::AdtDef(self.create_def_id(did))
+    pub fn adt_def(&mut self, did: DefId) -> crate::stable_mir::ty::AdtDef {
+        crate::stable_mir::ty::AdtDef(self.create_def_id(did))
     }
 
-    pub fn foreign_module_def(&mut self, did: DefId) -> stable_mir::ty::ForeignModuleDef {
-        stable_mir::ty::ForeignModuleDef(self.create_def_id(did))
+    pub fn foreign_module_def(&mut self, did: DefId) -> crate::stable_mir::ty::ForeignModuleDef {
+        crate::stable_mir::ty::ForeignModuleDef(self.create_def_id(did))
     }
 
-    pub fn foreign_def(&mut self, did: DefId) -> stable_mir::ty::ForeignDef {
-        stable_mir::ty::ForeignDef(self.create_def_id(did))
+    pub fn foreign_def(&mut self, did: DefId) -> crate::stable_mir::ty::ForeignDef {
+        crate::stable_mir::ty::ForeignDef(self.create_def_id(did))
     }
 
-    pub fn fn_def(&mut self, did: DefId) -> stable_mir::ty::FnDef {
-        stable_mir::ty::FnDef(self.create_def_id(did))
+    pub fn fn_def(&mut self, did: DefId) -> crate::stable_mir::ty::FnDef {
+        crate::stable_mir::ty::FnDef(self.create_def_id(did))
     }
 
-    pub fn closure_def(&mut self, did: DefId) -> stable_mir::ty::ClosureDef {
-        stable_mir::ty::ClosureDef(self.create_def_id(did))
+    pub fn closure_def(&mut self, did: DefId) -> crate::stable_mir::ty::ClosureDef {
+        crate::stable_mir::ty::ClosureDef(self.create_def_id(did))
     }
 
-    pub fn coroutine_def(&mut self, did: DefId) -> stable_mir::ty::CoroutineDef {
-        stable_mir::ty::CoroutineDef(self.create_def_id(did))
+    pub fn coroutine_def(&mut self, did: DefId) -> crate::stable_mir::ty::CoroutineDef {
+        crate::stable_mir::ty::CoroutineDef(self.create_def_id(did))
     }
 
-    pub fn coroutine_closure_def(&mut self, did: DefId) -> stable_mir::ty::CoroutineClosureDef {
-        stable_mir::ty::CoroutineClosureDef(self.create_def_id(did))
+    pub fn coroutine_closure_def(
+        &mut self,
+        did: DefId,
+    ) -> crate::stable_mir::ty::CoroutineClosureDef {
+        crate::stable_mir::ty::CoroutineClosureDef(self.create_def_id(did))
     }
 
-    pub fn alias_def(&mut self, did: DefId) -> stable_mir::ty::AliasDef {
-        stable_mir::ty::AliasDef(self.create_def_id(did))
+    pub fn alias_def(&mut self, did: DefId) -> crate::stable_mir::ty::AliasDef {
+        crate::stable_mir::ty::AliasDef(self.create_def_id(did))
     }
 
-    pub fn param_def(&mut self, did: DefId) -> stable_mir::ty::ParamDef {
-        stable_mir::ty::ParamDef(self.create_def_id(did))
+    pub fn param_def(&mut self, did: DefId) -> crate::stable_mir::ty::ParamDef {
+        crate::stable_mir::ty::ParamDef(self.create_def_id(did))
     }
 
-    pub fn br_named_def(&mut self, did: DefId) -> stable_mir::ty::BrNamedDef {
-        stable_mir::ty::BrNamedDef(self.create_def_id(did))
+    pub fn br_named_def(&mut self, did: DefId) -> crate::stable_mir::ty::BrNamedDef {
+        crate::stable_mir::ty::BrNamedDef(self.create_def_id(did))
     }
 
-    pub fn trait_def(&mut self, did: DefId) -> stable_mir::ty::TraitDef {
-        stable_mir::ty::TraitDef(self.create_def_id(did))
+    pub fn trait_def(&mut self, did: DefId) -> crate::stable_mir::ty::TraitDef {
+        crate::stable_mir::ty::TraitDef(self.create_def_id(did))
     }
 
-    pub fn generic_def(&mut self, did: DefId) -> stable_mir::ty::GenericDef {
-        stable_mir::ty::GenericDef(self.create_def_id(did))
+    pub fn generic_def(&mut self, did: DefId) -> crate::stable_mir::ty::GenericDef {
+        crate::stable_mir::ty::GenericDef(self.create_def_id(did))
     }
 
-    pub fn const_def(&mut self, did: DefId) -> stable_mir::ty::ConstDef {
-        stable_mir::ty::ConstDef(self.create_def_id(did))
+    pub fn const_def(&mut self, did: DefId) -> crate::stable_mir::ty::ConstDef {
+        crate::stable_mir::ty::ConstDef(self.create_def_id(did))
     }
 
-    pub fn impl_def(&mut self, did: DefId) -> stable_mir::ty::ImplDef {
-        stable_mir::ty::ImplDef(self.create_def_id(did))
+    pub fn impl_def(&mut self, did: DefId) -> crate::stable_mir::ty::ImplDef {
+        crate::stable_mir::ty::ImplDef(self.create_def_id(did))
     }
 
-    pub fn region_def(&mut self, did: DefId) -> stable_mir::ty::RegionDef {
-        stable_mir::ty::RegionDef(self.create_def_id(did))
+    pub fn region_def(&mut self, did: DefId) -> crate::stable_mir::ty::RegionDef {
+        crate::stable_mir::ty::RegionDef(self.create_def_id(did))
     }
 
-    pub fn coroutine_witness_def(&mut self, did: DefId) -> stable_mir::ty::CoroutineWitnessDef {
-        stable_mir::ty::CoroutineWitnessDef(self.create_def_id(did))
+    pub fn coroutine_witness_def(
+        &mut self,
+        did: DefId,
+    ) -> crate::stable_mir::ty::CoroutineWitnessDef {
+        crate::stable_mir::ty::CoroutineWitnessDef(self.create_def_id(did))
     }
 
-    pub fn prov(&mut self, aid: AllocId) -> stable_mir::ty::Prov {
-        stable_mir::ty::Prov(self.create_alloc_id(aid))
+    pub fn prov(&mut self, aid: AllocId) -> crate::stable_mir::ty::Prov {
+        crate::stable_mir::ty::Prov(self.create_alloc_id(aid))
     }
 
-    pub(crate) fn create_def_id(&mut self, did: DefId) -> stable_mir::DefId {
+    pub(crate) fn create_def_id(&mut self, did: DefId) -> crate::stable_mir::DefId {
         self.def_ids.create_or_fetch(did)
     }
 
-    pub(crate) fn create_alloc_id(&mut self, aid: AllocId) -> stable_mir::mir::alloc::AllocId {
+    pub(crate) fn create_alloc_id(
+        &mut self,
+        aid: AllocId,
+    ) -> crate::stable_mir::mir::alloc::AllocId {
         self.alloc_ids.create_or_fetch(aid)
     }
 
-    pub(crate) fn create_span(&mut self, span: Span) -> stable_mir::ty::Span {
+    pub(crate) fn create_span(&mut self, span: Span) -> crate::stable_mir::ty::Span {
         self.spans.create_or_fetch(span)
     }
 
     pub(crate) fn instance_def(
         &mut self,
         instance: ty::Instance<'tcx>,
-    ) -> stable_mir::mir::mono::InstanceDef {
+    ) -> crate::stable_mir::mir::mono::InstanceDef {
         self.instances.create_or_fetch(instance)
     }
 
-    pub(crate) fn static_def(&mut self, did: DefId) -> stable_mir::mir::mono::StaticDef {
-        stable_mir::mir::mono::StaticDef(self.create_def_id(did))
+    pub(crate) fn static_def(&mut self, did: DefId) -> crate::stable_mir::mir::mono::StaticDef {
+        crate::stable_mir::mir::mono::StaticDef(self.create_def_id(did))
     }
 
     pub(crate) fn layout_id(&mut self, layout: rustc_abi::Layout<'tcx>) -> Layout {
         self.layouts.create_or_fetch(layout)
     }
 }
 
-pub fn crate_num(item: &stable_mir::Crate) -> CrateNum {
+pub fn crate_num(item: &crate::stable_mir::Crate) -> CrateNum {
     item.id.into()
 }
 
@@ -224,7 +233,7 @@ where
         mir_consts: IndexMap::default(),
         layouts: IndexMap::default(),
     }));
-    stable_mir::compiler_interface::run(&tables, || init(&tables, f))
+    crate::stable_mir::compiler_interface::run(&tables, || init(&tables, f))
 }
 
 /// Instantiate and run the compiler with the provided arguments and callback.
@@ -241,7 +250,7 @@ where
 /// #
 /// # fn main() {
 /// #   use std::ops::ControlFlow;
-/// #   use stable_mir::CompilerError;
+/// #   use crate::stable_mir::CompilerError;
 ///     fn analyze_code() -> ControlFlow<(), ()> {
 ///         // Your code goes in here.
 /// #       ControlFlow::Continue(())
@@ -319,7 +328,7 @@ macro_rules! run_driver {
         use rustc_driver::{Callbacks, Compilation, run_compiler};
         use rustc_middle::ty::TyCtxt;
         use rustc_interface::interface;
-        use stable_mir::CompilerError;
+        use crate::stable_mir::CompilerError;
         use std::ops::ControlFlow;
 
         pub struct StableMir<B = (), C = (), F = fn($(optional!($with_tcx TyCtxt))?) -> ControlFlow<B, C>>

Diff for: compiler/rustc_smir/src/rustc_internal/pretty.rs

@@ -14,7 +14,7 @@ pub fn write_smir_pretty<'tcx, W: io::Write>(tcx: TyCtxt<'tcx>, w: &mut W) -> io
         "// If you find a bug or want to improve the output open a issue at https://github.com/rust-lang/project-stable-mir."
     )?;
     let _ = run(tcx, || {
-        let items = stable_mir::all_local_items();
+        let items = crate::stable_mir::all_local_items();
         let _ = items.iter().map(|item| -> io::Result<()> { item.emit_mir(w) }).collect::<Vec<_>>();
     });
     Ok(())

Diff for: compiler/rustc_smir/src/rustc_smir/alloc.rs

@@ -1,11 +1,11 @@
 use rustc_abi::{Align, Size};
 use rustc_middle::mir::ConstValue;
 use rustc_middle::mir::interpret::{AllocInit, AllocRange, Pointer, alloc_range};
-use stable_mir::Error;
-use stable_mir::mir::Mutability;
-use stable_mir::ty::{Allocation, ProvenanceMap};
 
 use crate::rustc_smir::{Stable, Tables};
+use crate::stable_mir::Error;
+use crate::stable_mir::mir::Mutability;
+use crate::stable_mir::ty::{Allocation, ProvenanceMap};
 
 /// Creates new empty `Allocation` from given `Align`.
 fn new_empty_allocation(align: Align) -> Allocation {

Diff for: compiler/rustc_smir/src/rustc_smir/builder.rs

@@ -30,7 +30,7 @@ impl<'tcx> BodyBuilder<'tcx> {
     /// Build a stable monomorphic body for a given instance based on the MIR body.
     ///
     /// All constants are also evaluated.
-    pub(crate) fn build(mut self, tables: &mut Tables<'tcx>) -> stable_mir::mir::Body {
+    pub(crate) fn build(mut self, tables: &mut Tables<'tcx>) -> crate::stable_mir::mir::Body {
         let body = tables.tcx.instance_mir(self.instance.def).clone();
         let mono_body = if !self.instance.args.is_empty()
             // Without the `generic_const_exprs` feature gate, anon consts in signatures do not