Remove region from borrow place contexts

diff --git a/src/librustc/mir/visit.rs b/src/librustc/mir/visit.rs
index 73dd24059a500300b150a10fd85f060038c69d45..5faacde7a8b7d9c53348c4102661f39416fd43ed 100644 (file)
--- a/src/librustc/mir/visit.rs
+++ b/src/librustc/mir/visit.rs
@@ -1,6 +1,6 @@
 use crate::hir::def_id::DefId;
 use crate::ty::subst::SubstsRef;
-use crate::ty::{CanonicalUserTypeAnnotation, ClosureSubsts, GeneratorSubsts, Region, Ty};
+use crate::ty::{CanonicalUserTypeAnnotation, ClosureSubsts, GeneratorSubsts, Ty};
 use crate::mir::*;
 use syntax_pos::Span;
 
@@ -147,14 +147,14 @@ fn visit_retag(&mut self,
 
             fn visit_place(&mut self,
                             place: & $($mutability)? Place<'tcx>,
-                            context: PlaceContext<'tcx>,
+                            context: PlaceContext,
                             location: Location) {
                 self.super_place(place, context, location);
             }
 
             fn visit_projection(&mut self,
                                 place: & $($mutability)? PlaceProjection<'tcx>,
-                                context: PlaceContext<'tcx>,
+                                context: PlaceContext,
                                 location: Location) {
                 self.super_projection(place, context, location);
             }
@@ -252,7 +252,7 @@ fn visit_local_decl(&mut self,
 
             fn visit_local(&mut self,
                             _local: & $($mutability)? Local,
-                            _context: PlaceContext<'tcx>,
+                            _context: PlaceContext,
                             _location: Location) {
             }
 
@@ -576,16 +576,16 @@ fn super_rvalue(&mut self,
                         self.visit_region(r, location);
                         let ctx = match bk {
                             BorrowKind::Shared => PlaceContext::NonMutatingUse(
-                                NonMutatingUseContext::SharedBorrow(*r)
+                                NonMutatingUseContext::SharedBorrow
                             ),
                             BorrowKind::Shallow => PlaceContext::NonMutatingUse(
-                                NonMutatingUseContext::ShallowBorrow(*r)
+                                NonMutatingUseContext::ShallowBorrow
                             ),
                             BorrowKind::Unique => PlaceContext::NonMutatingUse(
-                                NonMutatingUseContext::UniqueBorrow(*r)
+                                NonMutatingUseContext::UniqueBorrow
                             ),
                             BorrowKind::Mut { .. } =>
-                                PlaceContext::MutatingUse(MutatingUseContext::Borrow(*r)),
+                                PlaceContext::MutatingUse(MutatingUseContext::Borrow),
                         };
                         self.visit_place(path, ctx, location);
                     }
@@ -716,7 +716,7 @@ fn super_retag(&mut self,
 
             fn super_place(&mut self,
                             place: & $($mutability)? Place<'tcx>,
-                            context: PlaceContext<'tcx>,
+                            context: PlaceContext,
                             location: Location) {
                 match place {
                     Place::Base(PlaceBase::Local(local)) => {
@@ -736,7 +736,7 @@ fn super_place(&mut self,
 
             fn super_projection(&mut self,
                                 proj: & $($mutability)? PlaceProjection<'tcx>,
-                                context: PlaceContext<'tcx>,
+                                context: PlaceContext,
                                 location: Location) {
                 let Projection { base, elem } = proj;
                 let context = if context.is_mutating_use() {
@@ -948,7 +948,7 @@ pub enum TyContext {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum NonMutatingUseContext<'tcx> {
+pub enum NonMutatingUseContext {
     /// Being inspected in some way, like loading a len.
     Inspect,
     /// Consumed as part of an operand.
@@ -956,11 +956,11 @@ pub enum NonMutatingUseContext<'tcx> {
     /// Consumed as part of an operand.
     Move,
     /// Shared borrow.
-    SharedBorrow(Region<'tcx>),
+    SharedBorrow,
     /// Shallow borrow.
-    ShallowBorrow(Region<'tcx>),
+    ShallowBorrow,
     /// Unique borrow.
-    UniqueBorrow(Region<'tcx>),
+    UniqueBorrow,
     /// Used as base for another place, e.g., `x` in `x.y`. Will not mutate the place.
     /// For example, the projection `x.y` is not marked as a mutation in these cases:
     ///
@@ -971,7 +971,7 @@ pub enum NonMutatingUseContext<'tcx> {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum MutatingUseContext<'tcx> {
+pub enum MutatingUseContext {
     /// Appears as LHS of an assignment.
     Store,
     /// Can often be treated as a `Store`, but needs to be separate because
@@ -983,7 +983,7 @@ pub enum MutatingUseContext<'tcx> {
     /// Being dropped.
     Drop,
     /// Mutable borrow.
-    Borrow(Region<'tcx>),
+    Borrow,
     /// Used as base for another place, e.g., `x` in `x.y`. Could potentially mutate the place.
     /// For example, the projection `x.y` is marked as a mutation in these cases:
     ///
@@ -1006,13 +1006,13 @@ pub enum NonUseContext {
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
-pub enum PlaceContext<'tcx> {
-    NonMutatingUse(NonMutatingUseContext<'tcx>),
-    MutatingUse(MutatingUseContext<'tcx>),
+pub enum PlaceContext {
+    NonMutatingUse(NonMutatingUseContext),
+    MutatingUse(MutatingUseContext),
     NonUse(NonUseContext),
 }
 
-impl<'tcx> PlaceContext<'tcx> {
+impl<'tcx> PlaceContext {
     /// Returns `true` if this place context represents a drop.
     pub fn is_drop(&self) -> bool {
         match *self {
@@ -1024,10 +1024,10 @@ pub fn is_drop(&self) -> bool {
     /// Returns `true` if this place context represents a borrow.
     pub fn is_borrow(&self) -> bool {
         match *self {
-            PlaceContext::NonMutatingUse(NonMutatingUseContext::SharedBorrow(..)) |
-            PlaceContext::NonMutatingUse(NonMutatingUseContext::ShallowBorrow(..)) |
-            PlaceContext::NonMutatingUse(NonMutatingUseContext::UniqueBorrow(..)) |
-            PlaceContext::MutatingUse(MutatingUseContext::Borrow(..)) => true,
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::SharedBorrow) |
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::ShallowBorrow) |
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::UniqueBorrow) |
+            PlaceContext::MutatingUse(MutatingUseContext::Borrow) => true,
             _ => false,
         }
     }

diff --git a/src/librustc_codegen_ssa/mir/analyze.rs b/src/librustc_codegen_ssa/mir/analyze.rs
index c3eac4edd0ae6a91d5be4d4209fd2d2e4fb190a6..8021d4b11d0cf7a638d204b1695cec152d64af74 100644 (file)
--- a/src/librustc_codegen_ssa/mir/analyze.rs
+++ b/src/librustc_codegen_ssa/mir/analyze.rs
@@ -151,7 +151,7 @@ fn visit_terminator_kind(&mut self,
 
     fn visit_place(&mut self,
                    place: &mir::Place<'tcx>,
-                   context: PlaceContext<'tcx>,
+                   context: PlaceContext,
                    location: Location) {
         debug!("visit_place(place={:?}, context={:?})", place, context);
         let cx = self.fx.cx;
@@ -203,7 +203,7 @@ fn visit_place(&mut self,
 
     fn visit_local(&mut self,
                    &local: &mir::Local,
-                   context: PlaceContext<'tcx>,
+                   context: PlaceContext,
                    location: Location) {
         match context {
             PlaceContext::MutatingUse(MutatingUseContext::Call) => {
@@ -233,11 +233,11 @@ fn visit_local(&mut self,
             PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect) |
             PlaceContext::MutatingUse(MutatingUseContext::Store) |
             PlaceContext::MutatingUse(MutatingUseContext::AsmOutput) |
-            PlaceContext::MutatingUse(MutatingUseContext::Borrow(..)) |
+            PlaceContext::MutatingUse(MutatingUseContext::Borrow) |
             PlaceContext::MutatingUse(MutatingUseContext::Projection) |
-            PlaceContext::NonMutatingUse(NonMutatingUseContext::SharedBorrow(..)) |
-            PlaceContext::NonMutatingUse(NonMutatingUseContext::UniqueBorrow(..)) |
-            PlaceContext::NonMutatingUse(NonMutatingUseContext::ShallowBorrow(..)) |
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::SharedBorrow) |
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::UniqueBorrow) |
+            PlaceContext::NonMutatingUse(NonMutatingUseContext::ShallowBorrow) |
             PlaceContext::NonMutatingUse(NonMutatingUseContext::Projection) => {
                 self.not_ssa(local);
             }

diff --git a/src/librustc_mir/borrow_check/borrow_set.rs b/src/librustc_mir/borrow_check/borrow_set.rs
index f7d3aef4d766cd7740b0f946b9b8a4677248cdfb..66e463a73af670aa2102732a99d06f62d590ced7 100644 (file)
--- a/src/librustc_mir/borrow_check/borrow_set.rs
+++ b/src/librustc_mir/borrow_check/borrow_set.rs
@@ -95,7 +95,7 @@ fn build(
         struct HasStorageDead(BitSet<Local>);
 
         impl<'tcx> Visitor<'tcx> for HasStorageDead {
-            fn visit_local(&mut self, local: &Local, ctx: PlaceContext<'tcx>, _: Location) {
+            fn visit_local(&mut self, local: &Local, ctx: PlaceContext, _: Location) {
                 if ctx == PlaceContext::NonUse(NonUseContext::StorageDead) {
                     self.0.insert(*local);
                 }
@@ -220,7 +220,7 @@ fn visit_assign(
     fn visit_local(
         &mut self,
         temp: &Local,
-        context: PlaceContext<'tcx>,
+        context: PlaceContext,
         location: Location,
     ) {
         if !context.is_use() {

diff --git a/src/librustc_mir/borrow_check/nll/explain_borrow/find_use.rs b/src/librustc_mir/borrow_check/nll/explain_borrow/find_use.rs
index 7d6385752c34877337051de5da7e24a96b5c2663..9a2090d05084d98ec6e73413227e82a40a8a429f 100644 (file)
--- a/src/librustc_mir/borrow_check/nll/explain_borrow/find_use.rs
+++ b/src/librustc_mir/borrow_check/nll/explain_borrow/find_use.rs
@@ -113,7 +113,7 @@ enum DefUseResult {
 }
 
 impl<'cx, 'gcx, 'tcx> Visitor<'tcx> for DefUseVisitor<'cx, 'gcx, 'tcx> {
-    fn visit_local(&mut self, &local: &Local, context: PlaceContext<'tcx>, _: Location) {
+    fn visit_local(&mut self, &local: &Local, context: PlaceContext, _: Location) {
         let local_ty = self.mir.local_decls[local].ty;
 
         let mut found_it = false;

diff --git a/src/librustc_mir/borrow_check/nll/type_check/liveness/local_use_map.rs b/src/librustc_mir/borrow_check/nll/type_check/liveness/local_use_map.rs
index 9b8940098852c1bcb1f71aac390a8e31f57eadd3..6ba41806a313f3e43a047d18f01dc64c161a43ed 100644 (file)
--- a/src/librustc_mir/borrow_check/nll/type_check/liveness/local_use_map.rs
+++ b/src/librustc_mir/borrow_check/nll/type_check/liveness/local_use_map.rs
@@ -160,7 +160,7 @@ fn insert(
 }
 
 impl Visitor<'tcx> for LocalUseMapBuild<'_> {
-    fn visit_local(&mut self, &local: &Local, context: PlaceContext<'tcx>, location: Location) {
+    fn visit_local(&mut self, &local: &Local, context: PlaceContext, location: Location) {
         if self.locals_with_use_data[local] {
             match categorize(context) {
                 Some(DefUse::Def) => self.insert_def(local, location),

diff --git a/src/librustc_mir/borrow_check/nll/type_check/mod.rs b/src/librustc_mir/borrow_check/nll/type_check/mod.rs
index 0dee64db727631a9f2421f1da85ea4e9085d4966..76f395d6d670304f102b7d1d0ef61c5f4176362c 100644 (file)
--- a/src/librustc_mir/borrow_check/nll/type_check/mod.rs
+++ b/src/librustc_mir/borrow_check/nll/type_check/mod.rs
@@ -269,7 +269,7 @@ fn visit_span(&mut self, span: &Span) {
         }
     }
 
-    fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext<'_>, location: Location) {
+    fn visit_place(&mut self, place: &Place<'tcx>, context: PlaceContext, location: Location) {
         self.sanitize_place(place, location, context);
     }
 
@@ -447,7 +447,7 @@ fn sanitize_place(
         &mut self,
         place: &Place<'tcx>,
         location: Location,
-        context: PlaceContext<'_>,
+        context: PlaceContext,
     ) -> PlaceTy<'tcx> {
         debug!("sanitize_place: {:?}", place);
         let place_ty = match place {

diff --git a/src/librustc_mir/borrow_check/used_muts.rs b/src/librustc_mir/borrow_check/used_muts.rs
index f3b33c411a63621253a54bcced5b26f0d7049b6c..f4866fad9a5fd8c720714ceb1941913f25c34023 100644 (file)
--- a/src/librustc_mir/borrow_check/used_muts.rs
+++ b/src/librustc_mir/borrow_check/used_muts.rs
@@ -102,7 +102,7 @@ fn visit_statement(
     fn visit_local(
         &mut self,
         local: &Local,
-        place_context: PlaceContext<'tcx>,
+        place_context: PlaceContext,
         location: Location,
     ) {
         if place_context.is_place_assignment() && self.temporary_used_locals.contains(local) {

diff --git a/src/librustc_mir/monomorphize/collector.rs b/src/librustc_mir/monomorphize/collector.rs
index d5c5c3eda1de1f0b9c3c7110dd66dea1d3eea2a4..ab930fd83d063b76453c55b853efd58fb74b2bad 100644 (file)
--- a/src/librustc_mir/monomorphize/collector.rs
+++ b/src/librustc_mir/monomorphize/collector.rs
@@ -658,7 +658,7 @@ fn visit_terminator_kind(&mut self,
 
     fn visit_place(&mut self,
                     place: &mir::Place<'tcx>,
-                    context: mir::visit::PlaceContext<'tcx>,
+                    context: mir::visit::PlaceContext,
                     location: Location) {
         match place {
             Place::Base(

diff --git a/src/librustc_mir/transform/check_unsafety.rs b/src/librustc_mir/transform/check_unsafety.rs
index e072fafb1df0e393f90ccbf4b50d4e26ab127c95..078b347fb3f6be0fc8949734cc5f4d25670bb8ed 100644 (file)
--- a/src/librustc_mir/transform/check_unsafety.rs
+++ b/src/librustc_mir/transform/check_unsafety.rs
@@ -199,7 +199,7 @@ fn visit_rvalue(&mut self,
 
     fn visit_place(&mut self,
                     place: &Place<'tcx>,
-                    context: PlaceContext<'tcx>,
+                    context: PlaceContext,
                     location: Location) {
         match place {
             &Place::Projection(box Projection {

diff --git a/src/librustc_mir/transform/const_prop.rs b/src/librustc_mir/transform/const_prop.rs
index 75b9a6bc4ff72dfee2922d1ea39fb8732d6d7700..419e4b70122223968f9782ca2470c682c4bb8ed5 100644 (file)
--- a/src/librustc_mir/transform/const_prop.rs
+++ b/src/librustc_mir/transform/const_prop.rs
@@ -510,7 +510,7 @@ impl<'tcx> Visitor<'tcx> for CanConstProp {
     fn visit_local(
         &mut self,
         &local: &Local,
-        context: PlaceContext<'tcx>,
+        context: PlaceContext,
         _: Location,
     ) {
         use rustc::mir::visit::PlaceContext::*;

diff --git a/src/librustc_mir/transform/copy_prop.rs b/src/librustc_mir/transform/copy_prop.rs
index 817a2f31c07361859eb358db6e87506901b4813e..dfe2e991ba97bf9e118ef5029c856d3bcea7e62a 100644 (file)
--- a/src/librustc_mir/transform/copy_prop.rs
+++ b/src/librustc_mir/transform/copy_prop.rs
@@ -134,9 +134,9 @@ fn run_pass<'a, 'tcx>(&self,
     }
 }
 
-fn eliminate_self_assignments<'tcx>(
-    mir: &mut Mir<'tcx>,
-    def_use_analysis: &DefUseAnalysis<'tcx>,
+fn eliminate_self_assignments(
+    mir: &mut Mir<'_>,
+    def_use_analysis: &DefUseAnalysis,
 ) -> bool {
     let mut changed = false;
 
@@ -177,7 +177,7 @@ enum Action<'tcx> {
 }
 
 impl<'tcx> Action<'tcx> {
-    fn local_copy(mir: &Mir<'tcx>, def_use_analysis: &DefUseAnalysis<'_>, src_place: &Place<'tcx>)
+    fn local_copy(mir: &Mir<'tcx>, def_use_analysis: &DefUseAnalysis, src_place: &Place<'tcx>)
                   -> Option<Action<'tcx>> {
         // The source must be a local.
         let src_local = if let Place::Base(PlaceBase::Local(local)) = *src_place {
@@ -233,7 +233,7 @@ fn constant(src_constant: &Constant<'tcx>) -> Option<Action<'tcx>> {
 
     fn perform(self,
                mir: &mut Mir<'tcx>,
-               def_use_analysis: &DefUseAnalysis<'tcx>,
+               def_use_analysis: &DefUseAnalysis,
                dest_local: Local,
                location: Location)
                -> bool {

diff --git a/src/librustc_mir/transform/generator.rs b/src/librustc_mir/transform/generator.rs
index ba802370183357b9654afa34040224d39e51dba0..68f33d9438d9b47d61be0e5cb4ffb3367ab47b70 100644 (file)
--- a/src/librustc_mir/transform/generator.rs
+++ b/src/librustc_mir/transform/generator.rs
@@ -80,7 +80,7 @@ struct RenameLocalVisitor {
 impl<'tcx> MutVisitor<'tcx> for RenameLocalVisitor {
     fn visit_local(&mut self,
                    local: &mut Local,
-                   _: PlaceContext<'tcx>,
+                   _: PlaceContext,
                    _: Location) {
         if *local == self.from {
             *local = self.to;
@@ -93,14 +93,14 @@ fn visit_local(&mut self,
 impl<'tcx> MutVisitor<'tcx> for DerefArgVisitor {
     fn visit_local(&mut self,
                    local: &mut Local,
-                   _: PlaceContext<'tcx>,
+                   _: PlaceContext,
                    _: Location) {
         assert_ne!(*local, self_arg());
     }
 
     fn visit_place(&mut self,
                     place: &mut Place<'tcx>,
-                    context: PlaceContext<'tcx>,
+                    context: PlaceContext,
                     location: Location) {
         if *place == Place::Base(PlaceBase::Local(self_arg())) {
             *place = Place::Projection(Box::new(Projection {
@@ -120,14 +120,14 @@ struct PinArgVisitor<'tcx> {
 impl<'tcx> MutVisitor<'tcx> for PinArgVisitor<'tcx> {
     fn visit_local(&mut self,
                    local: &mut Local,
-                   _: PlaceContext<'tcx>,
+                   _: PlaceContext,
                    _: Location) {
         assert_ne!(*local, self_arg());
     }
 
     fn visit_place(&mut self,
                     place: &mut Place<'tcx>,
-                    context: PlaceContext<'tcx>,
+                    context: PlaceContext,
                     location: Location) {
         if *place == Place::Base(PlaceBase::Local(self_arg())) {
             *place = Place::Projection(Box::new(Projection {
@@ -221,14 +221,14 @@ fn set_state(&self, state_disc: u32, source_info: SourceInfo) -> Statement<'tcx>
 impl<'a, 'tcx> MutVisitor<'tcx> for TransformVisitor<'a, 'tcx> {
     fn visit_local(&mut self,
                    local: &mut Local,
-                   _: PlaceContext<'tcx>,
+                   _: PlaceContext,
                    _: Location) {
         assert_eq!(self.remap.get(local), None);
     }
 
     fn visit_place(&mut self,
                     place: &mut Place<'tcx>,
-                    context: PlaceContext<'tcx>,
+                    context: PlaceContext,
                     location: Location) {
         if let Place::Base(PlaceBase::Local(l)) = *place {
             // Replace an Local in the remap with a generator struct access

diff --git a/src/librustc_mir/transform/inline.rs b/src/librustc_mir/transform/inline.rs
index de1d424108d0bf86f33640099471e8cae7d9e153..937079dbd376c548edfed685607468635c284b08 100644 (file)
--- a/src/librustc_mir/transform/inline.rs
+++ b/src/librustc_mir/transform/inline.rs
@@ -662,7 +662,7 @@ fn update_target(&self, tgt: BasicBlock) -> BasicBlock {
 impl<'a, 'tcx> MutVisitor<'tcx> for Integrator<'a, 'tcx> {
     fn visit_local(&mut self,
                    local: &mut Local,
-                   _ctxt: PlaceContext<'tcx>,
+                   _ctxt: PlaceContext,
                    _location: Location) {
         if *local == RETURN_PLACE {
             match self.destination {
@@ -683,7 +683,7 @@ fn visit_local(&mut self,
 
     fn visit_place(&mut self,
                     place: &mut Place<'tcx>,
-                    _ctxt: PlaceContext<'tcx>,
+                    _ctxt: PlaceContext,
                     _location: Location) {
 
         match place {

diff --git a/src/librustc_mir/transform/promote_consts.rs b/src/librustc_mir/transform/promote_consts.rs
index ddf963c7fa9b5bef357f0ab5c1bf176f3471f542..0bf96c689176bedf8ee41449e9ff582d2508ced4 100644 (file)
--- a/src/librustc_mir/transform/promote_consts.rs
+++ b/src/librustc_mir/transform/promote_consts.rs
@@ -77,7 +77,7 @@ struct TempCollector<'tcx> {
 impl<'tcx> Visitor<'tcx> for TempCollector<'tcx> {
     fn visit_local(&mut self,
                    &index: &Local,
-                   context: PlaceContext<'tcx>,
+                   context: PlaceContext,
                    location: Location) {
         debug!("visit_local: index={:?} context={:?} location={:?}", index, context, location);
         // We're only interested in temporaries and the return place
@@ -361,7 +361,7 @@ fn promote_candidate(mut self, candidate: Candidate) {
 impl<'a, 'tcx> MutVisitor<'tcx> for Promoter<'a, 'tcx> {
     fn visit_local(&mut self,
                    local: &mut Local,
-                   _: PlaceContext<'tcx>,
+                   _: PlaceContext,
                    _: Location) {
         if self.source.local_kind(*local) == LocalKind::Temp {
             *local = self.promote_temp(*local);

diff --git a/src/librustc_mir/transform/qualify_consts.rs b/src/librustc_mir/transform/qualify_consts.rs
index c30666e53806dfdcfb0d0b2df269254a24670406..083363efacdbb24095e68d03cf9c3ab975155739 100644 (file)
--- a/src/librustc_mir/transform/qualify_consts.rs
+++ b/src/librustc_mir/transform/qualify_consts.rs
@@ -929,7 +929,7 @@ fn check_const(&mut self) -> (u8, Lrc<BitSet<Local>>) {
 impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> {
     fn visit_place(&mut self,
                     place: &Place<'tcx>,
-                    context: PlaceContext<'tcx>,
+                    context: PlaceContext,
                     location: Location) {
         debug!("visit_place: place={:?} context={:?} location={:?}", place, context, location);
         self.super_place(place, context, location);
@@ -1066,7 +1066,7 @@ fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
         debug!("visit_rvalue: rvalue={:?} location={:?}", rvalue, location);
 
         // Check nested operands and places.
-        if let Rvalue::Ref(region, kind, ref place) = *rvalue {
+        if let Rvalue::Ref(_, kind, ref place) = *rvalue {
             // Special-case reborrows.
             let mut is_reborrow = false;
             if let Place::Projection(ref proj) = *place {
@@ -1081,16 +1081,16 @@ fn visit_rvalue(&mut self, rvalue: &Rvalue<'tcx>, location: Location) {
             if is_reborrow {
                 let ctx = match kind {
                     BorrowKind::Shared => PlaceContext::NonMutatingUse(
-                        NonMutatingUseContext::SharedBorrow(region),
+                        NonMutatingUseContext::SharedBorrow,
                     ),
                     BorrowKind::Shallow => PlaceContext::NonMutatingUse(
-                        NonMutatingUseContext::ShallowBorrow(region),
+                        NonMutatingUseContext::ShallowBorrow,
                     ),
                     BorrowKind::Unique => PlaceContext::NonMutatingUse(
-                        NonMutatingUseContext::UniqueBorrow(region),
+                        NonMutatingUseContext::UniqueBorrow,
                     ),
                     BorrowKind::Mut { .. } => PlaceContext::MutatingUse(
-                        MutatingUseContext::Borrow(region),
+                        MutatingUseContext::Borrow,
                     ),
                 };
                 self.super_place(place, ctx, location);

diff --git a/src/librustc_mir/transform/simplify.rs b/src/librustc_mir/transform/simplify.rs
index 14e7895af0419572fa946ba532f02af8ec16374c..ee16ec7b41cf5e0af70309a5fcf25a76b64e66e3 100644 (file)
--- a/src/librustc_mir/transform/simplify.rs
+++ b/src/librustc_mir/transform/simplify.rs
@@ -345,7 +345,7 @@ struct DeclMarker {
 }
 
 impl<'tcx> Visitor<'tcx> for DeclMarker {
-    fn visit_local(&mut self, local: &Local, ctx: PlaceContext<'tcx>, _: Location) {
+    fn visit_local(&mut self, local: &Local, ctx: PlaceContext, _: Location) {
         // Ignore storage markers altogether, they get removed along with their otherwise unused
         // decls.
         // FIXME: Extend this to all non-uses.
@@ -372,7 +372,7 @@ fn visit_basic_block_data(&mut self, block: BasicBlock, data: &mut BasicBlockDat
         });
         self.super_basic_block_data(block, data);
     }
-    fn visit_local(&mut self, l: &mut Local, _: PlaceContext<'tcx>, _: Location) {
+    fn visit_local(&mut self, l: &mut Local, _: PlaceContext, _: Location) {
         *l = self.map[*l].unwrap();
     }
 }

diff --git a/src/librustc_mir/transform/uniform_array_move_out.rs b/src/librustc_mir/transform/uniform_array_move_out.rs
index cb23abd8a0dc36ee15b2b816831b2a85a6765056..4eee0640d78cd03171ecee0cdc0e4ff3b51985b1 100644 (file)
--- a/src/librustc_mir/transform/uniform_array_move_out.rs
+++ b/src/librustc_mir/transform/uniform_array_move_out.rs
@@ -304,7 +304,7 @@ fn visit_assign(&mut self,
 
     fn visit_local(&mut self,
                    local: &Local,
-                   context: PlaceContext<'tcx>,
+                   context: PlaceContext,
                    location: Location) {
         let local_use = &mut self.locals_use[*local];
         match context {

diff --git a/src/librustc_mir/util/collect_writes.rs b/src/librustc_mir/util/collect_writes.rs
index fd94c49dd1d4ae08796789038b046aff13a49029..7bd61c3a59c94ec09bcfe1788635349c754f4109 100644 (file)
--- a/src/librustc_mir/util/collect_writes.rs
+++ b/src/librustc_mir/util/collect_writes.rs
@@ -27,7 +27,7 @@ struct FindLocalAssignmentVisitor {
 impl<'tcx> Visitor<'tcx> for FindLocalAssignmentVisitor {
     fn visit_local(&mut self,
                    local: &Local,
-                   place_context: PlaceContext<'tcx>,
+                   place_context: PlaceContext,
                    location: Location) {
         if self.needle != *local {
             return;

diff --git a/src/librustc_mir/util/def_use.rs b/src/librustc_mir/util/def_use.rs
index 2e41c6e493bc35b777d67e09931919c436a16f07..2925005b6674dc1d05c6c9593a4eff749b5d6fd3 100644 (file)
--- a/src/librustc_mir/util/def_use.rs
+++ b/src/librustc_mir/util/def_use.rs
@@ -3,34 +3,31 @@
 use rustc::mir::{Local, Location, Mir};
 use rustc::mir::visit::{PlaceContext, MutVisitor, Visitor};
 use rustc_data_structures::indexed_vec::IndexVec;
-use std::marker::PhantomData;
 use std::mem;
-use std::slice;
-use std::iter;
 
-pub struct DefUseAnalysis<'tcx> {
-    info: IndexVec<Local, Info<'tcx>>,
+pub struct DefUseAnalysis {
+    info: IndexVec<Local, Info>,
 }
 
 #[derive(Clone)]
-pub struct Info<'tcx> {
-    pub defs_and_uses: Vec<Use<'tcx>>,
+pub struct Info {
+    pub defs_and_uses: Vec<Use>,
 }
 
 #[derive(Clone)]
-pub struct Use<'tcx> {
-    pub context: PlaceContext<'tcx>,
+pub struct Use {
+    pub context: PlaceContext,
     pub location: Location,
 }
 
-impl<'tcx> DefUseAnalysis<'tcx> {
-    pub fn new(mir: &Mir<'tcx>) -> DefUseAnalysis<'tcx> {
+impl DefUseAnalysis {
+    pub fn new(mir: &Mir<'_>) -> DefUseAnalysis {
         DefUseAnalysis {
             info: IndexVec::from_elem_n(Info::new(), mir.local_decls.len()),
         }
     }
 
-    pub fn analyze(&mut self, mir: &Mir<'tcx>) {
+    pub fn analyze(&mut self, mir: &Mir<'_>) {
         self.clear();
 
         let mut finder = DefUseFinder {
@@ -46,13 +43,13 @@ fn clear(&mut self) {
         }
     }
 
-    pub fn local_info(&self, local: Local) -> &Info<'tcx> {
+    pub fn local_info(&self, local: Local) -> &Info {
         &self.info[local]
     }
 
-    fn mutate_defs_and_uses<F>(&self, local: Local, mir: &mut Mir<'tcx>, mut callback: F)
+    fn mutate_defs_and_uses<F>(&self, local: Local, mir: &mut Mir<'_>, mut callback: F)
                                where F: for<'a> FnMut(&'a mut Local,
-                                                      PlaceContext<'tcx>,
+                                                      PlaceContext,
                                                       Location) {
         for place_use in &self.info[local].defs_and_uses {
             MutateUseVisitor::new(local,
@@ -64,20 +61,20 @@ fn mutate_defs_and_uses<F>(&self, local: Local, mir: &mut Mir<'tcx>, mut callbac
     // FIXME(pcwalton): this should update the def-use chains.
     pub fn replace_all_defs_and_uses_with(&self,
                                           local: Local,
-                                          mir: &mut Mir<'tcx>,
+                                          mir: &mut Mir<'_>,
                                           new_local: Local) {
         self.mutate_defs_and_uses(local, mir, |local, _, _| *local = new_local)
     }
 }
 
-struct DefUseFinder<'tcx> {
-    info: IndexVec<Local, Info<'tcx>>,
+struct DefUseFinder {
+    info: IndexVec<Local, Info>,
 }
 
-impl<'tcx> Visitor<'tcx> for DefUseFinder<'tcx> {
+impl Visitor<'_> for DefUseFinder {
     fn visit_local(&mut self,
                    &local: &Local,
-                   context: PlaceContext<'tcx>,
+                   context: PlaceContext,
                    location: Location) {
         self.info[local].defs_and_uses.push(Use {
             context,
@@ -86,8 +83,8 @@ fn visit_local(&mut self,
     }
 }
 
-impl<'tcx> Info<'tcx> {
-    fn new() -> Info<'tcx> {
+impl Info {
+    fn new() -> Info {
         Info {
             defs_and_uses: vec![],
         }
@@ -107,7 +104,7 @@ pub fn def_count_not_including_drop(&self) -> usize {
 
     pub fn defs_not_including_drop(
         &self,
-    ) -> iter::Filter<slice::Iter<'_, Use<'tcx>>, fn(&&Use<'tcx>) -> bool> {
+    ) -> impl Iterator<Item=&Use> {
         self.defs_and_uses.iter().filter(|place_use| {
             place_use.context.is_mutating_use() && !place_use.context.is_drop()
         })
@@ -120,29 +117,27 @@ pub fn use_count(&self) -> usize {
     }
 }
 
-struct MutateUseVisitor<'tcx, F> {
+struct MutateUseVisitor<F> {
     query: Local,
     callback: F,
-    phantom: PhantomData<&'tcx ()>,
 }
 
-impl<'tcx, F> MutateUseVisitor<'tcx, F> {
-    fn new(query: Local, callback: F, _: &Mir<'tcx>)
-           -> MutateUseVisitor<'tcx, F>
-           where F: for<'a> FnMut(&'a mut Local, PlaceContext<'tcx>, Location) {
+impl<F> MutateUseVisitor<F> {
+    fn new(query: Local, callback: F, _: &Mir<'_>)
+           -> MutateUseVisitor<F>
+           where F: for<'a> FnMut(&'a mut Local, PlaceContext, Location) {
         MutateUseVisitor {
             query,
             callback,
-            phantom: PhantomData,
         }
     }
 }
 
-impl<'tcx, F> MutVisitor<'tcx> for MutateUseVisitor<'tcx, F>
-              where F: for<'a> FnMut(&'a mut Local, PlaceContext<'tcx>, Location) {
+impl<F> MutVisitor<'_> for MutateUseVisitor<F>
+              where F: for<'a> FnMut(&'a mut Local, PlaceContext, Location) {
     fn visit_local(&mut self,
                     local: &mut Local,
-                    context: PlaceContext<'tcx>,
+                    context: PlaceContext,
                     location: Location) {
         if *local == self.query {
             (self.callback)(local, context, location)

diff --git a/src/librustc_mir/util/liveness.rs b/src/librustc_mir/util/liveness.rs
index 29f281fb8d430fd353eaa40f63d180751cf6e30f..4302076f1c32a8726728c551f9301f790028e152 100644 (file)
--- a/src/librustc_mir/util/liveness.rs
+++ b/src/librustc_mir/util/liveness.rs
@@ -110,7 +110,7 @@ pub enum DefUse {
     Drop,
 }
 
-pub fn categorize<'tcx>(context: PlaceContext<'tcx>) -> Option<DefUse> {
+pub fn categorize<'tcx>(context: PlaceContext) -> Option<DefUse> {
     match context {
         ///////////////////////////////////////////////////////////////////////////
         // DEFS
@@ -147,10 +147,10 @@ pub fn categorize<'tcx>(context: PlaceContext<'tcx>) -> Option<DefUse> {
         // This won't affect the results since we use this analysis for generators
         // and we only care about the result at suspension points. Borrows cannot
         // cross suspension points so this behavior is unproblematic.
-        PlaceContext::MutatingUse(MutatingUseContext::Borrow(..)) |
-        PlaceContext::NonMutatingUse(NonMutatingUseContext::SharedBorrow(..)) |
-        PlaceContext::NonMutatingUse(NonMutatingUseContext::ShallowBorrow(..)) |
-        PlaceContext::NonMutatingUse(NonMutatingUseContext::UniqueBorrow(..)) |
+        PlaceContext::MutatingUse(MutatingUseContext::Borrow) |
+        PlaceContext::NonMutatingUse(NonMutatingUseContext::SharedBorrow) |
+        PlaceContext::NonMutatingUse(NonMutatingUseContext::ShallowBorrow) |
+        PlaceContext::NonMutatingUse(NonMutatingUseContext::UniqueBorrow) |
 
         PlaceContext::NonMutatingUse(NonMutatingUseContext::Inspect) |
         PlaceContext::NonMutatingUse(NonMutatingUseContext::Copy) |
@@ -220,7 +220,7 @@ fn add_use(&mut self, index: Local) {
 
 impl<'tcx> Visitor<'tcx> for DefsUsesVisitor
 {
-    fn visit_local(&mut self, &local: &Local, context: PlaceContext<'tcx>, _: Location) {
+    fn visit_local(&mut self, &local: &Local, context: PlaceContext, _: Location) {
         match categorize(context) {
             Some(DefUse::Def) => self.defs_uses.add_def(local),
             Some(DefUse::Use) | Some(DefUse::Drop) => self.defs_uses.add_use(local),