Make causal tracking lazy

src/librustc/mir/mod.rs

@@ -1000,6 +1000,10 @@ impl<'tcx> Terminator<'tcx> {
         self.kind.successors_mut()
     }
 
+    pub fn unwind(&self) -> Option<&Option<BasicBlock>> {
+        self.kind.unwind()
+    }
+
     pub fn unwind_mut(&mut self) -> Option<&mut Option<BasicBlock>> {
         self.kind.unwind_mut()
     }
@@ -1195,6 +1199,31 @@ impl<'tcx> TerminatorKind<'tcx> {
         }
     }
 
+    pub fn unwind(&self) -> Option<&Option<BasicBlock>> {
+        match *self {
+            TerminatorKind::Goto { .. }
+            | TerminatorKind::Resume
+            | TerminatorKind::Abort
+            | TerminatorKind::Return
+            | TerminatorKind::Unreachable
+            | TerminatorKind::GeneratorDrop
+            | TerminatorKind::Yield { .. }
+            | TerminatorKind::SwitchInt { .. }
+            | TerminatorKind::FalseEdges { .. } => None,
+            TerminatorKind::Call {
+                cleanup: ref unwind,
+                ..
+            }
+            | TerminatorKind::Assert {
+                cleanup: ref unwind,
+                ..
+            }
+            | TerminatorKind::DropAndReplace { ref unwind, .. }
+            | TerminatorKind::Drop { ref unwind, .. }
+            | TerminatorKind::FalseUnwind { ref unwind, .. } => Some(unwind),
+        }
+    }
+
     pub fn unwind_mut(&mut self) -> Option<&mut Option<BasicBlock>> {
         match *self {
             TerminatorKind::Goto { .. }

src/librustc_mir/borrow_check/nll/constraint_generation.rs

@@ -12,7 +12,7 @@ use borrow_check::borrow_set::BorrowSet;
 use borrow_check::location::LocationTable;
 use borrow_check::nll::ToRegionVid;
 use borrow_check::nll::facts::AllFacts;
-use borrow_check::nll::region_infer::{Cause, RegionInferenceContext};
+use borrow_check::nll::region_infer::RegionInferenceContext;
 use borrow_check::nll::type_check::AtLocation;
 use rustc::hir;
 use rustc::infer::InferCtxt;
@@ -33,7 +33,7 @@ pub(super) fn generate_constraints<'cx, 'gcx, 'tcx>(
     location_table: &LocationTable,
     mir: &Mir<'tcx>,
     borrow_set: &BorrowSet<'tcx>,
-    liveness_set_from_typeck: &[(ty::Region<'tcx>, Location, Cause)],
+    liveness_set_from_typeck: &[(ty::Region<'tcx>, Location)],
 ) {
     let mut cg = ConstraintGeneration {
         borrow_set,
@@ -69,14 +69,14 @@ impl<'cg, 'cx, 'gcx, 'tcx> Visitor<'tcx> for ConstraintGeneration<'cg, 'cx, 'gcx
     /// We sometimes have `substs` within an rvalue, or within a
     /// call. Make them live at the location where they appear.
     fn visit_substs(&mut self, substs: &&'tcx Substs<'tcx>, location: Location) {
-        self.add_regular_live_constraint(*substs, location, Cause::LiveOther(location));
+        self.add_regular_live_constraint(*substs, location);
         self.super_substs(substs);
     }
 
     /// We sometimes have `region` within an rvalue, or within a
     /// call. Make them live at the location where they appear.
     fn visit_region(&mut self, region: &ty::Region<'tcx>, location: Location) {
-        self.add_regular_live_constraint(*region, location, Cause::LiveOther(location));
+        self.add_regular_live_constraint(*region, location);
         self.super_region(region);
     }
 
@@ -94,7 +94,7 @@ impl<'cg, 'cx, 'gcx, 'tcx> Visitor<'tcx> for ConstraintGeneration<'cg, 'cx, 'gcx
                 );
             }
             TyContext::Location(location) => {
-                self.add_regular_live_constraint(*ty, location, Cause::LiveOther(location));
+                self.add_regular_live_constraint(*ty, location);
             }
         }
 
@@ -104,14 +104,14 @@ impl<'cg, 'cx, 'gcx, 'tcx> Visitor<'tcx> for ConstraintGeneration<'cg, 'cx, 'gcx
     /// We sometimes have `generator_substs` within an rvalue, or within a
     /// call. Make them live at the location where they appear.
     fn visit_generator_substs(&mut self, substs: &GeneratorSubsts<'tcx>, location: Location) {
-        self.add_regular_live_constraint(*substs, location, Cause::LiveOther(location));
+        self.add_regular_live_constraint(*substs, location);
         self.super_generator_substs(substs);
     }
 
     /// We sometimes have `closure_substs` within an rvalue, or within a
     /// call. Make them live at the location where they appear.
     fn visit_closure_substs(&mut self, substs: &ClosureSubsts<'tcx>, location: Location) {
-        self.add_regular_live_constraint(*substs, location, Cause::LiveOther(location));
+        self.add_regular_live_constraint(*substs, location);
         self.super_closure_substs(substs);
     }
 
@@ -233,7 +233,7 @@ impl<'cx, 'cg, 'gcx, 'tcx> ConstraintGeneration<'cx, 'cg, 'gcx, 'tcx> {
     /// that we also have to respect.
     fn add_region_liveness_constraints_from_type_check(
         &mut self,
-        liveness_set: &[(ty::Region<'tcx>, Location, Cause)],
+        liveness_set: &[(ty::Region<'tcx>, Location)],
     ) {
         debug!(
             "add_region_liveness_constraints_from_type_check(liveness_set={} items)",
@@ -247,16 +247,16 @@ impl<'cx, 'cg, 'gcx, 'tcx> ConstraintGeneration<'cx, 'cg, 'gcx, 'tcx> {
             ..
         } = self;
 
-        for (region, location, cause) in liveness_set {
+        for (region, location) in liveness_set {
             debug!("generate: {:#?} is live at {:#?}", region, location);
             let region_vid = regioncx.to_region_vid(region);
-            regioncx.add_live_point(region_vid, *location, &cause);
+            regioncx.add_live_point(region_vid, *location);
         }
 
         if let Some(all_facts) = all_facts {
             all_facts
                 .region_live_at
-                .extend(liveness_set.into_iter().flat_map(|(region, location, _)| {
+                .extend(liveness_set.into_iter().flat_map(|(region, location)| {
                     let r = regioncx.to_region_vid(region);
                     let p1 = location_table.start_index(*location);
                     let p2 = location_table.mid_index(*location);
@@ -269,7 +269,7 @@ impl<'cx, 'cg, 'gcx, 'tcx> ConstraintGeneration<'cx, 'cg, 'gcx, 'tcx> {
     /// `location` -- i.e., it may be used later. This means that all
     /// regions appearing in the type `live_ty` must be live at
     /// `location`.
-    fn add_regular_live_constraint<T>(&mut self, live_ty: T, location: Location, cause: Cause)
+    fn add_regular_live_constraint<T>(&mut self, live_ty: T, location: Location)
     where
         T: TypeFoldable<'tcx>,
     {
@@ -282,7 +282,7 @@ impl<'cx, 'cg, 'gcx, 'tcx> ConstraintGeneration<'cx, 'cg, 'gcx, 'tcx> {
             .tcx
             .for_each_free_region(&live_ty, |live_region| {
                 let vid = live_region.to_region_vid();
-                self.regioncx.add_live_point(vid, location, &cause);
+                self.regioncx.add_live_point(vid, location);
             });
     }
 

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

@@ -0,0 +1,168 @@
+// Copyright 2017 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use std::collections::VecDeque;
+use std::rc::Rc;
+
+use borrow_check::nll::region_infer::{Cause, RegionInferenceContext};
+use borrow_check::nll::ToRegionVid;
+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};
+
+crate fn find<'cx, 'gcx: 'tcx, 'tcx: 'cx>(
+    mir: &'cx Mir<'tcx>,
+    regioncx: &'cx Rc<RegionInferenceContext<'tcx>>,
+    tcx: TyCtxt<'cx, 'gcx, 'tcx>,
+    region_vid: RegionVid,
+    start_point: Location,
+) -> Option<Cause> {
+    let mut uf = UseFinder {
+        mir,
+        regioncx,
+        tcx,
+        region_vid,
+        start_point,
+        liveness_mode: LivenessMode {
+            include_regular_use: true,
+            include_drops: true,
+        },
+    };
+
+    uf.find()
+}
+
+struct UseFinder<'cx, 'gcx: 'tcx, 'tcx: 'cx> {
+    mir: &'cx Mir<'tcx>,
+    regioncx: &'cx Rc<RegionInferenceContext<'tcx>>,
+    tcx: TyCtxt<'cx, 'gcx, 'tcx>,
+    region_vid: RegionVid,
+    start_point: Location,
+    liveness_mode: LivenessMode,
+}
+
+impl<'cx, 'gcx, 'tcx> UseFinder<'cx, 'gcx, 'tcx> {
+    fn find(&mut self) -> Option<Cause> {
+        let mut queue = VecDeque::new();
+        let mut visited = FxHashSet();
+
+        queue.push_back(self.start_point);
+        while let Some(p) = queue.pop_front() {
+            if !self.regioncx.region_contains_point(self.region_vid, p) {
+                continue;
+            }
+
+            if !visited.insert(p) {
+                continue;
+            }
+
+            let block_data = &self.mir[p.block];
+
+            match self.def_use(p, block_data.visitable(p.statement_index)) {
+                Some(DefUseResult::Def) => {}
+
+                Some(DefUseResult::UseLive { local }) => {
+                    return Some(Cause::LiveVar(local, p));
+                }
+
+                Some(DefUseResult::UseDrop { local }) => {
+                    return Some(Cause::DropVar(local, p));
+                }
+
+                None => {
+                    if p.statement_index < block_data.statements.len() {
+                        queue.push_back(Location {
+                            statement_index: p.statement_index + 1,
+                            ..p
+                        });
+                    } else {
+                        queue.extend(
+                            block_data
+                                .terminator()
+                                .successors()
+                                .filter(|&bb| Some(&Some(*bb)) != block_data.terminator().unwind())
+                                .map(|&bb| Location {
+                                    statement_index: 0,
+                                    block: bb,
+                                }),
+                        );
+                    }
+                }
+            }
+        }
+
+        None
+    }
+
+    fn def_use(&self, location: Location, thing: &dyn MirVisitable<'tcx>) -> Option<DefUseResult> {
+        let mut visitor = DefUseVisitor {
+            mir: self.mir,
+            tcx: self.tcx,
+            region_vid: self.region_vid,
+            liveness_mode: self.liveness_mode,
+            def_use_result: None,
+        };
+
+        thing.apply(location, &mut visitor);
+
+        visitor.def_use_result
+    }
+}
+
+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>,
+}
+
+enum DefUseResult {
+    Def,
+
+    UseLive { local: Local },
+
+    UseDrop { local: Local },
+}
+
+impl<'cx, 'gcx, 'tcx> Visitor<'tcx> for DefUseVisitor<'cx, 'gcx, 'tcx> {
+    fn visit_local(&mut self, &local: &Local, context: PlaceContext<'tcx>, _: Location) {
+        let local_ty = self.mir.local_decls[local].ty;
+
+        let mut found_it = false;
+        self.tcx.for_each_free_region(&local_ty, |r| {
+            if r.to_region_vid() == self.region_vid {
+                found_it = true;
+            }
+        });
+
+        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;
+                }
+            }
+        }
+    }
+}