Auto merge of #385 - stepancheg:pub-crate, r=Amanieu

Mark non-private members of mod raw pub(crate)

When reading code, make it more clear, what is private and what is public API.

Author: bors

src/raw/alloc.rs

@@ -7,7 +7,7 @@ mod inner {
     use core::ptr::NonNull;
 
     #[allow(clippy::map_err_ignore)]
-    pub fn do_alloc<A: Allocator>(alloc: &A, layout: Layout) -> Result<NonNull<u8>, ()> {
+    pub(crate) fn do_alloc<A: Allocator>(alloc: &A, layout: Layout) -> Result<NonNull<u8>, ()> {
         match alloc.allocate(layout) {
             Ok(ptr) => Ok(ptr.as_non_null_ptr()),
             Err(_) => Err(()),
@@ -58,7 +58,7 @@ mod inner {
         }
     }
 
-    pub fn do_alloc<A: Allocator>(alloc: &A, layout: Layout) -> Result<NonNull<u8>, ()> {
+    pub(crate) fn do_alloc<A: Allocator>(alloc: &A, layout: Layout) -> Result<NonNull<u8>, ()> {
         alloc.allocate(layout)
     }
 

src/raw/bitmask.rs

@@ -14,14 +14,14 @@ use core::intrinsics;
 /// performed on counts/indices to normalize this difference. `BITMASK_MASK` is
 /// similarly a mask of all the actually-used bits.
 #[derive(Copy, Clone)]
-pub struct BitMask(pub BitMaskWord);
+pub(crate) struct BitMask(pub(crate) BitMaskWord);
 
 #[allow(clippy::use_self)]
 impl BitMask {
     /// Returns a new `BitMask` with all bits inverted.
     #[inline]
     #[must_use]
-    pub fn invert(self) -> Self {
+    pub(crate) fn invert(self) -> Self {
         BitMask(self.0 ^ BITMASK_MASK)
     }
 
@@ -31,7 +31,7 @@ impl BitMask {
     #[inline]
     #[allow(clippy::cast_ptr_alignment)]
     #[cfg(feature = "raw")]
-    pub unsafe fn flip(&mut self, index: usize) -> bool {
+    pub(crate) unsafe fn flip(&mut self, index: usize) -> bool {
         // NOTE: The + BITMASK_STRIDE - 1 is to set the high bit.
         let mask = 1 << (index * BITMASK_STRIDE + BITMASK_STRIDE - 1);
         self.0 ^= mask;
@@ -42,18 +42,18 @@ impl BitMask {
     /// Returns a new `BitMask` with the lowest bit removed.
     #[inline]
     #[must_use]
-    pub fn remove_lowest_bit(self) -> Self {
+    pub(crate) fn remove_lowest_bit(self) -> Self {
         BitMask(self.0 & (self.0 - 1))
     }
     /// Returns whether the `BitMask` has at least one set bit.
     #[inline]
-    pub fn any_bit_set(self) -> bool {
+    pub(crate) fn any_bit_set(self) -> bool {
         self.0 != 0
     }
 
     /// Returns the first set bit in the `BitMask`, if there is one.
     #[inline]
-    pub fn lowest_set_bit(self) -> Option<usize> {
+    pub(crate) fn lowest_set_bit(self) -> Option<usize> {
         if self.0 == 0 {
             None
         } else {
@@ -65,18 +65,18 @@ impl BitMask {
     /// bitmask must not be empty.
     #[inline]
     #[cfg(feature = "nightly")]
-    pub unsafe fn lowest_set_bit_nonzero(self) -> usize {
+    pub(crate) unsafe fn lowest_set_bit_nonzero(self) -> usize {
         intrinsics::cttz_nonzero(self.0) as usize / BITMASK_STRIDE
     }
     #[inline]
     #[cfg(not(feature = "nightly"))]
-    pub unsafe fn lowest_set_bit_nonzero(self) -> usize {
+    pub(crate) unsafe fn lowest_set_bit_nonzero(self) -> usize {
         self.trailing_zeros()
     }
 
     /// Returns the number of trailing zeroes in the `BitMask`.
     #[inline]
-    pub fn trailing_zeros(self) -> usize {
+    pub(crate) fn trailing_zeros(self) -> usize {
         // ARM doesn't have a trailing_zeroes instruction, and instead uses
         // reverse_bits (RBIT) + leading_zeroes (CLZ). However older ARM
         // versions (pre-ARMv7) don't have RBIT and need to emulate it
@@ -91,7 +91,7 @@ impl BitMask {
 
     /// Returns the number of leading zeroes in the `BitMask`.
     #[inline]
-    pub fn leading_zeros(self) -> usize {
+    pub(crate) fn leading_zeros(self) -> usize {
         self.0.leading_zeros() as usize / BITMASK_STRIDE
     }
 }
@@ -108,7 +108,7 @@ impl IntoIterator for BitMask {
 
 /// Iterator over the contents of a `BitMask`, returning the indices of set
 /// bits.
-pub struct BitMaskIter(BitMask);
+pub(crate) struct BitMaskIter(BitMask);
 
 impl Iterator for BitMaskIter {
     type Item = usize;

src/raw/generic.rs

@@ -20,11 +20,11 @@ type GroupWord = u64;
 ))]
 type GroupWord = u32;
 
-pub type BitMaskWord = GroupWord;
-pub const BITMASK_STRIDE: usize = 8;
+pub(crate) type BitMaskWord = GroupWord;
+pub(crate) const BITMASK_STRIDE: usize = 8;
 // We only care about the highest bit of each byte for the mask.
 #[allow(clippy::cast_possible_truncation, clippy::unnecessary_cast)]
-pub const BITMASK_MASK: BitMaskWord = 0x8080_8080_8080_8080_u64 as GroupWord;
+pub(crate) const BITMASK_MASK: BitMaskWord = 0x8080_8080_8080_8080_u64 as GroupWord;
 
 /// Helper function to replicate a byte across a `GroupWord`.
 #[inline]
@@ -37,7 +37,7 @@ fn repeat(byte: u8) -> GroupWord {
 ///
 /// This implementation uses a word-sized integer.
 #[derive(Copy, Clone)]
-pub struct Group(GroupWord);
+pub(crate) struct Group(GroupWord);
 
 // We perform all operations in the native endianness, and convert to
 // little-endian just before creating a BitMask. The can potentially
@@ -46,14 +46,14 @@ pub struct Group(GroupWord);
 #[allow(clippy::use_self)]
 impl Group {
     /// Number of bytes in the group.
-    pub const WIDTH: usize = mem::size_of::<Self>();
+    pub(crate) const WIDTH: usize = mem::size_of::<Self>();
 
     /// Returns a full group of empty bytes, suitable for use as the initial
     /// value for an empty hash table.
     ///
     /// This is guaranteed to be aligned to the group size.
     #[inline]
-    pub const fn static_empty() -> &'static [u8; Group::WIDTH] {
+    pub(crate) const fn static_empty() -> &'static [u8; Group::WIDTH] {
         #[repr(C)]
         struct AlignedBytes {
             _align: [Group; 0],
@@ -69,15 +69,15 @@ impl Group {
     /// Loads a group of bytes starting at the given address.
     #[inline]
     #[allow(clippy::cast_ptr_alignment)] // unaligned load
-    pub unsafe fn load(ptr: *const u8) -> Self {
+    pub(crate) unsafe fn load(ptr: *const u8) -> Self {
         Group(ptr::read_unaligned(ptr.cast()))
     }
 
     /// Loads a group of bytes starting at the given address, which must be
     /// aligned to `mem::align_of::<Group>()`.
     #[inline]
     #[allow(clippy::cast_ptr_alignment)]
-    pub unsafe fn load_aligned(ptr: *const u8) -> Self {
+    pub(crate) unsafe fn load_aligned(ptr: *const u8) -> Self {
         // FIXME: use align_offset once it stabilizes
         debug_assert_eq!(ptr as usize & (mem::align_of::<Self>() - 1), 0);
         Group(ptr::read(ptr.cast()))
@@ -87,7 +87,7 @@ impl Group {
     /// aligned to `mem::align_of::<Group>()`.
     #[inline]
     #[allow(clippy::cast_ptr_alignment)]
-    pub unsafe fn store_aligned(self, ptr: *mut u8) {
+    pub(crate) unsafe fn store_aligned(self, ptr: *mut u8) {
         // FIXME: use align_offset once it stabilizes
         debug_assert_eq!(ptr as usize & (mem::align_of::<Self>() - 1), 0);
         ptr::write(ptr.cast(), self.0);
@@ -104,7 +104,7 @@ impl Group {
     /// - This only happens if there is at least 1 true match.
     /// - The chance of this happening is very low (< 1% chance per byte).
     #[inline]
-    pub fn match_byte(self, byte: u8) -> BitMask {
+    pub(crate) fn match_byte(self, byte: u8) -> BitMask {
         // This algorithm is derived from
         // https://graphics.stanford.edu/~seander/bithacks.html##ValueInWord
         let cmp = self.0 ^ repeat(byte);
@@ -114,7 +114,7 @@ impl Group {
     /// Returns a `BitMask` indicating all bytes in the group which are
     /// `EMPTY`.
     #[inline]
-    pub fn match_empty(self) -> BitMask {
+    pub(crate) fn match_empty(self) -> BitMask {
         // If the high bit is set, then the byte must be either:
         // 1111_1111 (EMPTY) or 1000_0000 (DELETED).
         // So we can just check if the top two bits are 1 by ANDing them.
@@ -124,14 +124,14 @@ impl Group {
     /// Returns a `BitMask` indicating all bytes in the group which are
     /// `EMPTY` or `DELETED`.
     #[inline]
-    pub fn match_empty_or_deleted(self) -> BitMask {
+    pub(crate) fn match_empty_or_deleted(self) -> BitMask {
         // A byte is EMPTY or DELETED iff the high bit is set
         BitMask((self.0 & repeat(0x80)).to_le())
     }
 
     /// Returns a `BitMask` indicating all bytes in the group which are full.
     #[inline]
-    pub fn match_full(self) -> BitMask {
+    pub(crate) fn match_full(self) -> BitMask {
         self.match_empty_or_deleted().invert()
     }
 
@@ -140,7 +140,7 @@ impl Group {
     /// - `DELETED => EMPTY`
     /// - `FULL => DELETED`
     #[inline]
-    pub fn convert_special_to_empty_and_full_to_deleted(self) -> Self {
+    pub(crate) fn convert_special_to_empty_and_full_to_deleted(self) -> Self {
         // Map high_bit = 1 (EMPTY or DELETED) to 1111_1111
         // and high_bit = 0 (FULL) to 1000_0000
         //

src/raw/sse2.rs

@@ -7,30 +7,30 @@ use core::arch::x86;
 #[cfg(target_arch = "x86_64")]
 use core::arch::x86_64 as x86;
 
-pub type BitMaskWord = u16;
-pub const BITMASK_STRIDE: usize = 1;
-pub const BITMASK_MASK: BitMaskWord = 0xffff;
+pub(crate) type BitMaskWord = u16;
+pub(crate) const BITMASK_STRIDE: usize = 1;
+pub(crate) const BITMASK_MASK: BitMaskWord = 0xffff;
 
 /// Abstraction over a group of control bytes which can be scanned in
 /// parallel.
 ///
 /// This implementation uses a 128-bit SSE value.
 #[derive(Copy, Clone)]
-pub struct Group(x86::__m128i);
+pub(crate) struct Group(x86::__m128i);
 
 // FIXME: https://github.com/rust-lang/rust-clippy/issues/3859
 #[allow(clippy::use_self)]
 impl Group {
     /// Number of bytes in the group.
-    pub const WIDTH: usize = mem::size_of::<Self>();
+    pub(crate) const WIDTH: usize = mem::size_of::<Self>();
 
     /// Returns a full group of empty bytes, suitable for use as the initial
     /// value for an empty hash table.
     ///
     /// This is guaranteed to be aligned to the group size.
     #[inline]
     #[allow(clippy::items_after_statements)]
-    pub const fn static_empty() -> &'static [u8; Group::WIDTH] {
+    pub(crate) const fn static_empty() -> &'static [u8; Group::WIDTH] {
         #[repr(C)]
         struct AlignedBytes {
             _align: [Group; 0],
@@ -46,15 +46,15 @@ impl Group {
     /// Loads a group of bytes starting at the given address.
     #[inline]
     #[allow(clippy::cast_ptr_alignment)] // unaligned load
-    pub unsafe fn load(ptr: *const u8) -> Self {
+    pub(crate) unsafe fn load(ptr: *const u8) -> Self {
         Group(x86::_mm_loadu_si128(ptr.cast()))
     }
 
     /// Loads a group of bytes starting at the given address, which must be
     /// aligned to `mem::align_of::<Group>()`.
     #[inline]
     #[allow(clippy::cast_ptr_alignment)]
-    pub unsafe fn load_aligned(ptr: *const u8) -> Self {
+    pub(crate) unsafe fn load_aligned(ptr: *const u8) -> Self {
         // FIXME: use align_offset once it stabilizes
         debug_assert_eq!(ptr as usize & (mem::align_of::<Self>() - 1), 0);
         Group(x86::_mm_load_si128(ptr.cast()))
@@ -64,7 +64,7 @@ impl Group {
     /// aligned to `mem::align_of::<Group>()`.
     #[inline]
     #[allow(clippy::cast_ptr_alignment)]
-    pub unsafe fn store_aligned(self, ptr: *mut u8) {
+    pub(crate) unsafe fn store_aligned(self, ptr: *mut u8) {
         // FIXME: use align_offset once it stabilizes
         debug_assert_eq!(ptr as usize & (mem::align_of::<Self>() - 1), 0);
         x86::_mm_store_si128(ptr.cast(), self.0);
@@ -73,7 +73,7 @@ impl Group {
     /// Returns a `BitMask` indicating all bytes in the group which have
     /// the given value.
     #[inline]
-    pub fn match_byte(self, byte: u8) -> BitMask {
+    pub(crate) fn match_byte(self, byte: u8) -> BitMask {
         #[allow(
             clippy::cast_possible_wrap, // byte: u8 as i8
             // byte: i32 as u16
@@ -91,14 +91,14 @@ impl Group {
     /// Returns a `BitMask` indicating all bytes in the group which are
     /// `EMPTY`.
     #[inline]
-    pub fn match_empty(self) -> BitMask {
+    pub(crate) fn match_empty(self) -> BitMask {
         self.match_byte(EMPTY)
     }
 
     /// Returns a `BitMask` indicating all bytes in the group which are
     /// `EMPTY` or `DELETED`.
     #[inline]
-    pub fn match_empty_or_deleted(self) -> BitMask {
+    pub(crate) fn match_empty_or_deleted(self) -> BitMask {
         #[allow(
             // byte: i32 as u16
             //   note: _mm_movemask_epi8 returns a 16-bit mask in a i32, the
@@ -114,7 +114,7 @@ impl Group {
 
     /// Returns a `BitMask` indicating all bytes in the group which are full.
     #[inline]
-    pub fn match_full(&self) -> BitMask {
+    pub(crate) fn match_full(&self) -> BitMask {
         self.match_empty_or_deleted().invert()
     }
 
@@ -123,7 +123,7 @@ impl Group {
     /// - `DELETED => EMPTY`
     /// - `FULL => DELETED`
     #[inline]
-    pub fn convert_special_to_empty_and_full_to_deleted(self) -> Self {
+    pub(crate) fn convert_special_to_empty_and_full_to_deleted(self) -> Self {
         // Map high_bit = 1 (EMPTY or DELETED) to 1111_1111
         // and high_bit = 0 (FULL) to 1000_0000
         //