Simplify BodyCache impl and fix all remaining type errors in librustc_mir (lifetime errors still exist)

Author: Nashenas88

src/librustc/arena.rs

@@ -23,17 +23,17 @@ macro_rules! arena_types {
             [] generics: rustc::ty::Generics,
             [] trait_def: rustc::ty::TraitDef,
             [] adt_def: rustc::ty::AdtDef,
-            [] steal_mir: rustc::ty::steal::Steal<rustc::mir::Body<$tcx>>,
-            [] mir: rustc::mir::Body<$tcx>,
+            [] steal_mir: rustc::ty::steal::Steal<rustc::mir::BodyCache<$tcx>>,
+            [] mir: rustc::mir::BodyCache<$tcx>,
             [] steal_promoted: rustc::ty::steal::Steal<
                 rustc_index::vec::IndexVec<
                     rustc::mir::Promoted,
-                    rustc::mir::Body<$tcx>
+                    rustc::mir::BodyCache<$tcx>
                 >
             >,
             [] promoted: rustc_index::vec::IndexVec<
                 rustc::mir::Promoted,
-                rustc::mir::Body<$tcx>
+                rustc::mir::BodyCache<$tcx>
             >,
             [] tables: rustc::ty::TypeckTables<$tcx>,
             [] const_allocs: rustc::mir::interpret::Allocation,

src/librustc/mir/cache.rs

@@ -1,7 +1,7 @@
 use rustc_index::vec::IndexVec;
-//use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-//use rustc_serialize::{Encodable, Encoder, Decodable, Decoder};
-//use crate::ich::StableHashingContext;
+use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
+use rustc_serialize::{Encodable, Encoder, Decodable, Decoder};
+use crate::ich::StableHashingContext;
 use crate::mir::{BasicBlock, BasicBlockData, Body, LocalDecls, Location, Successors};
 use rustc_data_structures::graph::{self, GraphPredecessors, GraphSuccessors};
 use rustc_data_structures::graph::dominators::{dominators, Dominators};
@@ -14,23 +14,23 @@ pub struct Cache {
     predecessors: Option<IndexVec<BasicBlock, Vec<BasicBlock>>>,
 }
 
-//impl<'tcx, T> rustc_serialize::Encodable for Cache<'tcx, T> {
-//    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-//        Encodable::encode(&(), s)
-//    }
-//}
-//
-//impl<'tcx, T> rustc_serialize::Decodable for Cache<'tcx, T> {
-//    fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error> {
-//        Decodable::decode(d).map(|_v: ()| Self::new())
-//    }
-//}
-//
-//impl<'a, 'tcx, T> HashStable<StableHashingContext<'a>> for Cache<'tcx, T> {
-//    fn hash_stable(&self, _: &mut StableHashingContext<'a>, _: &mut StableHasher) {
-//        // Do nothing.
-//    }
-//}
+impl rustc_serialize::Encodable for Cache {
+    fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
+        Encodable::encode(&(), s)
+    }
+}
+
+impl rustc_serialize::Decodable for Cache {
+    fn decode<D: Decoder>(d: &mut D) -> Result<Self, D::Error> {
+        Decodable::decode(d).map(|_v: ()| Self::new())
+    }
+}
+
+impl<'a> HashStable<StableHashingContext<'a>> for Cache {
+    fn hash_stable(&self, _: &mut StableHashingContext<'a>, _: &mut StableHasher) {
+        // Do nothing.
+    }
+}
 
 macro_rules! get_predecessors {
     (mut $self:ident, $block:expr, $body:expr) => {
@@ -98,13 +98,13 @@ impl Cache {
 
     #[inline]
     /// This will recompute the predecessors cache if it is not available
-    pub fn predecessors(&mut self, body: &Body<'_>) -> &IndexVec<BasicBlock, Vec<BasicBlock>> {
+    fn predecessors(&mut self, body: &Body<'_>) -> &IndexVec<BasicBlock, Vec<BasicBlock>> {
         self.ensure_predecessors(body);
         self.predecessors.as_ref().unwrap()
     }
 
     #[inline]
-    pub fn predecessors_for(&mut self, bb: BasicBlock, body: &Body<'_>) -> &[BasicBlock] {
+    fn predecessors_for(&mut self, bb: BasicBlock, body: &Body<'_>) -> &[BasicBlock] {
         &self.predecessors(body)[bb]
     }
 
@@ -136,55 +136,58 @@ impl Cache {
     }
 }
 
-pub struct BodyCache<T> {
+#[derive(Clone, Debug, RustcEncodable, RustcDecodable)]
+pub struct BodyCache<'tcx> {
     cache: Cache,
-    body: T,
+    body: Body<'tcx>,
 }
 
-impl<T> BodyCache<T> {
-    pub fn new(body: T) -> Self {
+impl BodyCache<'tcx> {
+    pub fn new(body: Body<'tcx>) -> Self {
         Self {
             cache: Cache::new(),
-            body
+            body,
         }
     }
 }
 
-impl<'a, 'tcx> BodyCache<&'a Body<'tcx>> {
-    #[inline]
-    pub fn predecessors_for(&mut self, bb: BasicBlock) -> &[BasicBlock] {
-        self.cache.predecessors_for(bb, self.body)
+impl BodyCache<'tcx> {
+    pub fn ensure_predecessors(&mut self) {
+        self.cache.ensure_predecessors(&self.body);
     }
 
-    #[inline]
-    pub fn body(&self) -> &'a Body<'tcx> {
-        self.body
+    pub fn predecessors(&mut self) -> &IndexVec<BasicBlock, Vec<BasicBlock>> {
+        self.cache.predecessors(&self.body)
     }
 
-    #[inline]
-    pub fn read_only(mut self) -> ReadOnlyBodyCache<'a, 'tcx> {
-        self.cache.ensure_predecessors(self.body);
+    pub fn read_only(&self) -> ReadOnlyBodyCache<'_, '_> {
+        assert!(self.cache.predecessors.is_some(), "");
         ReadOnlyBodyCache {
-            cache: self.cache,
-            body: self.body,
+            cache: &self.cache,
+            body: &self.body,
         }
     }
 
-    #[inline]
-    pub fn basic_blocks(&self) -> &IndexVec<BasicBlock, BasicBlockData<'tcx>> {
-        &self.body.basic_blocks
+    pub fn body(&self) -> &Body<'tcx> {
+        &self.body
     }
-}
 
-impl<'a, 'tcx> Deref for BodyCache<&'a Body<'tcx>> {
-    type Target = Body<'tcx>;
+    pub fn body_mut(&mut self) -> &mut Body<'tcx> {
+        &mut self.body
+    }
 
-    fn deref(&self) -> &Self::Target {
-        self.body
+    pub fn basic_blocks_mut(&mut self) -> &mut IndexVec<BasicBlock, BasicBlockData<'tcx>> {
+        self.cache.basic_blocks_mut(&mut self.body)
+    }
+
+    pub fn basic_blocks_and_local_decls_mut(
+        &mut self
+    ) -> (&mut IndexVec<BasicBlock, BasicBlockData<'tcx>>, &mut LocalDecls<'tcx>) {
+        self.cache.basic_blocks_and_local_decls_mut(&mut self.body)
     }
 }
 
-impl<'a, 'tcx> Index<BasicBlock> for BodyCache<&'a Body<'tcx>> {
+impl<'tcx> Index<BasicBlock> for BodyCache<'tcx> {
     type Output = BasicBlockData<'tcx>;
 
     #[inline]
@@ -193,69 +196,29 @@ impl<'a, 'tcx> Index<BasicBlock> for BodyCache<&'a Body<'tcx>> {
     }
 }
 
-impl<'a, 'tcx> BodyCache<&'a mut Body<'tcx>> {
-    #[inline]
-    pub fn body(&self) -> &Body<'tcx> {
-        self.body
-    }
-
-    #[inline]
-    pub fn body_mut(&mut self) -> &mut Body<'tcx> {
-        self.body
-    }
-
-    #[inline]
-    pub fn read_only(mut self) -> ReadOnlyBodyCache<'a, 'tcx> {
-        self.cache.ensure_predecessors(self.body);
-        ReadOnlyBodyCache {
-            cache: self.cache,
-            body: self.body,
-        }
-    }
-
-    #[inline]
-    pub fn basic_blocks(&self) -> &IndexVec<BasicBlock, BasicBlockData<'tcx>> {
-        &self.body.basic_blocks
-    }
-
-    #[inline]
-    pub fn basic_blocks_mut(&mut self) -> &mut IndexVec<BasicBlock, BasicBlockData<'tcx>> {
-        self.cache.basic_blocks_mut(&mut self.body)
+impl<'tcx> IndexMut<BasicBlock> for BodyCache<'tcx> {
+    fn index_mut(&mut self, index: BasicBlock) -> &mut Self::Output {
+        &mut self.basic_blocks_mut()[index]
     }
 }
 
-impl<'a, 'tcx> Deref for BodyCache<&'a mut Body<'tcx>> {
+impl<'tcx> Deref for BodyCache<'tcx> {
     type Target = Body<'tcx>;
 
     fn deref(&self) -> &Self::Target {
-        self.body
-    }
-}
-
-impl<'a, 'tcx> DerefMut for BodyCache<&'a mut Body<'tcx>> {
-    fn deref_mut(&mut self) -> &mut Body<'tcx> {
-        self.body
-    }
-}
-
-impl<'a, 'tcx> Index<BasicBlock> for BodyCache<&'a mut Body<'tcx>> {
-    type Output = BasicBlockData<'tcx>;
-
-    #[inline]
-    fn index(&self, index: BasicBlock) -> &BasicBlockData<'tcx> {
-        &self.body[index]
+        &self.body
     }
 }
 
-impl<'a, 'tcx> IndexMut<BasicBlock> for BodyCache<&'a mut Body<'tcx>> {
-    fn index_mut(&mut self, index: BasicBlock) -> &mut Self::Output {
-        self.cache.invalidate_predecessors();
-        &mut self.body.basic_blocks[index]
+impl<'tcx> DerefMut for BodyCache<'tcx> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.body
     }
 }
 
+#[derive(Copy, Clone, Debug)]
 pub struct ReadOnlyBodyCache<'a, 'tcx> {
-    cache: Cache,
+    cache: &'a Cache,
     body: &'a Body<'tcx>,
 }
 
@@ -289,13 +252,6 @@ impl ReadOnlyBodyCache<'a, 'tcx> {
     pub fn dominators(&self) -> Dominators<BasicBlock> {
         dominators(self)
     }
-
-    pub fn to_owned(self) -> BodyCache<&'a Body<'tcx>> {
-        BodyCache {
-            cache: self.cache,
-            body: self.body,
-        }
-    }
 }
 
 impl graph::DirectedGraph for ReadOnlyBodyCache<'a, 'tcx> {
@@ -358,4 +314,20 @@ impl Index<BasicBlock> for ReadOnlyBodyCache<'a, 'tcx> {
     fn index(&self, index: BasicBlock) -> &BasicBlockData<'tcx> {
         &self.body[index]
     }
-}
+}
+
+CloneTypeFoldableAndLiftImpls! {
+    Cache,
+}
+
+impl_stable_hash_for!(struct BodyCache<'tcx> {
+    cache,
+    body,
+});
+
+BraceStructTypeFoldableImpl! {
+    impl<'tcx> TypeFoldable<'tcx> for BodyCache<'tcx> {
+        cache,
+        body
+    }
+}

src/librustc/mir/mod.rs

@@ -107,7 +107,7 @@ pub struct Body<'tcx> {
     pub yield_ty: Option<Ty<'tcx>>,
 
     /// Generator drop glue.
-    pub generator_drop: Option<Box<Body<'tcx>>>,
+    pub generator_drop: Option<Box<BodyCache<'tcx>>>,
 
     /// The layout of a generator. Produced by the state transformation.
     pub generator_layout: Option<GeneratorLayout<'tcx>>,
@@ -2600,7 +2600,7 @@ impl Location {
     pub fn is_predecessor_of<'tcx>(
         &self,
         other: Location,
-        body_cache: &ReadOnlyBodyCache<'_, 'tcx>
+        body_cache: ReadOnlyBodyCache<'_, 'tcx>
     ) -> bool {
         // If we are in the same block as the other location and are an earlier statement
         // then we are a predecessor of `other`.

src/librustc/mir/visit.rs

@@ -67,10 +67,10 @@ use syntax_pos::Span;
 
 macro_rules! body_cache_type {
     (mut $a:lifetime, $tcx:lifetime) => {
-        &mut BodyCache<& $a mut Body<$tcx>>
+        &mut BodyCache<$tcx>
     };
     ($a:lifetime, $tcx:lifetime) => {
-        &ReadOnlyBodyCache<$a, $tcx>
+        ReadOnlyBodyCache<$a, $tcx>
     };
 }
 

src/librustc/query/mod.rs

@@ -106,42 +106,46 @@ rustc_queries! {
 
         /// Fetch the MIR for a given `DefId` right after it's built - this includes
         /// unreachable code.
-        query mir_built(_: DefId) -> &'tcx Steal<mir::Body<'tcx>> {}
+        query mir_built(_: DefId) -> &'tcx Steal<mir::BodyCache<'tcx>> {}
 
         /// Fetch the MIR for a given `DefId` up till the point where it is
         /// ready for const evaluation.
         ///
         /// See the README for the `mir` module for details.
-        query mir_const(_: DefId) -> &'tcx Steal<mir::Body<'tcx>> {
+        query mir_const(_: DefId) -> &'tcx Steal<mir::BodyCache<'tcx>> {
             no_hash
         }
 
         query mir_validated(_: DefId) ->
             (
-                &'tcx Steal<mir::Body<'tcx>>,
-                &'tcx Steal<IndexVec<mir::Promoted, mir::Body<'tcx>>>
+                &'tcx Steal<mir::BodyCache<'tcx>>,
+                &'tcx Steal<IndexVec<mir::Promoted, mir::BodyCache<'tcx>>>
             ) {
             no_hash
         }
 
         /// MIR after our optimization passes have run. This is MIR that is ready
         /// for codegen. This is also the only query that can fetch non-local MIR, at present.
-        query optimized_mir(key: DefId) -> &'tcx mir::Body<'tcx> {
+        query optimized_mir(key: DefId) -> &'tcx mir::BodyCache<'tcx> {
             cache_on_disk_if { key.is_local() }
             load_cached(tcx, id) {
-                let mir: Option<crate::mir::Body<'tcx>> = tcx.queries.on_disk_cache
-                                                            .try_load_query_result(tcx, id);
-                mir.map(|x| &*tcx.arena.alloc(x))
+                let mir: Option<crate::mir::BodyCache<'tcx>>
+                    = tcx.queries.on_disk_cache.try_load_query_result(tcx, id);
+                mir.map(|x| {
+                    let cache = tcx.arena.alloc(x);
+                    cache.ensure_predecessors();
+                    &*cache
+                })
             }
         }
 
-        query promoted_mir(key: DefId) -> &'tcx IndexVec<mir::Promoted, mir::Body<'tcx>> {
+        query promoted_mir(key: DefId) -> &'tcx IndexVec<mir::Promoted, mir::BodyCache<'tcx>> {
             cache_on_disk_if { key.is_local() }
             load_cached(tcx, id) {
                 let promoted: Option<
                     rustc_index::vec::IndexVec<
                         crate::mir::Promoted,
-                        crate::mir::Body<'tcx>
+                        crate::mir::BodyCache<'tcx>
                     >> = tcx.queries.on_disk_cache.try_load_query_result(tcx, id);
                 promoted.map(|p| &*tcx.arena.alloc(p))
             }
@@ -502,7 +506,7 @@ rustc_queries! {
         /// in the case of closures, this will be redirected to the enclosing function.
         query region_scope_tree(_: DefId) -> &'tcx region::ScopeTree {}
 
-        query mir_shims(key: ty::InstanceDef<'tcx>) -> &'tcx mir::Body<'tcx> {
+        query mir_shims(key: ty::InstanceDef<'tcx>) -> &'tcx mir::BodyCache<'tcx> {
             no_force
             desc { |tcx| "generating MIR shim for `{}`", tcx.def_path_str(key.def_id()) }
         }