Don't allocate on the heap for empty bit sets (#10495)

This commit fixes an issue where `CompoundBitSet::with_capacity(0)`
would end up allocation space on the heap due to an off-by-one in the
implementation. When calculating the maximum bit that might be set the
implementation now subtracts one. This more accurately models the
maximum bit that could be set and additionally guarantees the property
that `with_capacity(0)` does not allocate anything on the heap.

Author: alexcrichton

cranelift/bitset/src/compound.rs

@@ -243,7 +243,13 @@ impl<T: ScalarBitSetStorage> CompoundBitSet<T> {
     /// ```
     #[inline]
     pub fn ensure_capacity(&mut self, n: usize) {
-        let (word, _bit) = Self::word_and_bit(n);
+        // Subtract one from the capacity to get the maximum bit that we might
+        // set. If `n` is 0 then nothing need be done as no capacity needs to be
+        // allocated.
+        let (word, _bit) = Self::word_and_bit(match n.checked_sub(1) {
+            None => return,
+            Some(n) => n,
+        });
         if word >= self.elems.len() {
             assert!(word < usize::try_from(isize::MAX).unwrap());
 
@@ -552,3 +558,16 @@ impl<T: ScalarBitSetStorage> Iterator for Iter<'_, T> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn zero_capacity_no_allocs() {
+        let set = CompoundBitSet::<u32>::with_capacity(0);
+        assert_eq!(set.capacity(), 0);
+        let set = CompoundBitSet::new();
+        assert_eq!(set.capacity(), 0);
+    }
+}