remove the liveness mode and simplify categorize

Less modes!

Author: nikomatsakis

src/librustc_mir/borrow_check/nll/explain_borrow/find_use.rs

@@ -17,7 +17,7 @@ use rustc::mir::visit::{MirVisitable, PlaceContext, Visitor};
 use rustc::mir::{Local, Location, Mir};
 use rustc::ty::{RegionVid, TyCtxt};
 use rustc_data_structures::fx::FxHashSet;
-use util::liveness::{self, DefUse, LivenessMode};
+use util::liveness::{self, DefUse};
 
 crate fn find<'tcx>(
     mir: &Mir<'tcx>,
@@ -32,10 +32,6 @@ crate fn find<'tcx>(
         tcx,
         region_vid,
         start_point,
-        liveness_mode: LivenessMode {
-            include_regular_use: true,
-            include_drops: true,
-        },
     };
 
     uf.find()
@@ -47,7 +43,6 @@ struct UseFinder<'cx, 'gcx: 'tcx, 'tcx: 'cx> {
     tcx: TyCtxt<'cx, 'gcx, 'tcx>,
     region_vid: RegionVid,
     start_point: Location,
-    liveness_mode: LivenessMode,
 }
 
 impl<'cx, 'gcx, 'tcx> UseFinder<'cx, 'gcx, 'tcx> {
@@ -108,7 +103,6 @@ impl<'cx, 'gcx, 'tcx> UseFinder<'cx, 'gcx, 'tcx> {
             mir: self.mir,
             tcx: self.tcx,
             region_vid: self.region_vid,
-            liveness_mode: self.liveness_mode,
             def_use_result: None,
         };
 
@@ -122,7 +116,6 @@ struct DefUseVisitor<'cx, 'gcx: 'tcx, 'tcx: 'cx> {
     mir: &'cx Mir<'tcx>,
     tcx: TyCtxt<'cx, 'gcx, 'tcx>,
     region_vid: RegionVid,
-    liveness_mode: LivenessMode,
     def_use_result: Option<DefUseResult>,
 }
 
@@ -146,23 +139,12 @@ impl<'cx, 'gcx, 'tcx> Visitor<'tcx> for DefUseVisitor<'cx, 'gcx, 'tcx> {
         });
 
         if found_it {
-            match liveness::categorize(context, self.liveness_mode) {
-                Some(DefUse::Def) => {
-                    self.def_use_result = Some(DefUseResult::Def);
-                }
-
-                Some(DefUse::Use) => {
-                    self.def_use_result = if context.is_drop() {
-                        Some(DefUseResult::UseDrop { local })
-                    } else {
-                        Some(DefUseResult::UseLive { local })
-                    };
-                }
-
-                None => {
-                    self.def_use_result = None;
-                }
-            }
+            self.def_use_result = match liveness::categorize(context) {
+                Some(DefUse::Def) => Some(DefUseResult::Def),
+                Some(DefUse::Use) => Some(DefUseResult::UseLive { local }),
+                Some(DefUse::Drop) => Some(DefUseResult::UseDrop { local }),
+                None => None,
+            };
         }
     }
 }

src/librustc_mir/util/liveness.rs

@@ -279,9 +279,10 @@ impl<V: Idx> LivenessResult<V> {
 pub enum DefUse {
     Def,
     Use,
+    Drop,
 }
 
-pub fn categorize<'tcx>(context: PlaceContext<'tcx>, mode: LivenessMode) -> Option<DefUse> {
+pub fn categorize<'tcx>(context: PlaceContext<'tcx>) -> Option<DefUse> {
     match context {
         ///////////////////////////////////////////////////////////////////////////
         // DEFS
@@ -322,13 +323,8 @@ pub fn categorize<'tcx>(context: PlaceContext<'tcx>, mode: LivenessMode) -> Opti
         PlaceContext::Inspect |
         PlaceContext::Copy |
         PlaceContext::Move |
-        PlaceContext::Validate => {
-            if mode.include_regular_use {
-                Some(DefUse::Use)
-            } else {
-                None
-            }
-        }
+        PlaceContext::Validate =>
+            Some(DefUse::Use),
 
         ///////////////////////////////////////////////////////////////////////////
         // DROP USES
@@ -338,13 +334,8 @@ pub fn categorize<'tcx>(context: PlaceContext<'tcx>, mode: LivenessMode) -> Opti
         // uses in drop are special because `#[may_dangle]`
         // attributes can affect whether lifetimes must be live.
 
-        PlaceContext::Drop => {
-            if mode.include_drops {
-                Some(DefUse::Use)
-            } else {
-                None
-            }
-        }
+        PlaceContext::Drop =>
+            Some(DefUse::Drop),
     }
 }
 
@@ -434,10 +425,11 @@ where
 {
     fn visit_local(&mut self, &local: &Local, context: PlaceContext<'tcx>, _: Location) {
         if let Some(v_index) = self.map.from_local(local) {
-            match categorize(context, self.mode) {
+            match categorize(context) {
                 Some(DefUse::Def) => self.defs_uses.add_def(v_index),
-                Some(DefUse::Use) => self.defs_uses.add_use(v_index),
-                None => (),
+                Some(DefUse::Use) if self.mode.include_regular_use => self.defs_uses.add_use(v_index),
+                Some(DefUse::Drop) if self.mode.include_drops => self.defs_uses.add_use(v_index),
+                _ => (),
             }
         }
     }