Remove HasLocalDecls impl from BodyCache's, properly reborrow to Body, rename all body_cache back to body

Author: Nashenas88

src/librustc/mir/cache.rs

@@ -2,7 +2,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 crate::mir::{BasicBlock, BasicBlockData, Body, HasLocalDecls, LocalDecls, Location, Successors};
+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};
 use std::iter;
@@ -160,10 +160,10 @@ impl BodyCache<'tcx> {
 
 #[macro_export]
 macro_rules! read_only {
-    ($body_cache:expr) => {
+    ($body:expr) => {
         {
-            $body_cache.ensure_predecessors();
-            $body_cache.unwrap_read_only()
+            $body.ensure_predecessors();
+            $body.unwrap_read_only()
         }
     };
 }
@@ -223,12 +223,6 @@ impl<'tcx> DerefMut for BodyCache<'tcx> {
     }
 }
 
-impl<'tcx> HasLocalDecls<'tcx> for BodyCache<'tcx> {
-    fn local_decls(&self) -> &LocalDecls<'tcx> {
-        &self.body.local_decls
-    }
-}
-
 #[derive(Copy, Clone, Debug)]
 pub struct ReadOnlyBodyCache<'a, 'tcx> {
     cache: &'a Cache,
@@ -347,12 +341,6 @@ impl Index<BasicBlock> for ReadOnlyBodyCache<'a, 'tcx> {
     }
 }
 
-impl<'a, 'tcx> HasLocalDecls<'tcx> for ReadOnlyBodyCache<'a, 'tcx> {
-    fn local_decls(&self) -> &LocalDecls<'tcx> {
-        &self.body.local_decls
-    }
-}
-
 CloneTypeFoldableAndLiftImpls! {
     Cache,
 }

src/librustc/mir/mod.rs

@@ -2602,7 +2602,7 @@ impl Location {
     pub fn is_predecessor_of<'tcx>(
         &self,
         other: Location,
-        body_cache: ReadOnlyBodyCache<'_, 'tcx>
+        body: 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`.
@@ -2611,13 +2611,13 @@ impl Location {
         }
 
         // If we're in another block, then we want to check that block is a predecessor of `other`.
-        let mut queue: Vec<BasicBlock> = body_cache.predecessors_for(other.block).to_vec();
+        let mut queue: Vec<BasicBlock> = body.predecessors_for(other.block).to_vec();
         let mut visited = FxHashSet::default();
 
         while let Some(block) = queue.pop() {
             // If we haven't visited this block before, then make sure we visit it's predecessors.
             if visited.insert(block) {
-                queue.extend(body_cache.predecessors_for(block).iter().cloned());
+                queue.extend(body.predecessors_for(block).iter().cloned());
             } else {
                 continue;
             }

src/librustc/mir/visit.rs

@@ -82,9 +82,9 @@ macro_rules! make_mir_visitor {
 
             fn visit_body(
                 &mut self,
-                body_cache: body_cache_type!($($mutability)? '_, 'tcx)
+                body: body_cache_type!($($mutability)? '_, 'tcx)
             ) {
-                self.super_body(body_cache);
+                self.super_body(body);
             }
 
             fn visit_basic_block_data(&mut self,
@@ -254,10 +254,10 @@ macro_rules! make_mir_visitor {
 
             fn super_body(
                 &mut self,
-                $($mutability)? body_cache: body_cache_type!($($mutability)? '_, 'tcx)
+                $($mutability)? body: body_cache_type!($($mutability)? '_, 'tcx)
             ) {
-                let span = body_cache.span;
-                if let Some(yield_ty) = &$($mutability)? body_cache.yield_ty {
+                let span = body.span;
+                if let Some(yield_ty) = &$($mutability)? body.yield_ty {
                     self.visit_ty(yield_ty, TyContext::YieldTy(SourceInfo {
                         span,
                         scope: OUTERMOST_SOURCE_SCOPE,
@@ -268,14 +268,14 @@ macro_rules! make_mir_visitor {
                 // than a for-loop, to avoid calling `body::Body::invalidate` for
                 // each basic block.
                 macro_rules! basic_blocks {
-                    (mut) => (body_cache.basic_blocks_mut().iter_enumerated_mut());
-                    () => (body_cache.basic_blocks().iter_enumerated());
+                    (mut) => (body.basic_blocks_mut().iter_enumerated_mut());
+                    () => (body.basic_blocks().iter_enumerated());
                 };
                 for (bb, data) in basic_blocks!($($mutability)?) {
                     self.visit_basic_block_data(bb, data);
                 }
 
-                let body: & $($mutability)? Body<'_> = & $($mutability)? body_cache;
+                let body: & $($mutability)? Body<'_> = & $($mutability)? body;
                 for scope in &$($mutability)? body.source_scopes {
                     self.visit_source_scope_data(scope);
                 }
@@ -808,10 +808,10 @@ macro_rules! make_mir_visitor {
 
             fn visit_location(
                 &mut self,
-                body_cache: body_cache_type!($($mutability)? '_, 'tcx),
+                body: body_cache_type!($($mutability)? '_, 'tcx),
                 location: Location
             ) {
-                let basic_block = & $($mutability)? body_cache[location.block];
+                let basic_block = & $($mutability)? body[location.block];
                 if basic_block.statements.len() == location.statement_index {
                     if let Some(ref $($mutability)? terminator) = basic_block.terminator {
                         self.visit_terminator(terminator, location)

src/librustc/query/mod.rs

@@ -149,8 +149,8 @@ rustc_queries! {
                     >> = tcx.queries.on_disk_cache.try_load_query_result(tcx, id);
                 promoted.map(|p| {
                     let cache = tcx.arena.alloc(p);
-                    for body_cache in cache.iter_mut() {
-                        body_cache.ensure_predecessors();
+                    for body in cache.iter_mut() {
+                        body.ensure_predecessors();
                     }
                     &*cache
                 })

src/librustc/ty/context.rs

@@ -1083,8 +1083,8 @@ impl<'tcx> TyCtxt<'tcx> {
         &self.hir_map
     }
 
-    pub fn alloc_steal_mir(self, mir_cache: BodyCache<'tcx>) -> &'tcx Steal<BodyCache<'tcx>> {
-        self.arena.alloc(Steal::new(mir_cache))
+    pub fn alloc_steal_mir(self, mir: BodyCache<'tcx>) -> &'tcx Steal<BodyCache<'tcx>> {
+        self.arena.alloc(Steal::new(mir))
     }
 
     pub fn alloc_steal_promoted(self, promoted: IndexVec<Promoted, BodyCache<'tcx>>) ->

src/librustc_codegen_ssa/mir/analyze.rs

@@ -131,7 +131,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.fx.mir, cx.tcx());
                 let base_ty = self.fx.monomorphize(&base_ty);
 
                 // ZSTs don't require any actual memory access.

src/librustc_codegen_ssa/mir/block.rs

@@ -324,7 +324,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         target: mir::BasicBlock,
         unwind: Option<mir::BasicBlock>,
     ) {
-        let ty = location.ty(&self.mir, bx.tcx()).ty;
+        let ty = location.ty(&*self.mir, bx.tcx()).ty;
         let ty = self.monomorphize(&ty);
         let drop_fn = Instance::resolve_drop_in_place(bx.tcx(), ty);
 
@@ -510,7 +510,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
 
         let extra_args = &args[sig.inputs().len()..];
         let extra_args = extra_args.iter().map(|op_arg| {
-            let op_ty = op_arg.ty(&self.mir, bx.tcx());
+            let op_ty = op_arg.ty(&*self.mir, bx.tcx());
             self.monomorphize(&op_ty)
         }).collect::<Vec<_>>();
 

src/librustc_codegen_ssa/mir/place.rs

@@ -594,7 +594,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
         let place_ty = mir::Place::ty_from(
             place_ref.base,
             place_ref.projection,
-            &self.mir,
+            &*self.mir,
             tcx,
         );
         self.monomorphize(&place_ty.ty)

src/librustc_codegen_ssa/mir/rvalue.rs

@@ -460,7 +460,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             }
 
             mir::Rvalue::Discriminant(ref place) => {
-                let discr_ty = rvalue.ty(&self.mir, bx.tcx());
+                let discr_ty = rvalue.ty(&*self.mir, bx.tcx());
                 let discr =  self.codegen_place(&mut bx, &place.as_ref())
                     .codegen_get_discr(&mut bx, discr_ty);
                 (bx, OperandRef {
@@ -513,7 +513,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             mir::Rvalue::Aggregate(..) => {
                 // According to `rvalue_creates_operand`, only ZST
                 // aggregate rvalues are allowed to be operands.
-                let ty = rvalue.ty(&self.mir, self.cx.tcx());
+                let ty = rvalue.ty(&*self.mir, self.cx.tcx());
                 let operand = OperandRef::new_zst(
                     &mut bx,
                     self.cx.layout_of(self.monomorphize(&ty)),
@@ -710,7 +710,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 true,
             mir::Rvalue::Repeat(..) |
             mir::Rvalue::Aggregate(..) => {
-                let ty = rvalue.ty(&self.mir, self.cx.tcx());
+                let ty = rvalue.ty(&*self.mir, self.cx.tcx());
                 let ty = self.monomorphize(&ty);
                 self.cx.spanned_layout_of(ty, span).is_zst()
             }

src/librustc_metadata/rmeta/decoder.rs

@@ -1101,8 +1101,8 @@ impl<'a, 'tcx> CrateMetadata {
                 bug!("get_promoted_mir: missing MIR for `{:?}`", self.local_def_id(id))
             })
             .decode((self, tcx));
-        for body_cache in cache.iter_mut() {
-            body_cache.ensure_predecessors();
+        for body in cache.iter_mut() {
+            body.ensure_predecessors();
         }
         cache
     }