Temporarily fix vector<bool>::operator==

Author: winner245

libcxx/include/__algorithm/equal.h

@@ -28,10 +28,6 @@
 #include <__type_traits/is_volatile.h>
 #include <__utility/move.h>
 
-#if _LIBCPP_STD_VER >= 20
-#  include <__functional/ranges_operations.h>
-#endif
-
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif

libcxx/include/__vector/comparison.h

@@ -29,6 +29,20 @@ operator==(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __
   return __sz == __y.size() && std::equal(__x.begin(), __x.end(), __y.begin());
 }
 
+// FIXME: Remove this `vector<bool>` overload once #126369 is resolved, reverting to the generic `operator==`
+// with `std::equal` for better performance.
+template <class _Allocator>
+_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI bool
+operator==(const vector<bool, _Allocator>& __x, const vector<bool, _Allocator>& __y) {
+  const typename vector<bool, _Allocator>::size_type __sz = __x.size();
+  if (__sz != __y.size())
+    return false;
+  for (typename vector<bool, _Allocator>::size_type __i = 0; __i < __sz; ++__i)
+    if (__x[__i] != __y[__i])
+      return false;
+  return true;
+}
+
 #if _LIBCPP_STD_VER <= 17
 
 template <class _Tp, class _Allocator>

libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill.pass.cpp

@@ -56,28 +56,14 @@ TEST_CONSTEXPR_CXX20 void test_bititer_with_custom_sized_types() {
     std::vector<bool, Alloc> in(100, false, Alloc(1));
     std::vector<bool, Alloc> expected(100, true, Alloc(1));
     std::fill(in.begin(), in.end(), true);
-
-    // FIXME: We are currently forced to use the standard `std::equal()` for general `input_iterator`s instead of
-    // the optimized version for `__bit_iterator`s. This is due to a recently discovered issue #126369 where the
-    // optimization fails to correctly compare `vector<bool>`s with small integral storage types. Once the issue is
-    // fixed, we should revert to the optimized version by uncommenting the last line in this code block.
-    using It = cpp17_input_iterator<std::vector<bool, Alloc>::iterator>;
-    assert(in.size() == expected.size() && std::equal(It(in.begin()), It(in.end()), It(expected.begin())));
-    // assert(in == expected); // FIXME: Uncomment this line once issue #126369 is fixed.
+    assert(in == expected);
   }
   {
     using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
     std::vector<bool, Alloc> in(200, false, Alloc(1));
     std::vector<bool, Alloc> expected(200, true, Alloc(1));
     std::fill(in.begin(), in.end(), true);
-
-    // FIXME: We are currently forced to use the standard `std::equal()` for general `input_iterator`s instead of
-    // the optimized version for `__bit_iterator`s. This is due to a recently discovered issue #126369 where the
-    // optimization fails to correctly compare `vector<bool>`s with small integral storage types. Once the issue is
-    // fixed, we should revert to the optimized version by uncommenting the last line in this code block.
-    using It = cpp17_input_iterator<std::vector<bool, Alloc>::iterator>;
-    assert(in.size() == expected.size() && std::equal(It(in.begin()), It(in.end()), It(expected.begin())));
-    // assert(in == expected); // FIXME: Uncomment this line once issue #126369 is fixed.
+    assert(in == expected);
   }
   {
     using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;

libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/fill_n.pass.cpp

@@ -117,28 +117,14 @@ TEST_CONSTEXPR_CXX20 void test_bititer_with_custom_sized_types() {
     std::vector<bool, Alloc> in(100, false, Alloc(1));
     std::vector<bool, Alloc> expected(100, true, Alloc(1));
     std::fill_n(in.begin(), in.size(), true);
-
-    // FIXME: We are currently forced to use the standard `std::equal()` for general `input_iterator`s instead of
-    // the optimized version for `__bit_iterator`s. This is due to a recently discovered issue #126369 where the
-    // optimization fails to correctly compare `vector<bool>`s with small integral storage types. Once the issue is
-    // fixed, we should revert to the optimized version by uncommenting the last line in this code block.
-    using It = cpp17_input_iterator<std::vector<bool, Alloc>::iterator>;
-    assert(in.size() == expected.size() && std::equal(It(in.begin()), It(in.end()), It(expected.begin())));
-    // assert(in == expected); // FIXME: Uncomment this line once issue #126369 is fixed.
+    assert(in == expected);
   }
   {
     using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
     std::vector<bool, Alloc> in(200, false, Alloc(1));
     std::vector<bool, Alloc> expected(200, true, Alloc(1));
     std::fill_n(in.begin(), in.size(), true);
-
-    // FIXME: We are currently forced to use the standard `std::equal()` for general `input_iterator`s instead of
-    // the optimized version for `__bit_iterator`s. This is due to a recently discovered issue #126369 where the
-    // optimization fails to correctly compare `vector<bool>`s with small integral storage types. Once the issue is
-    // fixed, we should revert to the optimized version by uncommenting the last line in this code block.
-    using It = cpp17_input_iterator<std::vector<bool, Alloc>::iterator>;
-    assert(in.size() == expected.size() && std::equal(It(in.begin()), It(in.end()), It(expected.begin())));
-    // assert(in == expected); // FIXME: Uncomment this line once issue #126369 is fixed.
+    assert(in == expected);
   }
   {
     using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;

libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill.pass.cpp

@@ -91,28 +91,14 @@ TEST_CONSTEXPR_CXX20 void test_bititer_with_custom_sized_types() {
     std::vector<bool, Alloc> in(100, false, Alloc(1));
     std::vector<bool, Alloc> expected(100, true, Alloc(1));
     std::ranges::fill(in, true);
-
-    // FIXME: We are currently forced to use the standard `std::equal()` for general `input_iterator`s instead of
-    // the optimized version for `__bit_iterator`s. This is due to a recently discovered issue #126369 where the
-    // optimization fails to correctly compare `vector<bool>`s with small integral storage types. Once the issue is
-    // fixed, we should revert to the optimized version by uncommenting the last line in this code block.
-    using It = cpp17_input_iterator<std::vector<bool, Alloc>::iterator>;
-    assert(in.size() == expected.size() && std::equal(It(in.begin()), It(in.end()), It(expected.begin())));
-    // assert(in == expected); // FIXME: Uncomment this line once issue #126369 is fixed.
+    assert(in == expected);
   }
   {
     using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
     std::vector<bool, Alloc> in(200, false, Alloc(1));
     std::vector<bool, Alloc> expected(200, true, Alloc(1));
     std::ranges::fill(in, true);
-
-    // FIXME: We are currently forced to use the standard `std::equal()` for general `input_iterator`s instead of
-    // the optimized version for `__bit_iterator`s. This is due to a recently discovered issue #126369 where the
-    // optimization fails to correctly compare `vector<bool>`s with small integral storage types. Once the issue is
-    // fixed, we should revert to the optimized version by uncommenting the last line in this code block.
-    using It = cpp17_input_iterator<std::vector<bool, Alloc>::iterator>;
-    assert(in.size() == expected.size() && std::equal(It(in.begin()), It(in.end()), It(expected.begin())));
-    // assert(in == expected); // FIXME: Uncomment this line once issue #126369 is fixed.
+    assert(in == expected);
   }
   {
     using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;

libcxx/test/std/algorithms/alg.modifying.operations/alg.fill/ranges.fill_n.pass.cpp

@@ -64,28 +64,14 @@ TEST_CONSTEXPR_CXX20 void test_bititer_with_custom_sized_types() {
     std::vector<bool, Alloc> in(100, false, Alloc(1));
     std::vector<bool, Alloc> expected(100, true, Alloc(1));
     std::ranges::fill_n(std::ranges::begin(in), in.size(), true);
-
-    // FIXME: We are currently forced to use the standard `std::equal()` for general `input_iterator`s instead of
-    // the optimized version for `__bit_iterator`s. This is due to a recently discovered issue #126369 where the
-    // optimization fails to correctly compare `vector<bool>`s with small integral storage types. Once the issue is
-    // fixed, we should revert to the optimized version by uncommenting the last line in this code block.
-    using It = cpp17_input_iterator<std::vector<bool, Alloc>::iterator>;
-    assert(in.size() == expected.size() && std::equal(It(in.begin()), It(in.end()), It(expected.begin())));
-    // assert(in == expected); // FIXME: Uncomment this line once issue #126369 is fixed.
+    assert(in == expected);
   }
   {
     using Alloc = sized_allocator<bool, std::uint16_t, std::int16_t>;
     std::vector<bool, Alloc> in(200, false, Alloc(1));
     std::vector<bool, Alloc> expected(200, true, Alloc(1));
     std::ranges::fill_n(std::ranges::begin(in), in.size(), true);
-
-    // FIXME: We are currently forced to use the standard `std::equal()` for general `input_iterator`s instead of
-    // the optimized version for `__bit_iterator`s. This is due to a recently discovered issue #126369 where the
-    // optimization fails to correctly compare `vector<bool>`s with small integral storage types. Once the issue is
-    // fixed, we should revert to the optimized version by uncommenting the last line in this code block.
-    using It = cpp17_input_iterator<std::vector<bool, Alloc>::iterator>;
-    assert(in.size() == expected.size() && std::equal(It(in.begin()), It(in.end()), It(expected.begin())));
-    // assert(in == expected); // FIXME: Uncomment this line once issue #126369 is fixed.
+    assert(in == expected);
   }
   {
     using Alloc = sized_allocator<bool, std::uint32_t, std::int32_t>;