Inline and group tests for vector<bool> together

Author: winner245

libcxx/include/__bit/popcount.h

@@ -50,7 +50,6 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __popcount(_Tp __t) _NOEXCEPT {
     return std::__libcpp_popcount(static_cast<unsigned long long>(__t));
   } else {
 #if _LIBCPP_STD_VER == 11
-    // A recursive constexpr implementation for C++11
     return __t != 0 ? std::__libcpp_popcount(static_cast<unsigned long long>(__t)) +
                           std::__popcount<_Tp>(__t >> numeric_limits<unsigned long long>::digits)
                     : 0;
@@ -69,7 +68,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __popcount(_Tp __t) _NOEXCEPT {
 
 template <__libcpp_unsigned_integer _Tp>
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int popcount(_Tp __t) noexcept {
-#  if __has_builtin(__builtin_popcountg)
+#  if __has_builtin(__builtin_popcountg) // TODO (LLVM 21): This can be dropped once we only support Clang >= 19.
   return __builtin_popcountg(__t);
 #  else
   return std::__popcount(__t);

libcxx/include/__bit_reference

@@ -70,19 +70,18 @@ struct __size_difference_type_traits<_Cp, __void_t<typename _Cp::difference_type
 template <class _StorageType>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _StorageType __trailing_mask(unsigned __clz) {
   static_assert(is_unsigned<_StorageType>::value, "__trailing_mask only works with unsigned types");
-  return static_cast<_StorageType>(static_cast<_StorageType>(~static_cast<_StorageType>(0)) >> __clz);
+  return static_cast<_StorageType>(~static_cast<_StorageType>(0)) >> __clz;
 }
 
 template <class _StorageType>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _StorageType __middle_mask(unsigned __clz, unsigned __ctz) {
   static_assert(is_unsigned<_StorageType>::value, "__middle_mask only works with unsigned types");
-  return static_cast<_StorageType>(static_cast<_StorageType>(~static_cast<_StorageType>(0)) << __ctz) &
+  return (static_cast<_StorageType>(~static_cast<_StorageType>(0)) << __ctz) &
          std::__trailing_mask<_StorageType>(__clz);
 }
 
 // This function is designed to operate correctly even for smaller integral types like `uint8_t`, `uint16_t`,
-// or `unsigned short`. Casting back to _StorageType is crucial to prevent undefined behavior that can arise
-// from integral promotions.
+// or `unsigned short`.
 // See https://github.com/llvm/llvm-project/pull/122410.
 template <class _StoragePointer>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
@@ -96,7 +95,7 @@ __fill_masked_range(_StoragePointer __word, unsigned __clz, unsigned __ctz, bool
   if (__fill_val)
     *__word |= __m;
   else
-    *__word &= static_cast<_StorageType>(~__m);
+    *__word &= ~__m;
 }
 
 template <class _Cp, bool = __has_storage_type<_Cp>::value>

libcxx/test/std/algorithms/alg.nonmodifying/alg.count/count.pass.cpp

@@ -38,45 +38,51 @@ struct Test {
   }
 };
 
-TEST_CONSTEXPR_CXX20 void test_bit_iterator_with_custom_sized_types() {
-  {
-    using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
-    std::vector<bool, Alloc> in(100, true, Alloc(1));
-    assert(std::count(in.begin(), in.end(), true) == 100);
-  }
-  {
-    using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
-    std::vector<bool, Alloc> in(199, true, Alloc(1));
-    assert(std::count(in.begin(), in.end(), true) == 199);
-  }
-  {
-    using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;
-    std::vector<bool, Alloc> in(200, true, Alloc(1));
-    assert(std::count(in.begin(), in.end(), true) == 200);
-  }
-  {
-    using Alloc = sized_allocator<bool, std::uint64_t, std::int64_t>;
-    std::vector<bool, Alloc> in(257, true, Alloc(1));
-    assert(std::count(in.begin(), in.end(), true) == 257);
-  }
-}
-
 TEST_CONSTEXPR_CXX20 bool test() {
   types::for_each(types::cpp17_input_iterator_list<const int*>(), Test());
 
-  if (TEST_STD_AT_LEAST_20_OR_RUNTIME_EVALUATED) {
-    std::vector<bool> vec(256 + 64);
-    for (ptrdiff_t i = 0; i != 256; ++i) {
-      for (size_t offset = 0; offset != 64; ++offset) {
-        std::fill(vec.begin(), vec.end(), false);
-        std::fill(vec.begin() + offset, vec.begin() + i + offset, true);
-        assert(std::count(vec.begin() + offset, vec.begin() + offset + 256, true) == i);
-        assert(std::count(vec.begin() + offset, vec.begin() + offset + 256, false) == 256 - i);
+  // Tests for std::count with std::vector<bool>::iterator optimizations.
+  {
+    { // check that vector<bool>::iterator optimization works as expected
+      std::vector<bool> vec(256 + 64);
+      for (ptrdiff_t i = 0; i != 256; ++i) {
+        for (size_t offset = 0; offset != 64; ++offset) {
+          std::fill(vec.begin(), vec.end(), false);
+          std::fill(vec.begin() + offset, vec.begin() + i + offset, true);
+          assert(std::count(vec.begin() + offset, vec.begin() + offset + 256, true) == i);
+          assert(std::count(vec.begin() + offset, vec.begin() + offset + 256, false) == 256 - i);
+        }
       }
     }
-  }
 
-  test_bit_iterator_with_custom_sized_types();
+    // Fix std::count for std::vector<bool> with small storage types, e.g., std::uint16_t, unsigned short.
+    // See https://github.com/llvm/llvm-project/issues/122528
+    {
+      using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
+      std::vector<bool, Alloc> in(100, true, Alloc(1));
+      assert(std::count(in.begin(), in.end(), true) == 100);
+    }
+    {
+      using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
+      std::vector<bool, Alloc> in(199, true, Alloc(1));
+      assert(std::count(in.begin(), in.end(), true) == 199);
+    }
+    {
+      using Alloc = sized_allocator<bool, unsigned short, short>;
+      std::vector<bool, Alloc> in(200, true, Alloc(1));
+      assert(std::count(in.begin(), in.end(), true) == 200);
+    }
+    {
+      using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;
+      std::vector<bool, Alloc> in(205, true, Alloc(1));
+      assert(std::count(in.begin(), in.end(), true) == 205);
+    }
+    {
+      using Alloc = sized_allocator<bool, std::uint64_t, std::int64_t>;
+      std::vector<bool, Alloc> in(257, true, Alloc(1));
+      assert(std::count(in.begin(), in.end(), true) == 257);
+    }
+  }
 
   return true;
 }

libcxx/test/std/algorithms/alg.nonmodifying/alg.count/ranges.count.pass.cpp

@@ -156,29 +156,6 @@ constexpr void test_iterators() {
   }
 }
 
-TEST_CONSTEXPR_CXX20 void test_bit_iterator_with_custom_sized_types() {
-  {
-    using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
-    std::vector<bool, Alloc> in(100, true, Alloc(1));
-    assert(std::ranges::count(in, true) == 100);
-  }
-  {
-    using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
-    std::vector<bool, Alloc> in(199, true, Alloc(1));
-    assert(std::ranges::count(in, true) == 199);
-  }
-  {
-    using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;
-    std::vector<bool, Alloc> in(200, true, Alloc(1));
-    assert(std::ranges::count(in, true) == 200);
-  }
-  {
-    using Alloc = sized_allocator<bool, std::uint64_t, std::int64_t>;
-    std::vector<bool, Alloc> in(257, true, Alloc(1));
-    assert(std::ranges::count(in, true) == 257);
-  }
-}
-
 constexpr bool test() {
   test_iterators<int*>();
   test_iterators<const int*>();
@@ -293,19 +270,48 @@ constexpr bool test() {
     }
   }
 
-  { // check that __bit_iterator optimizations work as expected
-    std::vector<bool> vec(256 + 64);
-    for (ptrdiff_t i = 0; i != 256; ++i) {
-      for (size_t offset = 0; offset != 64; ++offset) {
-        std::fill(vec.begin(), vec.end(), false);
-        std::fill(vec.begin() + offset, vec.begin() + i + offset, true);
-        assert(std::ranges::count(vec.begin() + offset, vec.begin() + offset + 256, true) == i);
-        assert(std::ranges::count(vec.begin() + offset, vec.begin() + offset + 256, false) == 256 - i);
+  // Tests for std::count with std::vector<bool>::iterator optimizations.
+  {
+    { // check that vector<bool>::iterator optimization works as expected
+      std::vector<bool> vec(256 + 64);
+      for (ptrdiff_t i = 0; i != 256; ++i) {
+        for (size_t offset = 0; offset != 64; ++offset) {
+          std::fill(vec.begin(), vec.end(), false);
+          std::fill(vec.begin() + offset, vec.begin() + i + offset, true);
+          assert(std::ranges::count(vec.begin() + offset, vec.begin() + offset + 256, true) == i);
+          assert(std::ranges::count(vec.begin() + offset, vec.begin() + offset + 256, false) == 256 - i);
+        }
       }
     }
-  }
 
-  test_bit_iterator_with_custom_sized_types();
+    // Fix std::ranges::count for std::vector<bool> with small storage types, e.g., std::uint16_t, unsigned short.
+    // See https://github.com/llvm/llvm-project/issues/122528
+    {
+      using Alloc = sized_allocator<bool, std::uint8_t, std::int8_t>;
+      std::vector<bool, Alloc> in(100, true, Alloc(1));
+      assert(std::ranges::count(in, true) == 100);
+    }
+    {
+      using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
+      std::vector<bool, Alloc> in(199, true, Alloc(1));
+      assert(std::ranges::count(in, true) == 199);
+    }
+    {
+      using Alloc = sized_allocator<bool, unsigned short, short>;
+      std::vector<bool, Alloc> in(200, true, Alloc(1));
+      assert(std::ranges::count(in, true) == 200);
+    }
+    {
+      using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;
+      std::vector<bool, Alloc> in(205, true, Alloc(1));
+      assert(std::ranges::count(in, true) == 205);
+    }
+    {
+      using Alloc = sized_allocator<bool, std::uint64_t, std::int64_t>;
+      std::vector<bool, Alloc> in(257, true, Alloc(1));
+      assert(std::ranges::count(in, true) == 257);
+    }
+  }
 
   return true;
 }