Addressed PR comments.

davidtwco · davidtwco · commit 590ab7c3b891 · 2018-07-16T00:29:38.000+01:00
diff --git a/src/librustc_data_structures/bitvec.rs b/src/librustc_data_structures/bitvec.rs
@@ -293,15 +293,12 @@ impl<R: Idx, C: Idx> SparseBitMatrix<R, C> {
     ///
     /// Returns true if this changed the matrix, and false otherwise.
     pub fn add(&mut self, row: R, column: C) -> bool {
+        self.vector.resize_to_elem(row, || SparseBitSet::new());
         if let None = self.vector.get(row) {
             self.vector.push(SparseBitSet::new());
         }
 
-        if let Some(row) = self.vector.get_mut(row) {
-            row.insert(column)
-        } else {
-            false
-        }
+        self.vector[row].insert(column)
     }
 
     /// Do the bits from `row` contain `column`? Put another way, is
@@ -335,10 +332,8 @@ impl<R: Idx, C: Idx> SparseBitMatrix<R, C> {
 
     /// Merge a row, `from`, into the `into` row.
     pub fn merge_into(&mut self, into: R, from: &SparseBitSet<C>) -> bool {
-        match self.vector.get_mut(into) {
-            Some(row) => row.merge_into(from),
-            None => false,
-        }
+        self.vector.resize_to_elem(into, || SparseBitSet::new());
+        self.vector[into].insert_from(from)
     }
 
     /// True if `sub` is a subset of `sup`
@@ -471,8 +466,8 @@ impl<I: Idx> SparseBitSet<I> {
         }
     }
 
-    /// Merge two sparse bit sets.
-    pub fn merge_into(&mut self, from: &SparseBitSet<I>) -> bool {
+    /// Insert into bit set from another bit set.
+    pub fn insert_from(&mut self, from: &SparseBitSet<I>) -> bool {
         let mut changed = false;
         for read_chunk in from.chunks() {
             changed = changed | self.insert_chunk(read_chunk).any();
diff --git a/src/librustc_data_structures/indexed_vec.rs b/src/librustc_data_structures/indexed_vec.rs
@@ -522,6 +522,12 @@ impl<I: Idx, T: Clone> IndexVec<I, T> {
     pub fn resize(&mut self, new_len: usize, value: T) {
         self.raw.resize(new_len, value)
     }
+
+    #[inline]
+    pub fn resize_to_elem(&mut self, elem: I, fill_value: impl FnMut() -> T) {
+        let min_new_len = elem.index() + 1;
+        self.raw.resize_with(min_new_len, fill_value);
+    }
 }
 
 impl<I: Idx, T: Ord> IndexVec<I, T> {
diff --git a/src/librustc_data_structures/lib.rs b/src/librustc_data_structures/lib.rs
@@ -30,6 +30,7 @@
 #![feature(optin_builtin_traits)]
 #![feature(macro_vis_matcher)]
 #![feature(allow_internal_unstable)]
+#![feature(vec_resize_with)]
 
 #![cfg_attr(unix, feature(libc))]
 #![cfg_attr(test, feature(test))]
diff --git a/src/librustc_mir/borrow_check/nll/constraint_generation.rs b/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::{RegionElement, RegionInferenceContext};
+use borrow_check::nll::region_infer::RegionInferenceContext;
 use rustc::infer::InferCtxt;
 use rustc::mir::visit::TyContext;
 use rustc::mir::visit::Visitor;
@@ -21,7 +21,6 @@ use rustc::mir::{Local, Statement, Terminator};
 use rustc::ty::fold::TypeFoldable;
 use rustc::ty::subst::Substs;
 use rustc::ty::{self, CanonicalTy, ClosureSubsts, GeneratorSubsts};
-use std::iter;
 
 pub(super) fn generate_constraints<'cx, 'gcx, 'tcx>(
     infcx: &InferCtxt<'cx, 'gcx, 'tcx>,
@@ -39,8 +38,6 @@ pub(super) fn generate_constraints<'cx, 'gcx, 'tcx>(
         all_facts,
     };
 
-    cg.add_region_liveness_constraints_from_type_check();
-
     for (bb, data) in mir.basic_blocks().iter_enumerated() {
         cg.visit_basic_block_data(bb, data);
     }
@@ -188,42 +185,6 @@ impl<'cg, 'cx, 'gcx, 'tcx> Visitor<'tcx> for ConstraintGeneration<'cg, 'cx, 'gcx
 }
 
 impl<'cx, 'cg, 'gcx, 'tcx> ConstraintGeneration<'cx, 'cg, 'gcx, 'tcx> {
-    /// The MIR type checker generates region liveness constraints
-    /// that we also have to respect.
-    fn add_region_liveness_constraints_from_type_check(&mut self) {
-        let ConstraintGeneration {
-            regioncx,
-            location_table,
-            all_facts,
-            ..
-        } = self;
-
-        debug!(
-            "add_region_liveness_constraints_from_type_check(liveness_constraints={} items)",
-            regioncx.number_of_liveness_constraints(),
-        );
-
-        if let Some(all_facts) = all_facts {
-            for (r, _) in regioncx.liveness_constraints() {
-                all_facts
-                    .region_live_at
-                    .extend(regioncx.elements_contained_in(r)
-                            .filter_map(|region_element| {
-                                if let RegionElement::Location(location) = region_element {
-                                    Some(location)
-                                } else {
-                                    None
-                                }
-                            })
-                            .flat_map(|location| {
-                                let p1 = location_table.start_index(location);
-                                let p2 = location_table.mid_index(location);
-                                iter::once((r, p1)).chain(iter::once((r, p2)))
-                            }));
-            }
-        }
-    }
-
     /// Some variable with type `live_ty` is "regular live" at
     /// `location` -- i.e., it may be used later. This means that all
     /// regions appearing in the type `live_ty` must be live at
diff --git a/src/librustc_mir/borrow_check/nll/mod.rs b/src/librustc_mir/borrow_check/nll/mod.rs
@@ -12,7 +12,7 @@ use borrow_check::borrow_set::BorrowSet;
 use borrow_check::location::{LocationIndex, LocationTable};
 use borrow_check::nll::facts::AllFactsExt;
 use borrow_check::nll::type_check::MirTypeckRegionConstraints;
-use borrow_check::nll::region_infer::RegionValueElements;
+use borrow_check::nll::region_infer::values::RegionValueElements;
 use dataflow::indexes::BorrowIndex;
 use dataflow::move_paths::MoveData;
 use dataflow::FlowAtLocation;
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/error_reporting/mod.rs
@@ -94,6 +94,20 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             }
             return;
         }
+
+        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].sub,
+                target_test,
+                visited,
+                stack,
+                results,
+            );
+            stack.pop();
+        }
     }
 
     /// This function will return true if a constraint is interesting and false if a constraint
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/mod.rs b/src/librustc_mir/borrow_check/nll/region_infer/mod.rs
@@ -12,6 +12,7 @@ use super::universal_regions::UniversalRegions;
 use borrow_check::nll::constraints::{
     ConstraintIndex, ConstraintSccIndex, ConstraintSet, OutlivesConstraint,
 };
+use borrow_check::nll::constraints::graph::ConstraintGraph;
 use borrow_check::nll::region_infer::values::ToElementIndex;
 use borrow_check::nll::type_check::Locations;
 use rustc::hir::def_id::DefId;
@@ -26,7 +27,6 @@ use rustc::mir::{
 };
 use rustc::ty::{self, RegionVid, Ty, TyCtxt, TypeFoldable};
 use rustc::util::common;
-use rustc_data_structures::bitvec::SparseBitSet;
 use rustc_data_structures::graph::scc::Sccs;
 use rustc_data_structures::indexed_set::{IdxSet, IdxSetBuf};
 use rustc_data_structures::indexed_vec::IndexVec;
@@ -37,8 +37,8 @@ mod annotation;
 mod dump_mir;
 mod error_reporting;
 mod graphviz;
-mod values;
-crate use self::values::{RegionElement, RegionElementIndex, RegionValueElements, RegionValues};
+pub mod values;
+use self::values::{RegionValueElements, RegionValues};
 
 use super::ToRegionVid;
 
@@ -61,6 +61,11 @@ pub struct RegionInferenceContext<'tcx> {
     /// The outlives constraints computed by the type-check.
     constraints: Rc<ConstraintSet>,
 
+    /// The constraint-set, but in graph form, making it easy to traverse
+    /// the constraints adjacent to a particular region. Used to construct
+    /// the SCC (see `constraint_sccs`) and for error reporting.
+    constraint_graph: Rc<ConstraintGraph>,
+
     /// The SCC computed from `constraints` and the constraint graph. Used to compute the values
     /// of each region.
     constraint_sccs: Rc<Sccs<RegionVid, ConstraintSccIndex>>,
@@ -232,6 +237,7 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             elements: elements.clone(),
             liveness_constraints,
             constraints,
+            constraint_graph,
             constraint_sccs,
             scc_values,
             type_tests,
@@ -301,26 +307,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         self.definitions.indices()
     }
 
-    /// Iterates through each row and the accompanying bit set.
-    pub fn liveness_constraints<'a>(
-        &'a self
-    ) -> impl Iterator<Item = (RegionVid, &'a SparseBitSet<RegionElementIndex>)> + 'a {
-        self.liveness_constraints.iter_enumerated()
-    }
-
-    /// Number of liveness constaints in region inference context.
-    pub fn number_of_liveness_constraints(&self) -> usize {
-        self.liveness_constraints.len()
-    }
-
-    /// Returns all the elements contained in a given region's value.
-    crate fn elements_contained_in<'a>(
-        &'a self,
-        r: RegionVid,
-    ) -> impl Iterator<Item = RegionElement> + 'a {
-        self.liveness_constraints.elements_contained_in(r)
-    }
-
     /// Given a universal region in scope on the MIR, returns the
     /// corresponding index.
     ///
diff --git a/src/librustc_mir/borrow_check/nll/region_infer/values.rs b/src/librustc_mir/borrow_check/nll/region_infer/values.rs
@@ -214,11 +214,6 @@ impl<N: Idx> RegionValues<N> {
         self.matrix.contains(r, i)
     }
 
-    /// Number of region values.
-    crate fn len(&self) -> usize {
-        self.matrix.len()
-    }
-
     /// Iterates through each row and the accompanying bit set.
     pub fn iter_enumerated<'a>(
         &'a self
diff --git a/src/librustc_mir/borrow_check/nll/type_check/liveness.rs b/src/librustc_mir/borrow_check/nll/type_check/liveness.rs
@@ -168,9 +168,17 @@ impl<'gen, 'typeck, 'flow, 'gcx, 'tcx> TypeLivenessGenerator<'gen, 'typeck, 'flo
         );
 
         cx.tcx().for_each_free_region(&value, |live_region| {
-            if let Some(borrowck_context) = cx.borrowck_context {
+            if let Some(ref mut borrowck_context) = cx.borrowck_context {
                 let region_vid = borrowck_context.universal_regions.to_region_vid(live_region);
                 borrowck_context.constraints.liveness_constraints.add_element(region_vid, location);
+
+                if let Some(all_facts) = borrowck_context.all_facts {
+                    let start_index = borrowck_context.location_table.start_index(location);
+                    all_facts.region_live_at.push((region_vid, start_index));
+
+                    let mid_index = borrowck_context.location_table.mid_index(location);
+                    all_facts.region_live_at.push((region_vid, mid_index));
+                }
             }
         });
     }
diff --git a/src/librustc_mir/borrow_check/nll/type_check/mod.rs b/src/librustc_mir/borrow_check/nll/type_check/mod.rs
@@ -15,8 +15,8 @@ use borrow_check::borrow_set::BorrowSet;
 use borrow_check::location::LocationTable;
 use borrow_check::nll::constraints::{ConstraintSet, OutlivesConstraint};
 use borrow_check::nll::facts::AllFacts;
-use borrow_check::nll::region_infer::{ClosureRegionRequirementsExt, TypeTest, RegionValues};
-use borrow_check::nll::region_infer::{RegionValueElements};
+use borrow_check::nll::region_infer::{ClosureRegionRequirementsExt, TypeTest};
+use borrow_check::nll::region_infer::values::{RegionValues, RegionValueElements};
 use borrow_check::nll::universal_regions::UniversalRegions;
 use borrow_check::nll::ToRegionVid;
 use dataflow::move_paths::MoveData;
@@ -123,7 +123,7 @@ pub(crate) fn type_check<'gcx, 'tcx>(
     };
 
     {
-        let borrowck_context = BorrowCheckContext {
+        let mut borrowck_context = BorrowCheckContext {
             universal_regions,
             location_table,
             borrow_set,
@@ -138,8 +138,8 @@ pub(crate) fn type_check<'gcx, 'tcx>(
             mir,
             &universal_regions.region_bound_pairs,
             Some(implicit_region_bound),
-            &mut Some(borrowck_context),
-            &mut |cx| {
+            Some(&mut borrowck_context),
+            |cx| {
                 liveness::generate(cx, mir, liveness, flow_inits, move_data);
 
                 cx.equate_inputs_and_outputs(mir, mir_def_id, universal_regions);
@@ -150,16 +150,18 @@ pub(crate) fn type_check<'gcx, 'tcx>(
     constraints
 }
 
-fn type_check_internal<'a, 'gcx, 'tcx>(
+fn type_check_internal<'a, 'gcx, 'tcx, F>(
     infcx: &'a InferCtxt<'a, 'gcx, 'tcx>,
     mir_def_id: DefId,
     param_env: ty::ParamEnv<'gcx>,
     mir: &'a Mir<'tcx>,
     region_bound_pairs: &'a [(ty::Region<'tcx>, GenericKind<'tcx>)],
     implicit_region_bound: Option<ty::Region<'tcx>>,
-    borrowck_context: &'a mut Option<BorrowCheckContext<'a, 'tcx>>,
-    extra: &'a mut dyn FnMut(&mut TypeChecker<'a, 'gcx, 'tcx>),
-) {
+    borrowck_context: Option<&'a mut BorrowCheckContext<'a, 'tcx>>,
+    mut extra: F,
+)
+    where F: FnMut(&mut TypeChecker<'a, 'gcx, 'tcx>)
+{
     let mut checker = TypeChecker::new(
         infcx,
         mir,
@@ -617,7 +619,7 @@ struct TypeChecker<'a, 'gcx: 'a + 'tcx, 'tcx: 'a> {
     region_bound_pairs: &'a [(ty::Region<'tcx>, GenericKind<'tcx>)],
     implicit_region_bound: Option<ty::Region<'tcx>>,
     reported_errors: FxHashSet<(Ty<'tcx>, Span)>,
-    borrowck_context: &'a mut Option<BorrowCheckContext<'a, 'tcx>>,
+    borrowck_context: Option<&'a mut BorrowCheckContext<'a, 'tcx>>,
 }
 
 struct BorrowCheckContext<'a, 'tcx: 'a> {
@@ -730,7 +732,7 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
         param_env: ty::ParamEnv<'gcx>,
         region_bound_pairs: &'a [(ty::Region<'tcx>, GenericKind<'tcx>)],
         implicit_region_bound: Option<ty::Region<'tcx>>,
-        borrowck_context: &'a mut Option<BorrowCheckContext<'a, 'tcx>>,
+        borrowck_context: Option<&'a mut BorrowCheckContext<'a, 'tcx>>,
     ) -> Self {
         TypeChecker {
             infcx,
@@ -779,7 +781,7 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
             locations, data
         );
 
-        if let Some(borrowck_context) = &mut self.borrowck_context {
+        if let Some(ref mut borrowck_context) = self.borrowck_context {
             constraint_conversion::ConstraintConversion::new(
                 self.infcx.tcx,
                 borrowck_context.universal_regions,
@@ -1005,7 +1007,7 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
                 // output) types in the signature must be live, since
                 // all the inputs that fed into it were live.
                 for &late_bound_region in map.values() {
-                    if let Some(borrowck_context) = self.borrowck_context {
+                    if let Some(ref mut borrowck_context) = self.borrowck_context {
                         let region_vid = borrowck_context.universal_regions.to_region_vid(
                             late_bound_region);
                         borrowck_context.constraints
@@ -1505,8 +1507,8 @@ impl<'a, 'gcx, 'tcx> TypeChecker<'a, 'gcx, 'tcx> {
             all_facts,
             constraints,
             ..
-        } = match &mut self.borrowck_context {
-            Some(borrowck_context) => borrowck_context,
+        } = match self.borrowck_context {
+            Some(ref mut borrowck_context) => borrowck_context,
             None => return,
         };
 
@@ -1809,7 +1811,7 @@ impl MirPass for TypeckMir {
 
         let param_env = tcx.param_env(def_id);
         tcx.infer_ctxt().enter(|infcx| {
-            type_check_internal(&infcx, def_id, param_env, mir, &[], None, &mut None, &mut |_| ());
+            type_check_internal(&infcx, def_id, param_env, mir, &[], None, None, |_| ());
 
             // For verification purposes, we just ignore the resulting
             // region constraint sets. Not our problem. =)

Original file line number	Diff line number	Diff line change
`@@ -522,6 +522,12 @@ impl<I: Idx, T: Clone> IndexVec<I, T> {`
`522`	`522`	`pub fn resize(&mut self, new_len: usize, value: T) {`
`523`	`523`	`self.raw.resize(new_len, value)`
`524`	`524`	`}`
	`525`	`+`
	`526`	`+ #[inline]`
	`527`	`+ pub fn resize_to_elem(&mut self, elem: I, fill_value: impl FnMut() -> T) {`
	`528`	`+ let min_new_len = elem.index() + 1;`
	`529`	`+ self.raw.resize_with(min_new_len, fill_value);`
	`530`	`+ }`
`525`	`531`	`}`
`526`	`532`
`527`	`533`	`impl<I: Idx, T: Ord> IndexVec<I, T> {`