Implement union_not for ThinBitSet.

Author: Tage Johansson

compiler/rustc_index/src/bit_set/old_dense_bit_set.rs

@@ -206,7 +206,7 @@ impl<T: Idx> DenseBitSet<T> {
     ///
     /// FIXME: Incorporate this into [`BitRelations`] and fill out
     /// implementations for other bitset types, if needed.
-    pub fn union_not(&mut self, other: &DenseBitSet<T>) {
+    pub fn union_not(&mut self, other: &DenseBitSet<T>, _domain_size: usize) {
         assert_eq!(self.domain_size, other.domain_size);
 
         // FIXME(Zalathar): If we were to forcibly _set_ all excess bits before

compiler/rustc_index/src/bit_set/tests.rs

@@ -92,6 +92,15 @@ fn union_not() {
     b.insert(63);
     b.insert(81); // Already in `a`.
     b.insert(90);
+
+    a.union_not(&b, 100);
+
+    // After union-not, `a` should contain all values in the domain, except for
+    // the ones that are in `b` and were _not_ already in `a`.
+    assert_eq!(
+        a.iter().collect::<Vec<_>>(),
+        (0usize..100).filter(|&x| !matches!(x, 7 | 63 | 90)).collect::<Vec<_>>(),
+    );
 }
 
 #[test]

compiler/rustc_index/src/bit_set/thin_bit_set.rs

@@ -342,6 +342,39 @@ impl<T> ThinBitSet<T> {
         }
     }
 
+    /// Sets `self = self | !other` for all elements less than `domain_size`.
+    #[inline(always)]
+    pub fn union_not(&mut self, other: &Self, domain_size: usize) {
+        if self.is_inline() {
+            assert!(other.is_inline());
+
+            let self_word = unsafe { &mut self.inline };
+            let other_word = unsafe { other.inline };
+
+            debug_assert!(domain_size <= Self::INLINE_CAPACITY);
+
+            *self_word |= !other_word & !(Word::MAX >> domain_size);
+        } else if other.is_empty_unallocated() {
+            self.insert_all(domain_size);
+        } else {
+            let self_words = self.on_heap_get_or_alloc().as_mut_slice();
+            let other_words = other.on_heap().unwrap().as_slice();
+
+            // Set all but the last word if domain_size is not divisible by `WORD_BITS`.
+            for (self_word, other_word) in
+                self_words.iter_mut().zip(other_words).take(domain_size / WORD_BITS)
+            {
+                *self_word |= !other_word;
+            }
+
+            let remaining_bits = domain_size % WORD_BITS;
+            if remaining_bits > 0 {
+                let last_idx = domain_size / WORD_BITS;
+                self_words[last_idx] |= !other_words[last_idx] & !(Word::MAX << remaining_bits);
+            }
+        }
+    }
+
     /// Common function for union/intersection-like operations.
     ///
     /// This function takes two bit sets—one mutably, one immutably. Neither must be the
@@ -426,11 +459,6 @@ impl<T> ThinBitSet<T> {
         }
     }
 
-    #[inline(always)]
-    pub fn union_not(&mut self, _other: &Self) {
-        todo!()
-    }
-
     super::bit_relations_inherent_impls! {}
 }
 
@@ -1483,22 +1511,27 @@ mod tests {
                         assert_eq!(set_2.remove(elem), set_2_reference.remove(elem));
                     }
                 }
-                70..79 => {
+                70..76 => {
                     // Union
                     assert_eq!(set_1.union(&set_2), set_1_reference.union(&set_2_reference));
                 }
-                79..88 => {
+                76..82 => {
                     // Intersection
                     assert_eq!(
                         set_1.intersect(&set_2),
                         set_1_reference.intersect(&set_2_reference)
                     );
                 }
-                88..97 => {
+                82..88 => {
                     // Subtraction
                     assert_eq!(set_1.subtract(&set_2), set_1_reference.subtract(&set_2_reference));
                 }
-                97..99 => {
+                88..94 => {
+                    // Union_not
+                    set_1.union_not(&set_2, domain_size);
+                    set_1_reference.union_not(&set_2_reference, domain_size);
+                }
+                94..97 => {
                     // Clear
                     if rng.next_bool() {
                         set_1.clear();
@@ -1508,7 +1541,7 @@ mod tests {
                         set_2_reference.clear();
                     }
                 }
-                99..100 => {
+                97..100 => {
                     // Test new_filled().
                     if rng.next_bool() {
                         set_1 = ThinBitSet::new_filled(domain_size);

compiler/rustc_index/src/bit_set/twin_bit_set.rs

@@ -49,10 +49,10 @@ macro_rules! compare_results_clone_arg(
 );
 
 macro_rules! compare_results_with_self(
-    ($self:ident, $method:tt, $other:expr) => {
+    ($self:ident, $method:tt, $other:expr $(, $extra_arg:expr)?) => {
         {
-            let thin_res = $self.thin.$method(&$other.thin);
-            let old_res = $self.old.$method(&$other.old);
+            let thin_res = $self.thin.$method(&$other.thin $(, $extra_arg)?);
+            let old_res = $self.old.$method(&$other.old $(, $extra_arg)?);
             $self.assert_valid();
             assert_eq!(thin_res, old_res, "TwinBitSet give different results in {}", stringify!($method));
             thin_res
@@ -154,8 +154,8 @@ impl<T: Idx> DenseBitSet<T> {
     bit_relations_inherent_impls! {}
 
     /// Sets `self = self | !other`.
-    pub fn union_not(&mut self, other: &DenseBitSet<T>) {
-        compare_results_with_self!(self, union_not, other)
+    pub fn union_not(&mut self, other: &DenseBitSet<T>, domain_size: usize) {
+        compare_results_with_self!(self, union_not, other, domain_size)
     }
 
     #[inline]

compiler/rustc_mir_transform/src/coverage/counters/balanced_flow.rs

@@ -72,7 +72,7 @@ impl<G: graph::DirectedGraph> BalancedFlowGraph<G> {
         // Next, find all nodes that are currently not reverse-reachable from
         // `sink_edge_nodes`, and add them to the set as well.
         dfs.complete_search();
-        sink_edge_nodes.union_not(dfs.visited_set());
+        sink_edge_nodes.union_not(dfs.visited_set(), graph.num_nodes());
 
         // The sink node is 1 higher than the highest real node.
         let sink = G::Node::new(graph.num_nodes());