compute region values using SCCs not iterative flow

The strategy is this:

- we compute SCCs once all outlives constraints are known
- we allocate a set of values **per region** for storing liveness
- we allocate a set of values **per SCC** for storing the final values
- when we add a liveness constraint to the region R, we also add it
  to the final value of the SCC to which R belongs
- then we can apply the constraints by just walking the DAG for the
  SCCs and union'ing the children (which have their liveness
  constraints within)

There are a few intermediate refactorings that I really ought to have
broken out into their own commits:

- reverse the constraint graph so that `R1: R2` means `R1 -> R2` and
  not `R2 -> R1`. This fits better with the SCC computation and new
  style of inference (`->` now means "take value from" and not "push
  value into")
  - this does affect some of the UI tests, since they traverse the
    graph, but mostly the artificial ones and they don't necessarily
    seem worse
- put some things (constraint set, etc) into `Rc`. This lets us root
  them to permit mutation and iteration. It also guarantees they don't
  change, which is critical to the correctness of the algorithm.
- Generalize various helpers that previously operated only on points
  to work on any sort of region element.

Author: nikomatsakis

src/librustc_data_structures/graph/scc/mod.rs

@@ -54,6 +54,11 @@ impl<N: Idx, S: Idx> Sccs<N, S> {
         self.scc_data.len()
     }
 
+    /// Returns the number of SCCs in the graph.
+    pub fn all_sccs(&self) -> impl Iterator<Item = S> {
+        (0 .. self.scc_data.len()).map(S::new)
+    }
+
     /// Returns the SCC to which a node `r` belongs.
     pub fn scc(&self, r: N) -> S {
         self.scc_indices[r]

src/librustc_mir/borrow_check/nll/constraint_generation.rs

@@ -210,7 +210,7 @@ impl<'cx, 'cg, 'gcx, 'tcx> ConstraintGeneration<'cx, 'cg, 'gcx, 'tcx> {
         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);
+            regioncx.add_live_element(region_vid, *location);
         }
 
         if let Some(all_facts) = all_facts {
@@ -242,7 +242,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);
+                self.regioncx.add_live_element(vid, location);
             });
     }
 }

src/librustc_mir/borrow_check/nll/constraints/graph.rs

@@ -0,0 +1,134 @@
+// 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 borrow_check::nll::constraints::{ConstraintIndex, ConstraintSet};
+use rustc::ty::RegionVid;
+use rustc_data_structures::graph;
+use rustc_data_structures::indexed_vec::IndexVec;
+
+crate struct ConstraintGraph {
+    first_constraints: IndexVec<RegionVid, Option<ConstraintIndex>>,
+    next_constraints: IndexVec<ConstraintIndex, Option<ConstraintIndex>>,
+}
+
+impl ConstraintGraph {
+    /// Create a "dependency graph" where each region constraint `R1:
+    /// R2` is treated as an edge `R1 -> R2`. We use this graph to
+    /// construct SCCs for region inference but also for error
+    /// reporting.
+    crate fn new(set: &ConstraintSet, num_region_vars: usize) -> Self {
+        let mut first_constraints = IndexVec::from_elem_n(None, num_region_vars);
+        let mut next_constraints = IndexVec::from_elem(None, &set.constraints);
+
+        for (idx, constraint) in set.constraints.iter_enumerated().rev() {
+            let mut head = &mut first_constraints[constraint.sup];
+            let mut next = &mut next_constraints[idx];
+            debug_assert!(next.is_none());
+            *next = *head;
+            *head = Some(idx);
+        }
+
+        Self {
+            first_constraints,
+            next_constraints,
+        }
+    }
+
+    /// Given a region `R`, iterate over all constraints `R: R1`.
+    crate fn outgoing_edges(&self, region_sup: RegionVid) -> Edges<'_> {
+        let first = self.first_constraints[region_sup];
+        Edges {
+            graph: self,
+            pointer: first,
+        }
+    }
+}
+
+crate struct Edges<'s> {
+    graph: &'s ConstraintGraph,
+    pointer: Option<ConstraintIndex>,
+}
+
+impl<'s> Iterator for Edges<'s> {
+    type Item = ConstraintIndex;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(p) = self.pointer {
+            self.pointer = self.graph.next_constraints[p];
+            Some(p)
+        } else {
+            None
+        }
+    }
+}
+
+crate struct RegionGraph<'s> {
+    set: &'s ConstraintSet,
+    constraint_graph: &'s ConstraintGraph,
+}
+
+impl<'s> RegionGraph<'s> {
+    /// Create a "dependency graph" where each region constraint `R1:
+    /// R2` is treated as an edge `R1 -> R2`. We use this graph to
+    /// construct SCCs for region inference but also for error
+    /// reporting.
+    crate fn new(set: &'s ConstraintSet, constraint_graph: &'s ConstraintGraph) -> Self {
+        Self {
+            set,
+            constraint_graph,
+        }
+    }
+
+    /// Given a region `R`, iterate over all regions `R1` such that
+    /// there exists a constraint `R: R1`.
+    crate fn sub_regions(&self, region_sup: RegionVid) -> Successors<'_> {
+        Successors {
+            set: self.set,
+            edges: self.constraint_graph.outgoing_edges(region_sup),
+        }
+    }
+}
+
+crate struct Successors<'s> {
+    set: &'s ConstraintSet,
+    edges: Edges<'s>,
+}
+
+impl<'s> Iterator for Successors<'s> {
+    type Item = RegionVid;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.edges.next().map(|c| self.set[c].sub)
+    }
+}
+
+impl<'s> graph::DirectedGraph for RegionGraph<'s> {
+    type Node = RegionVid;
+}
+
+impl<'s> graph::WithNumNodes for RegionGraph<'s> {
+    fn num_nodes(&self) -> usize {
+        self.constraint_graph.first_constraints.len()
+    }
+}
+
+impl<'s> graph::WithSuccessors for RegionGraph<'s> {
+    fn successors<'graph>(
+        &'graph self,
+        node: Self::Node,
+    ) -> <Self as graph::GraphSuccessors<'graph>>::Iter {
+        self.sub_regions(node)
+    }
+}
+
+impl<'s, 'graph> graph::GraphSuccessors<'graph> for RegionGraph<'s> {
+    type Item = RegionVid;
+    type Iter = Successors<'graph>;
+}

src/librustc_mir/borrow_check/nll/constraints/mod.rs

@@ -9,19 +9,22 @@
 // except according to those terms.
 
 use rustc::ty::RegionVid;
+use rustc_data_structures::graph::scc::Sccs;
 use rustc_data_structures::indexed_vec::{Idx, IndexVec};
 use borrow_check::nll::type_check::Locations;
 
 use std::fmt;
 use std::ops::Deref;
 
+crate mod graph;
+
 #[derive(Clone, Default)]
 crate struct ConstraintSet {
     constraints: IndexVec<ConstraintIndex, OutlivesConstraint>,
 }
 
 impl ConstraintSet {
-    pub fn push(&mut self, constraint: OutlivesConstraint) {
+    crate fn push(&mut self, constraint: OutlivesConstraint) {
         debug!(
             "ConstraintSet::push({:?}: {:?} @ {:?}",
             constraint.sup, constraint.sub, constraint.locations
@@ -32,12 +35,33 @@ impl ConstraintSet {
         }
         self.constraints.push(constraint);
     }
+
+    /// Constructs a graph from the constraint set; the graph makes it
+    /// easy to find the constriants affecting a particular region
+    /// (you should not mutate the set once this graph is
+    /// constructed).
+    crate fn graph(&self, num_region_vars: usize) -> graph::ConstraintGraph {
+        graph::ConstraintGraph::new(self, num_region_vars)
+    }
+
+    /// Compute cycles (SCCs) in the graph of regions. In particular,
+    /// find all regions R1, R2 such that R1: R2 and R2: R1 and group
+    /// them into an SCC, and find the relationships between SCCs.
+    crate fn compute_sccs(
+        &self,
+        constraint_graph: &graph::ConstraintGraph,
+    ) -> Sccs<RegionVid, ConstraintSccIndex> {
+        let region_graph = &graph::RegionGraph::new(self, constraint_graph);
+        Sccs::new(region_graph)
+    }
 }
 
 impl Deref for ConstraintSet {
     type Target = IndexVec<ConstraintIndex, OutlivesConstraint>;
 
-    fn deref(&self) -> &Self::Target { &self.constraints }
+    fn deref(&self) -> &Self::Target {
+        &self.constraints
+    }
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -68,45 +92,4 @@ impl fmt::Debug for OutlivesConstraint {
 
 newtype_index!(ConstraintIndex { DEBUG_FORMAT = "ConstraintIndex({})" });
 
-crate struct ConstraintGraph {
-    first_constraints: IndexVec<RegionVid, Option<ConstraintIndex>>,
-    next_constraints: IndexVec<ConstraintIndex, Option<ConstraintIndex>>,
-}
-
-impl ConstraintGraph {
-    /// Constraint a graph where each region constraint `R1: R2` is
-    /// treated as an edge `R2 -> R1`. This is useful for cheaply
-    /// finding dirty constraints.
-    crate fn new(set: &ConstraintSet, num_region_vars: usize) -> Self {
-        let mut first_constraints = IndexVec::from_elem_n(None, num_region_vars);
-        let mut next_constraints = IndexVec::from_elem(None, &set.constraints);
-
-        for (idx, constraint) in set.constraints.iter_enumerated().rev() {
-            let mut head = &mut first_constraints[constraint.sub];
-            let mut next = &mut next_constraints[idx];
-            debug_assert!(next.is_none());
-            *next = *head;
-            *head = Some(idx);
-        }
-
-        ConstraintGraph { first_constraints, next_constraints }
-    }
-
-    /// Invokes `op` with the index of any constraints of the form
-    /// `region_sup: region_sub`.  These are the constraints that must
-    /// be reprocessed when the value of `R1` changes. If you think of
-    /// each constraint `R1: R2` as an edge `R2 -> R1`, then this
-    /// gives the set of successors to R2.
-    crate fn for_each_dependent(
-        &self,
-        region_sub: RegionVid,
-        mut op: impl FnMut(ConstraintIndex),
-    ) {
-        let mut p = self.first_constraints[region_sub];
-        while let Some(dep_idx) = p {
-            op(dep_idx);
-            p = self.next_constraints[dep_idx];
-        }
-    }
-}
-
+newtype_index!(ConstraintSccIndex { DEBUG_FORMAT = "ConstraintSccIndex({})" });

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

@@ -57,7 +57,7 @@ impl<'cx, 'gcx, 'tcx> UseFinder<'cx, 'gcx, 'tcx> {
 
         queue.push_back(self.start_point);
         while let Some(p) = queue.pop_front() {
-            if !self.regioncx.region_contains_point(self.region_vid, p) {
+            if !self.regioncx.region_contains(self.region_vid, p) {
                 continue;
             }
 

src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs

@@ -50,18 +50,10 @@ impl fmt::Display for ConstraintCategory {
 
 impl<'tcx> RegionInferenceContext<'tcx> {
     /// Walks the graph of constraints (where `'a: 'b` is considered
-    /// an edge `'b -> 'a`) to find all paths from `from_region` to
+    /// an edge `'a -> 'b`) to find all paths from `from_region` to
     /// `to_region`. The paths are accumulated into the vector
     /// `results`. The paths are stored as a series of
     /// `ConstraintIndex` values -- in other words, a list of *edges*.
-    ///
-    /// # Parameters
-    ///
-    /// - `from_region`
-    /// When reporting an error, it is useful to be able to determine
-    /// which constraints influenced the region being reported as an
-    /// error. This function finds all of the paths from the
-    /// constraint.
     fn find_constraint_paths_between_regions(
         &self,
         from_region: RegionVid,
@@ -97,25 +89,25 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         // Check if we reached the region we were looking for.
         if target_test(current_region) {
             if !stack.is_empty() {
-                assert_eq!(self.constraints[stack[0]].sub, from_region);
+                assert_eq!(self.constraints[stack[0]].sup, from_region);
                 results.push(stack.clone());
             }
             return;
         }
 
-        self.constraint_graph.for_each_dependent(current_region, |constraint| {
-            assert_eq!(self.constraints[constraint].sub, current_region);
+        for constraint in self.constraint_graph.outgoing_edges(current_region) {
+            assert_eq!(self.constraints[constraint].sup, current_region);
             stack.push(constraint);
             self.find_constraint_paths_between_regions_helper(
                 from_region,
-                self.constraints[constraint].sup,
+                self.constraints[constraint].sub,
                 target_test,
                 visited,
                 stack,
                 results,
             );
             stack.pop();
-        });
+        }
     }
 
     /// This function will return true if a constraint is interesting and false if a constraint
@@ -207,7 +199,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         }
 
         // Find all paths
-        let constraint_paths = self.find_constraint_paths_between_regions(outlived_fr, |r| r == fr);
+        let constraint_paths = self.find_constraint_paths_between_regions(fr, |r| r == outlived_fr);
         debug!("report_error: constraint_paths={:#?}", constraint_paths);
 
         // Find the shortest such path.
@@ -316,7 +308,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
 
         while changed {
             changed = false;
-            for constraint in &*self.constraints {
+            for constraint in self.constraints.iter() {
                 if let Some(n) = result_set[constraint.sup] {
                     let m = n + 1;
                     if result_set[constraint.sub]