Fix overflow exception in BitArray

spec/std/bit_array_spec.cr

@@ -74,6 +74,27 @@ describe "BitArray" do
       (b == c).should be_false
       (a == d).should be_false
     end
+
+    it "compares last bit" do
+      a = BitArray.new(1000)
+      b = BitArray.new(1000)
+      a.should eq(b)
+      a[-1] = true
+      a.should_not eq(b)
+    end
+
+    it "compares true-initialized" do
+      BitArray.new(0, true).should eq(BitArray.new(0))
+      {31, 32, 33, 63, 64, 65}.each do |size|
+        ary = BitArray.new(size, true)
+        bry = BitArray.new(size)
+        bry.should_not eq(ary)
+        0.to(size - 2) { |i| bry[i] = true }
+        bry.should_not eq(ary)
+        bry[-1] = true
+        bry.should eq(ary)
+      end
+    end
   end
 
   describe "[]" do
@@ -225,6 +246,19 @@ describe "BitArray" do
 
       ba[28..40].should eq(from_int(13, 0b1111111111111))
     end
+
+    it "gets 32-bit boundaries" do
+      {32, 64, 128}.each do |ba_size|
+        ba = BitArray.new(ba_size, true)
+        {0, 31, 32}.each do |start|
+          {0, 31, 32}.each do |len|
+            size = {ba_size - start, len}.min
+            ba[start, len].size.should eq(size)
+            ba[start, len].should eq(BitArray.new(size, true))
+          end
+        end
+      end
+    end
   end
 
   it "toggles a bit" do
@@ -337,4 +371,12 @@ describe "BitArray" do
     iter.next.should be_true
     iter.next.should be_a(Iterator::Stop)
   end
+
+  it "hashes" do
+    1.to(17) do |len|
+      ba = BitArray.new(len, true)
+      0.upto(len - 1) { |i| ba[i] = false }
+      BitArray.new(len).hash.should eq(ba.hash)
+    end
+  end
 end

src/bit_array.cr

@@ -32,10 +32,17 @@ struct BitArray
 
   def ==(other : BitArray)
     return false if size != other.size
-    # NOTE: If BitArray implements resizing, there may be more than 1 binary
-    # representation and their hashes for equivalent BitArrays after a downsize as the
-    # discarded bits may not have been zeroed.
-    return LibC.memcmp(@bits, other.@bits, malloc_size) == 0
+    return true if size == 0
+    return false if LibC.memcmp(@bits, other.@bits, malloc_size - 1) != 0
+    last = @bits[malloc_size - 1]
+    other_last = other.@bits[malloc_size - 1]
+    return true if last == other_last
+    trailing = 32 - size % 32
+    if trailing != 32
+      last << trailing == other_last << trailing
+    else
+      false
+    end
   end
 
   def ==(other)
@@ -133,18 +140,18 @@ struct BitArray
       bits = @bits[0]
 
       bits >>= start
-      bits &= (1 << count) - 1
+      bits &= (1 << count) &- 1
 
       BitArray.new(count).tap { |ba| ba.@bits[0] = bits }
     elsif size <= 64
       # Original fits in int64, we can use bitshifts
       bits = @bits.as(UInt64*)[0]
 
       bits >>= start
-      bits &= (1 << count) - 1
+      bits &= (1 << count) &- 1
 
       if count <= 32
-        BitArray.new(count).tap { |ba| ba.@bits[0] = bits.to_u32 }
+        BitArray.new(count).tap { |ba| ba.@bits[0] = bits.to_u32! }
       else
         BitArray.new(count).tap { |ba| [email protected](UInt64*)[0] = bits }
       end
@@ -162,7 +169,7 @@ struct BitArray
         bits = @bits[start_bit_index + i + 1]
 
         high_bits = bits
-        high_bits &= (1 << start_sub_index) - 1
+        high_bits &= (1 << start_sub_index) &- 1
         high_bits <<= 32 - start_sub_index
 
         ba.@bits[i] = low_bits | high_bits
@@ -239,7 +246,13 @@ struct BitArray
   # See `Object#hash(hasher)`
   def hash(hasher)
     hasher = size.hash(hasher)
-    hasher = to_slice.hash(hasher)
+    bytes, bits = @size.divmod(8)
+    if bytes > 0
+      hasher = Slice.new(@bits.as(Pointer(UInt8)), bytes).hash(hasher)
+    end
+    if bits != 0
+      hasher = (@bits.as(Pointer(UInt8))[bytes] << 8 - bits).hash(hasher)
+    end
     hasher
   end