Simplify Cache wrapper to single type, impl Deref on it, fix all compilation errors in librustc_codegen_ssa

Author: Nashenas88

src/librustc/mir/cache.rs

@@ -6,7 +6,7 @@ use crate::mir::{BasicBlock, BasicBlockData, Body, LocalDecls, Location, Success
 use rustc_data_structures::graph::{self, GraphPredecessors, GraphSuccessors};
 use rustc_data_structures::graph::dominators::{dominators, Dominators};
 use std::iter;
-use std::ops::{Index, IndexMut};
+use std::ops::{Deref, DerefMut, Index, IndexMut};
 use std::vec::IntoIter;
 
 #[derive(Clone, Debug)]
@@ -111,33 +111,21 @@ impl Cache {
     }
 }
 
-pub struct OwningCache<'tcx> {
+pub struct BodyCache<T> {
     cache: Cache,
-    body: Body<'tcx>,
+    body: T,
 }
 
-impl<'tcx> OwningCache<'tcx> {
-    pub fn borrow(&mut self) -> BorrowedCache<'_, 'tcx> {
-        BorrowedCache {
-            cache: &mut self.cache,
-            body: &self.body,
-        }
-    }
-
-    pub fn borrow_mut(&mut self) -> MutCache<'_, 'tcx> {
-        MutCache {
-            cache: &mut self.cache,
-            body: &mut self.body,
+impl<T> BodyCache<T> {
+    pub fn new(body: T) -> Self {
+        Self {
+            cache: Cache::new(),
+            body
         }
     }
 }
 
-pub struct BorrowedCache<'a, 'tcx> {
-    cache: &'a mut Cache,
-    body: &'a Body<'tcx>
-}
-
-impl<'a, 'tcx> BorrowedCache<'a, 'tcx> {
+impl<'a, 'tcx> BodyCache<&'a Body<'tcx>> {
     #[inline]
     pub fn predecessors_for(&mut self, bb: BasicBlock) -> &[BasicBlock] {
         self.cache.predecessors_for(bb, self.body)
@@ -159,7 +147,14 @@ impl<'a, 'tcx> BorrowedCache<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> Index<BasicBlock> for BorrowedCache<'a, 'tcx> {
+impl<'a, 'tcx> Deref for BodyCache<&'a Body<'tcx>> {
+    type Target = Body<'tcx>;
+    fn deref(&self) -> &Body<'tcx> {
+        self.body
+    }
+}
+
+impl<'a, 'tcx> Index<BasicBlock> for BodyCache<&'a Body<'tcx>> {
     type Output = BasicBlockData<'tcx>;
 
     #[inline]
@@ -168,16 +163,16 @@ impl<'a, 'tcx> Index<BasicBlock> for BorrowedCache<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> graph::DirectedGraph for BorrowedCache<'a, 'tcx> {
+impl<'a, 'tcx> graph::DirectedGraph for BodyCache<&'a Body<'tcx>> {
     type Node = BasicBlock;
 }
 
-impl<'a, 'graph, 'tcx> graph::GraphPredecessors<'graph> for BorrowedCache<'a, 'tcx> {
+impl<'a, 'graph, 'tcx> graph::GraphPredecessors<'graph> for BodyCache<&'a Body<'tcx>> {
     type Item = BasicBlock;
     type Iter = IntoIter<BasicBlock>;
 }
 
-impl<'a, 'tcx> graph::WithPredecessors for BorrowedCache<'a, 'tcx> {
+impl<'a, 'tcx> graph::WithPredecessors for BodyCache<&'a Body<'tcx>> {
     fn predecessors(
         &mut self,
         node: Self::Node,
@@ -186,19 +181,19 @@ impl<'a, 'tcx> graph::WithPredecessors for BorrowedCache<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> graph::WithNumNodes for BorrowedCache<'a, 'tcx> {
+impl<'a, 'tcx> graph::WithNumNodes for BodyCache<&'a Body<'tcx>> {
     fn num_nodes(&self) -> usize {
         self.body.num_nodes()
     }
 }
 
-impl<'a, 'tcx> graph::WithStartNode for BorrowedCache<'a, 'tcx> {
+impl<'a, 'tcx> graph::WithStartNode for BodyCache<&'a Body<'tcx>> {
     fn start_node(&self) -> Self::Node {
         self.body.start_node()
     }
 }
 
-impl<'a, 'tcx> graph::WithSuccessors for BorrowedCache<'a, 'tcx> {
+impl<'a, 'tcx> graph::WithSuccessors for BodyCache<&'a Body<'tcx>> {
     fn successors(
         &self,
         node: Self::Node,
@@ -207,17 +202,12 @@ impl<'a, 'tcx> graph::WithSuccessors for BorrowedCache<'a, 'tcx> {
     }
 }
 
-impl<'a, 'b, 'tcx> graph::GraphSuccessors<'b> for BorrowedCache<'a, 'tcx> {
+impl<'a, 'b, 'tcx> graph::GraphSuccessors<'b> for BodyCache<&'a Body<'tcx>> {
     type Item = BasicBlock;
     type Iter = iter::Cloned<Successors<'b>>;
 }
 
-pub struct MutCache<'a, 'tcx> {
-    cache: &'a mut Cache,
-    body: &'a mut Body<'tcx>,
-}
-
-impl<'a, 'tcx> MutCache<'a, 'tcx> {
+impl<'a, 'tcx> BodyCache<&'a mut Body<'tcx>> {
     #[inline]
     pub fn body(&mut self) -> &mut Body<'tcx> {
         self.body
@@ -234,7 +224,21 @@ impl<'a, 'tcx> MutCache<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> Index<BasicBlock> for MutCache<'a, 'tcx> {
+impl<'a, 'tcx> Deref for BodyCache<&'a mut Body<'tcx>> {
+    type Target = Body<'tcx>;
+
+    fn deref(&self) -> &Body<'tcx> {
+        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]
@@ -243,13 +247,9 @@ impl<'a, 'tcx> Index<BasicBlock> for MutCache<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> IndexMut<BasicBlock> for MutCache<'a, 'tcx> {
+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]
     }
 }
-
-//CloneTypeFoldableAndLiftImpls! {
-//    Cache,
-//}

src/librustc/mir/mod.rs

@@ -38,6 +38,7 @@ use syntax::symbol::Symbol;
 use syntax_pos::{Span, DUMMY_SP};
 
 pub use crate::mir::interpret::AssertMessage;
+pub use crate::mir::cache::BodyCache;
 
 pub mod cache;
 pub mod interpret;
@@ -2596,7 +2597,11 @@ impl Location {
     }
 
     /// Returns `true` if `other` is earlier in the control flow graph than `self`.
-    pub fn is_predecessor_of<'tcx>(&self, other: Location, mut body_cache: cache::BorrowedCache<'_, 'tcx>) -> bool {
+    pub fn is_predecessor_of<'tcx>(
+        &self,
+        other: Location,
+        mut body_cache: BodyCache<&'_ Body<'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`.
         if self.block == other.block && self.statement_index < other.statement_index {

src/librustc/mir/visit.rs

@@ -1,7 +1,6 @@
 use crate::ty::subst::SubstsRef;
 use crate::ty::{CanonicalUserTypeAnnotation, Ty};
 use crate::mir::*;
-use crate::mir::cache::*;
 use syntax_pos::Span;
 
 // # The MIR Visitor
@@ -72,7 +71,10 @@ macro_rules! make_mir_visitor {
             // Override these, and call `self.super_xxx` to revert back to the
             // default behavior.
 
-            fn visit_body(&mut self, body_cache: & $($mutability)? cache_type!('tcx $($mutability)?)) {
+            fn visit_body(
+                &mut self,
+                body_cache: & $($mutability)? BodyCache<&'_ $($mutability)? Body<'tcx>>
+            ) {
                 self.super_body(body_cache);
             }
 
@@ -241,8 +243,10 @@ macro_rules! make_mir_visitor {
             // The `super_xxx` methods comprise the default behavior and are
             // not meant to be overridden.
 
-            fn super_body(&mut self,
-                         body_cache: & $($mutability)? cache_type!('tcx $($mutability)?)) {
+            fn super_body(
+                &mut self,
+                body_cache: & $($mutability)? BodyCache<&'_ $($mutability)? Body<'tcx>>
+            ) {
                 let span = body_cache.body().span;
                 if let Some(yield_ty) = &$($mutability)? body_cache.body().yield_ty {
                     self.visit_ty(yield_ty, TyContext::YieldTy(SourceInfo {
@@ -793,7 +797,11 @@ macro_rules! make_mir_visitor {
 
             // Convenience methods
 
-            fn visit_location(&mut self, body_cache: & $($mutability)? cache_type!('tcx $($mutability)?), location: Location) {
+            fn visit_location(
+                &mut self,
+                body_cache: & $($mutability)? BodyCache<&'_ $($mutability)? Body<'tcx>>,
+                location: Location
+            ) {
                 let basic_block = & $($mutability)? body_cache[location.block];
                 if basic_block.statements.len() == location.statement_index {
                     if let Some(ref $($mutability)? terminator) = basic_block.terminator {
@@ -809,11 +817,6 @@ macro_rules! make_mir_visitor {
     }
 }
 
-macro_rules! cache_type {
-    ($tcx:lifetime mut) => {MutCache<'_, $tcx>};
-    ($tcx:lifetime) => {BorrowedCache<'_, $tcx>};
-}
-
 macro_rules! visit_place_fns {
     (mut) => (
         fn tcx<'a>(&'a self) -> TyCtxt<'tcx>;

src/librustc_codegen_ssa/base.rs

@@ -31,6 +31,7 @@ use rustc::hir::def_id::{DefId, LOCAL_CRATE};
 use rustc::middle::cstore::EncodedMetadata;
 use rustc::middle::lang_items::StartFnLangItem;
 use rustc::middle::weak_lang_items;
+use rustc::mir::BodyCache;
 use rustc::mir::mono::{CodegenUnitNameBuilder, CodegenUnit, MonoItem};
 use rustc::ty::{self, Ty, TyCtxt, Instance};
 use rustc::ty::layout::{self, Align, TyLayout, LayoutOf, VariantIdx, HasTyCtxt};
@@ -374,7 +375,9 @@ pub fn codegen_instance<'a, 'tcx: 'a, Bx: BuilderMethods<'a, 'tcx>>(
     let lldecl = cx.get_fn(instance);
 
     let mir = cx.tcx().instance_mir(instance.def);
-    mir::codegen_mir::<Bx>(cx, lldecl, &mir, instance, sig);
+    // TODO(nashenas88) move this into instance_mir before merging PR
+    let mut mir = BodyCache::new(mir);
+    mir::codegen_mir::<Bx>(cx, lldecl, &mut mir, instance, sig);
 }
 
 /// Creates the `main` function which will initialize the rust runtime and call

src/librustc_codegen_ssa/mir/analyze.rs

@@ -4,7 +4,7 @@
 use rustc_index::bit_set::BitSet;
 use rustc_data_structures::graph::dominators::Dominators;
 use rustc_index::vec::{Idx, IndexVec};
-use rustc::mir::{self, Location, TerminatorKind};
+use rustc::mir::{self, Body, BodyCache, Location, TerminatorKind};
 use rustc::mir::visit::{
     Visitor, PlaceContext, MutatingUseContext, NonMutatingUseContext, NonUseContext,
 };
@@ -17,10 +17,10 @@ use super::FunctionCx;
 use crate::traits::*;
 
 pub fn non_ssa_locals<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
-    fx: &FunctionCx<'a, 'tcx, Bx>,
+    fx: &mut FunctionCx<'a, 'tcx, Bx>,
 ) -> BitSet<mir::Local> {
-    let mir = fx.mir;
-    let mut analyzer = LocalAnalyzer::new(fx);
+    let mir = fx.mir.take().unwrap();
+    let mut analyzer = LocalAnalyzer::new(fx, mir);
 
     analyzer.visit_body(mir);
 
@@ -54,11 +54,14 @@ pub fn non_ssa_locals<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
         }
     }
 
-    analyzer.non_ssa_locals
+    let (mir, non_ssa_locals) = analyzer.finalize();
+    fx.mir = Some(mir);
+    non_ssa_locals
 }
 
 struct LocalAnalyzer<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> {
     fx: &'mir FunctionCx<'a, 'tcx, Bx>,
+    mir: &'a mut BodyCache<&'a Body<'tcx>>,
     dominators: Dominators<mir::BasicBlock>,
     non_ssa_locals: BitSet<mir::Local>,
     // The location of the first visited direct assignment to each
@@ -67,27 +70,32 @@ struct LocalAnalyzer<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> {
 }
 
 impl<Bx: BuilderMethods<'a, 'tcx>> LocalAnalyzer<'mir, 'a, 'tcx, Bx> {
-    fn new(fx: &'mir FunctionCx<'a, 'tcx, Bx>) -> Self {
+    fn new(fx: &'mir FunctionCx<'a, 'tcx, Bx>, mir: &'a mut BodyCache<&'a Body<'tcx>>) -> Self {
         let invalid_location =
-            mir::BasicBlock::new(fx.mir.basic_blocks().len()).start_location();
+            mir::BasicBlock::new(mir.basic_blocks().len()).start_location();
         let mut analyzer = LocalAnalyzer {
             fx,
-            dominators: fx.mir.dominators(),
-            non_ssa_locals: BitSet::new_empty(fx.mir.local_decls.len()),
-            first_assignment: IndexVec::from_elem(invalid_location, &fx.mir.local_decls)
+            dominators: mir.dominators(),
+            mir,
+            non_ssa_locals: BitSet::new_empty(mir.local_decls.len()),
+            first_assignment: IndexVec::from_elem(invalid_location, &mir.local_decls)
         };
 
         // Arguments get assigned to by means of the function being called
-        for arg in fx.mir.args_iter() {
+        for arg in mir.args_iter() {
             analyzer.first_assignment[arg] = mir::START_BLOCK.start_location();
         }
 
         analyzer
     }
 
+    fn finalize(self) -> (&'a mut BodyCache<&'a Body<'tcx>>, BitSet<mir::Local>) {
+        (self.mir, self.non_ssa_locals)
+    }
+
     fn first_assignment(&self, local: mir::Local) -> Option<Location> {
         let location = self.first_assignment[local];
-        if location.block.index() < self.fx.mir.basic_blocks().len() {
+        if location.block.index() < self.mir.basic_blocks().len() {
             Some(location)
         } else {
             None
@@ -130,7 +138,7 @@ impl<Bx: BuilderMethods<'a, 'tcx>> LocalAnalyzer<'mir, 'a, 'tcx, Bx> {
             };
             if is_consume {
                 let base_ty =
-                    mir::Place::ty_from(place_ref.base, proj_base, self.fx.mir, cx.tcx());
+                    mir::Place::ty_from(place_ref.base, proj_base, self.mir.body(), cx.tcx());
                 let base_ty = self.fx.monomorphize(&base_ty);
 
                 // ZSTs don't require any actual memory access.
@@ -139,7 +147,7 @@ impl<Bx: BuilderMethods<'a, 'tcx>> LocalAnalyzer<'mir, 'a, 'tcx, Bx> {
                     .ty;
                 let elem_ty = self.fx.monomorphize(&elem_ty);
                 let span = if let mir::PlaceBase::Local(index) = place_ref.base {
-                    self.fx.mir.local_decls[*index].source_info.span
+                    self.mir.local_decls[*index].source_info.span
                 } else {
                     DUMMY_SP
                 };
@@ -243,7 +251,7 @@ impl<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx>
 
         if let Some(index) = place.as_local() {
             self.assign(index, location);
-            let decl_span = self.fx.mir.local_decls[index].source_info.span;
+            let decl_span = self.mir.local_decls[index].source_info.span;
             if !self.fx.rvalue_creates_operand(rvalue, decl_span) {
                 self.not_ssa(index);
             }
@@ -348,7 +356,7 @@ impl<'mir, 'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> Visitor<'tcx>
             }
 
             PlaceContext::MutatingUse(MutatingUseContext::Drop) => {
-                let ty = self.fx.mir.local_decls[local].ty;
+                let ty = self.mir.local_decls[local].ty;
                 let ty = self.fx.monomorphize(&ty);
 
                 // Only need the place if we're actually dropping it.