[libc++] Remove the constexpr hash<vector<bool>> extension (llvm#132617)

libc++ makes the `hash<vector<bool, A>>::operator()` `constexpr` since
C++20, which is a conforming extension, but it was unintended.

This patch removes the extension, with an escape hatch macro for it, and
the escape hatch will be removed in the future. Test cases for
`constexpr` along with the assumption of hash values are moved to the
`libcxx/test/libcxx/` subdirectory.

---------

Co-authored-by: Louis Dionne <[email protected]>

Author: frederick-vs-ja

libcxx/docs/ReleaseNotes/21.rst

@@ -80,6 +80,9 @@ Deprecations and Removals
 - The ``_LIBCPP_VERBOSE_ABORT_NOT_NOEXCEPT`` has been removed, making ``std::__libcpp_verbose_abort``
   unconditionally ``noexcept``.
 
+- libc++ no longer adds ``constexpr`` to ``std::hash<std::vector<bool, A>>::operator()``, as the ``constexpr`` addition
+  since C++20 was an unintended extension.
+
 - TODO: The non-conforming extension ``packaged_task::result_type`` has been removed in LLVM 21.
 
 Potentially breaking changes

libcxx/include/__vector/vector_bool.h

@@ -512,7 +512,7 @@ class vector<bool, _Allocator> {
 
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __move_assign_alloc(vector&, false_type) _NOEXCEPT {}
 
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_t __hash_code() const _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI size_t __hash_code() const _NOEXCEPT;
 
   friend class __bit_reference<vector>;
   friend class __bit_const_reference<vector>;
@@ -1093,7 +1093,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 bool vector<bool, _Allocator>::__invariants() cons
 }
 
 template <class _Allocator>
-_LIBCPP_CONSTEXPR_SINCE_CXX20 size_t vector<bool, _Allocator>::__hash_code() const _NOEXCEPT {
+size_t vector<bool, _Allocator>::__hash_code() const _NOEXCEPT {
   size_t __h = 0;
   // do middle whole words
   size_type __n         = __size_;
@@ -1110,8 +1110,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 size_t vector<bool, _Allocator>::__hash_code() con
 
 template <class _Allocator>
 struct hash<vector<bool, _Allocator> > : public __unary_function<vector<bool, _Allocator>, size_t> {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_t
-  operator()(const vector<bool, _Allocator>& __vec) const _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const vector<bool, _Allocator>& __vec) const _NOEXCEPT {
     return __vec.__hash_code();
   }
 };

libcxx/test/std/containers/sequences/vector.bool/enabled_hash.pass.cpp

@@ -19,19 +19,14 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-TEST_CONSTEXPR_CXX20 bool test() {
+void test() {
   test_hash_enabled<std::vector<bool> >();
   test_hash_enabled<std::vector<bool, min_allocator<bool>>>();
-
-  return true;
 }
 
 int main(int, char**) {
   test_library_hash_specializations_available();
   test();
-#if TEST_STD_VER > 17
-  static_assert(test());
-#endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/vector.bool/vector_bool.pass.cpp

@@ -14,8 +14,6 @@
 //     size_t operator()(T val) const;
 // };
 
-// Not very portable
-
 #include <vector>
 #include <cassert>
 #include <iterator>
@@ -24,35 +22,29 @@
 #include "test_macros.h"
 #include "min_allocator.h"
 
-TEST_CONSTEXPR_CXX20 bool tests() {
-  {
-    typedef std::vector<bool> T;
-    typedef std::hash<T> H;
+template <class VB>
+TEST_CONSTEXPR_CXX20 void test() {
+  typedef std::hash<VB> H;
 #if TEST_STD_VER <= 14
-    static_assert((std::is_same<H::argument_type, T>::value), "");
-    static_assert((std::is_same<H::result_type, std::size_t>::value), "");
+  static_assert((std::is_same<typename H::argument_type, VB>::value), "");
+  static_assert((std::is_same<typename H::result_type, std::size_t>::value), "");
 #endif
-    ASSERT_NOEXCEPT(H()(T()));
-
-    bool ba[] = {true, false, true, true, false};
-    T vb(std::begin(ba), std::end(ba));
-    H h;
-    assert(h(vb) != 0);
+  ASSERT_NOEXCEPT(H()(VB()));
+
+  bool ba[] = {true, false, true, true, false};
+  VB vb(std::begin(ba), std::end(ba));
+  H h;
+  if (!TEST_IS_CONSTANT_EVALUATED) {
+    const std::size_t hash_value = h(vb);
+    assert(h(vb) == hash_value);
+    LIBCPP_ASSERT(hash_value != 0);
   }
+}
+
+TEST_CONSTEXPR_CXX20 bool tests() {
+  test<std::vector<bool> >();
 #if TEST_STD_VER >= 11
-  {
-    typedef std::vector<bool, min_allocator<bool>> T;
-    typedef std::hash<T> H;
-#  if TEST_STD_VER <= 14
-    static_assert((std::is_same<H::argument_type, T>::value), "");
-    static_assert((std::is_same<H::result_type, std::size_t>::value), "");
-#  endif
-    ASSERT_NOEXCEPT(H()(T()));
-    bool ba[] = {true, false, true, true, false};
-    T vb(std::begin(ba), std::end(ba));
-    H h;
-    assert(h(vb) != 0);
-  }
+  test<std::vector<bool, min_allocator<bool>>>();
 #endif
 
   return true;