Fix remaining compilation issues

Author: Nashenas88

src/librustc/mir/cache.rs

@@ -151,6 +151,16 @@ impl BodyCache<'tcx> {
     }
 }
 
+#[macro_export]
+macro_rules! read_only {
+    ($body_cache:expr) => {
+        {
+            $body_cache.ensure_predecessors();
+            $body_cache.unwrap_read_only()
+        }
+    };
+}
+
 impl BodyCache<'tcx> {
     pub fn ensure_predecessors(&mut self) {
         self.cache.ensure_predecessors(&self.body);
@@ -160,12 +170,8 @@ impl BodyCache<'tcx> {
         self.cache.predecessors(&self.body)
     }
 
-    pub fn read_only(&self) -> ReadOnlyBodyCache<'_, '_> {
-        assert!(self.cache.predecessors.is_some(), "");
-        ReadOnlyBodyCache {
-            cache: &self.cache,
-            body: &self.body,
-        }
+    pub fn unwrap_read_only(&self) -> ReadOnlyBodyCache<'_, 'tcx> {
+        ReadOnlyBodyCache::new(&self.cache, &self.body)
     }
 
     pub fn body(&self) -> &Body<'tcx> {
@@ -176,6 +182,8 @@ impl BodyCache<'tcx> {
         &mut self.body
     }
 
+    pub fn cache(&self) -> &Cache { &self.cache }
+
     pub fn basic_blocks_mut(&mut self) -> &mut IndexVec<BasicBlock, BasicBlockData<'tcx>> {
         self.cache.basic_blocks_mut(&mut self.body)
     }
@@ -223,6 +231,24 @@ pub struct ReadOnlyBodyCache<'a, 'tcx> {
 }
 
 impl ReadOnlyBodyCache<'a, 'tcx> {
+    fn new(cache: &'a Cache, body: &'a Body<'tcx>) -> Self {
+        assert!(
+            cache.predecessors.is_some(),
+            "Cannot construct ReadOnlyBodyCache without computed predecessors");
+        Self {
+            cache,
+            body,
+        }
+    }
+
+    pub fn from_external_cache(cache: &'a mut Cache, body: &'a Body<'tcx>) -> Self {
+        cache.ensure_predecessors(body);
+        Self {
+            cache,
+            body,
+        }
+    }
+
     #[inline]
     pub fn predecessors(&self) -> &IndexVec<BasicBlock, Vec<BasicBlock>> {
         self.cache.predecessors.as_ref().unwrap()

src/librustc/mir/mod.rs

@@ -38,7 +38,9 @@ use syntax::symbol::Symbol;
 use syntax_pos::{Span, DUMMY_SP};
 
 pub use crate::mir::interpret::AssertMessage;
-pub use crate::mir::cache::{BodyCache, ReadOnlyBodyCache};
+// TODO(nashenas88) Cache only exported for use in librustc_mir/transform/check_unsafety.rs
+pub use crate::mir::cache::{BodyCache, Cache, ReadOnlyBodyCache};
+pub use crate::read_only;
 
 pub mod cache;
 pub mod interpret;

src/librustc/query/mod.rs

@@ -147,7 +147,13 @@ rustc_queries! {
                         crate::mir::Promoted,
                         crate::mir::BodyCache<'tcx>
                     >> = tcx.queries.on_disk_cache.try_load_query_result(tcx, id);
-                promoted.map(|p| &*tcx.arena.alloc(p))
+                promoted.map(|p| {
+                    let cache = tcx.arena.alloc(p);
+                    for body_cache in cache.iter_mut() {
+                        body_cache.ensure_predecessors();
+                    }
+                    &*cache
+                })
             }
         }
     }

src/librustc/ty/mod.rs

@@ -2988,7 +2988,7 @@ impl<'tcx> TyCtxt<'tcx> {
     pub fn instance_mir(self, instance: ty::InstanceDef<'tcx>) -> ReadOnlyBodyCache<'tcx, 'tcx> {
         match instance {
             ty::InstanceDef::Item(did) => {
-                self.optimized_mir(did).read_only()
+                self.optimized_mir(did).unwrap_read_only()
             }
             ty::InstanceDef::VtableShim(..) |
             ty::InstanceDef::ReifyShim(..) |
@@ -2998,7 +2998,7 @@ impl<'tcx> TyCtxt<'tcx> {
             ty::InstanceDef::ClosureOnceShim { .. } |
             ty::InstanceDef::DropGlue(..) |
             ty::InstanceDef::CloneShim(..) => {
-                self.mir_shims(instance).read_only()
+                self.mir_shims(instance).unwrap_read_only()
             }
         }
     }

src/librustc_metadata/rmeta/decoder.rs

@@ -1080,25 +1080,31 @@ impl<'a, 'tcx> CrateMetadata {
     }
 
     fn get_optimized_mir(&self, tcx: TyCtxt<'tcx>, id: DefIndex) -> BodyCache<'tcx> {
-        self.root.per_def.mir.get(self, id)
+        let mut cache = self.root.per_def.mir.get(self, id)
             .filter(|_| !self.is_proc_macro(id))
             .unwrap_or_else(|| {
                 bug!("get_optimized_mir: missing MIR for `{:?}`", self.local_def_id(id))
             })
-            .decode((self, tcx))
+            .decode((self, tcx));
+        cache.ensure_predecessors();
+        cache
     }
 
     fn get_promoted_mir(
         &self,
         tcx: TyCtxt<'tcx>,
         id: DefIndex,
     ) -> IndexVec<Promoted, BodyCache<'tcx>> {
-        self.root.per_def.promoted_mir.get(self, id)
+        let mut cache = self.root.per_def.promoted_mir.get(self, id)
             .filter(|_| !self.is_proc_macro(id))
             .unwrap_or_else(|| {
                 bug!("get_promoted_mir: missing MIR for `{:?}`", self.local_def_id(id))
             })
-            .decode((self, tcx))
+            .decode((self, tcx));
+        for body_cache in cache.iter_mut() {
+            body_cache.ensure_predecessors();
+        }
+        cache
     }
 
     fn mir_const_qualif(&self, id: DefIndex) -> mir::ConstQualifs {

src/librustc_mir/borrow_check/mod.rs

@@ -10,7 +10,7 @@ use rustc::lint::builtin::{MUTABLE_BORROW_RESERVATION_CONFLICT};
 use rustc::mir::{AggregateKind, BasicBlock, BorrowCheckResult, BorrowKind};
 use rustc::mir::{
     ClearCrossCrate, Local, Location, Body, BodyCache, Mutability, Operand, Place, PlaceBase,
-    PlaceElem, PlaceRef, ReadOnlyBodyCache, Static, StaticKind
+    PlaceElem, PlaceRef, ReadOnlyBodyCache, Static, StaticKind, read_only
 };
 use rustc::mir::{Field, ProjectionElem, Promoted, Rvalue, Statement, StatementKind};
 use rustc::mir::{Terminator, TerminatorKind};
@@ -167,8 +167,8 @@ fn do_mir_borrowck<'a, 'tcx>(
     let mut body_cache = BodyCache::new(body);
     let free_regions =
         nll::replace_regions_in_mir(infcx, def_id, param_env, &mut body_cache, &mut promoted);
-    let body_cache = body_cache.read_only(); // no further changes
-    let promoted: IndexVec<_, _> = promoted.iter().map(|body_cache| body_cache.read_only()).collect();
+    let body_cache = read_only!(body_cache); // no further changes
+    let promoted: IndexVec<_, _> = promoted.iter_mut().map(|body_cache| read_only!(body_cache)).collect();
 
     let location_table = &LocationTable::new(&body_cache);
 
@@ -492,7 +492,7 @@ impl<'cx, 'tcx> DataflowResultsConsumer<'cx, 'tcx> for MirBorrowckCtxt<'cx, 'tcx
     type FlowState = Flows<'cx, 'tcx>;
 
     fn body(&self) -> &'cx Body<'tcx> {
-        &self.body_cache
+        self.body_cache.body()
     }
 
     fn visit_block_entry(&mut self, bb: BasicBlock, flow_state: &Self::FlowState) {

src/librustc_mir/borrow_check/nll/type_check/liveness/trace.rs

@@ -302,7 +302,8 @@ impl LivenessResults<'me, 'typeck, 'flow, 'tcx> {
             }
         }
 
-        for &pred_block in self.cx.body_cache.predecessors_for(block).iter() {
+        let body_cache = self.cx.body_cache;
+        for &pred_block in body_cache.predecessors_for(block).iter() {
             debug!("compute_drop_live_points_for_block: pred_block = {:?}", pred_block,);
 
             // Check whether the variable is (at least partially)

src/librustc_mir/borrow_check/nll/type_check/mod.rs

@@ -540,7 +540,7 @@ impl<'a, 'b, 'tcx> TypeVerifier<'a, 'b, 'tcx> {
         // checker on the promoted MIR, then transfer the constraints back to
         // the main MIR, changing the locations to the provided location.
 
-        let parent_body = mem::replace(&mut self.body, &promoted_body_cache);
+        let parent_body = mem::replace(&mut self.body, promoted_body_cache.body());
 
         // Use new sets of constraints and closure bounds so that we can
         // modify their locations.

src/librustc_mir/borrow_check/prefixes.rs

@@ -56,7 +56,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
         Prefixes {
             next: Some(place_ref),
             kind,
-            body: &self.body_cache,
+            body: self.body_cache.body(),
             tcx: self.infcx.tcx,
         }
     }

src/librustc_mir/interpret/eval_context.rs

@@ -303,11 +303,11 @@ impl<'mir, 'tcx, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
         }
         trace!("load mir(instance={:?}, promoted={:?})", instance, promoted);
         if let Some(promoted) = promoted {
-            return Ok(self.tcx.promoted_mir(did)[promoted].read_only());
+            return Ok(self.tcx.promoted_mir(did)[promoted].unwrap_read_only());
         }
         match instance {
             ty::InstanceDef::Item(def_id) => if self.tcx.is_mir_available(did) {
-                Ok(self.tcx.optimized_mir(did).read_only())
+                Ok(self.tcx.optimized_mir(did).unwrap_read_only())
             } else {
                 throw_unsup!(NoMirFor(self.tcx.def_path_str(def_id)))
             },