split into two matrices

Author: nikomatsakis

src/librustc_data_structures/bitvec.rs

@@ -43,12 +43,27 @@ impl<C: Idx> BitVector<C> {
         self.data.iter().map(|e| e.count_ones() as usize).sum()
     }
 
+    /// True if `self` contains the bit `bit`.
     #[inline]
     pub fn contains(&self, bit: C) -> bool {
         let (word, mask) = word_mask(bit);
         (self.data[word] & mask) != 0
     }
 
+    /// True if `self` contains all the bits in `other`.
+    ///
+    /// The two vectors must have the same length.
+    #[inline]
+    pub fn contains_all(&self, other: &BitVector<C>) -> bool {
+        assert_eq!(self.data.len(), other.data.len());
+        self.data.iter().zip(&other.data).all(|(a, b)| (a & b) == *b)
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.data.iter().all(|a| *a == 0)
+    }
+
     /// Returns true if the bit has changed.
     #[inline]
     pub fn insert(&mut self, bit: C) -> bool {
@@ -349,6 +364,10 @@ impl<R: Idx, C: Idx> SparseBitMatrix<R, C> {
         self.vector.len()
     }
 
+    pub fn rows(&self) -> impl Iterator<Item = R> {
+        self.vector.indices()
+    }
+
     /// Iterates through all the columns set to true in a given row of
     /// the matrix.
     pub fn iter<'a>(&'a self, row: R) -> impl Iterator<Item = C> + 'a {
@@ -522,3 +541,45 @@ fn matrix_iter() {
     }
     assert!(iter.next().is_none());
 }
+
+#[test]
+fn sparse_matrix_iter() {
+    let mut matrix = SparseBitMatrix::new(64, 100);
+    matrix.add(3, 22);
+    matrix.add(3, 75);
+    matrix.add(2, 99);
+    matrix.add(4, 0);
+    matrix.merge(3, 5);
+
+    let expected = [99];
+    let mut iter = expected.iter();
+    for i in matrix.iter(2) {
+        let j = *iter.next().unwrap();
+        assert_eq!(i, j);
+    }
+    assert!(iter.next().is_none());
+
+    let expected = [22, 75];
+    let mut iter = expected.iter();
+    for i in matrix.iter(3) {
+        let j = *iter.next().unwrap();
+        assert_eq!(i, j);
+    }
+    assert!(iter.next().is_none());
+
+    let expected = [0];
+    let mut iter = expected.iter();
+    for i in matrix.iter(4) {
+        let j = *iter.next().unwrap();
+        assert_eq!(i, j);
+    }
+    assert!(iter.next().is_none());
+
+    let expected = [22, 75];
+    let mut iter = expected.iter();
+    for i in matrix.iter(5) {
+        let j = *iter.next().unwrap();
+        assert_eq!(i, j);
+    }
+    assert!(iter.next().is_none());
+}

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

@@ -48,9 +48,6 @@ pub struct RegionInferenceContext<'tcx> {
     /// from as well as its final inferred value.
     definitions: IndexVec<RegionVid, RegionDefinition<'tcx>>,
 
-    /// Maps from points/universal-regions to a `RegionElementIndex`.
-    elements: Rc<RegionValueElements>,
-
     /// The liveness constraints added to each region. For most
     /// regions, these start out empty and steadily grow, though for
     /// each universally quantified region R they start out containing
@@ -219,14 +216,13 @@ impl<'tcx> RegionInferenceContext<'tcx> {
 
         let mut scc_values = RegionValues::new(elements);
 
-        for (region, location_set) in liveness_constraints.iter_enumerated() {
+        for region in liveness_constraints.regions_with_points() {
             let scc = constraint_sccs.scc(region);
-            scc_values.merge_into(scc, location_set);
+            scc_values.merge_row(scc, region, &liveness_constraints);
         }
 
         let mut result = Self {
             definitions,
-            elements: elements.clone(),
             liveness_constraints,
             constraints,
             constraint_graph,
@@ -273,7 +269,6 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         }
 
         // For each universally quantified region X:
-        let elements = self.elements.clone();
         let universal_regions = self.universal_regions.clone();
         for variable in universal_regions.universal_regions() {
             // These should be free-region variables.
@@ -283,9 +278,9 @@ impl<'tcx> RegionInferenceContext<'tcx> {
             });
 
             // Add all nodes in the CFG to liveness constraints
-            for point_index in elements.all_point_indices() {
-                self.add_live_element(variable, point_index);
-            }
+            let variable_scc = self.constraint_sccs.scc(variable);
+            self.liveness_constraints.add_all_points(variable);
+            self.scc_values.add_all_points(variable_scc);
 
             // Add `end(X)` into the set for X.
             self.add_live_element(variable, variable);
@@ -782,7 +777,8 @@ impl<'tcx> RegionInferenceContext<'tcx> {
         // now). Therefore, the sup-region outlives the sub-region if,
         // for each universal region R1 in the sub-region, there
         // exists some region R2 in the sup-region that outlives R1.
-        let universal_outlives = self.scc_values
+        let universal_outlives = self
+            .scc_values
             .universal_regions_outlived_by(sub_region_scc)
             .all(|r1| {
                 self.scc_values