[libc++] Adds string_view constructor overload

[Mordante]

Summary

Implements

• P2697R1 Interfacing bitset with string_view

Depends on D153192

[Mordante]

CI fixes.

[Mordante]

Updates transitive includes.

[Mordante]

Rebased on parent.

[philnik]

libcxx/include/bitset

844

Given that we want to move away from defining member functions out-of-line, maybe we want to jut define the new functions inline directly?

853–867

I think a helper to deduplicate this code between the overloads above and below wold be a good idea. There is also some pretty obvious optimization opportunity missed by clang for this code, so maybe we can improve on it later.

[Mordante]

Rebased and update version number in status tables.

[Mordante]

Thanks for the review!

libcxx/include/bitset

844

Do we? I must have missed that message. When/where was this discussed? (I'm not objecting against it.)

853–867

I really dislike that idea in this patch. I'll create a different patch to do the refactoring first.

[philnik]

libcxx/include/bitset

844

I don't think we ever discussed this explicitly, but that's how we write every new class, so I don't see why that would be different for pre-existing classes. So I guess I'm assuming consensus on this based on how people write code.

[Mordante]

Addresses review comments.

[Mordante]

libcxx/include/bitset

844

I see. I don't object so I inlined the new constructor too.

[Mordante]

Rebased and target LLVM-18 as shipping vehicle.

[ldionne]

Thanks! LGTM w/ test comments applied.

libcxx/include/bitset

42–53

Maybe this is more explicit?

template <class charT>
        constexpr explicit bitset(const charT* str,
            typename basic_string<charT>::size_type n = basic_string<charT>::npos,
            charT zero = charT('0'), charT one = charT('1'));                                // until C++26, constexpr since C++23

template <class charT>
        constexpr explicit bitset(const charT* str,
            typename basic_string_view<charT>::size_type n = basic_string_view<charT>::npos,
            charT zero = charT('0'), charT one = charT('1'));                                // since C++26

libcxx/test/std/utilities/template.bitset/bitset.cons/string_view_ctor.pass.cpp

2

We need to add stricter tests for the default arguments. Specifically, we should be calling as

bitset(s)
bitset(s, pos)
bitset(s, pos, n)
bitset(s, pos, n, zero)
bitset(s, pos, n, zero, one)

Also, it would be great to backport these additional tests to the string and c-string constructors, since it'll be trivial to do that. I'd do it as a fly-by change in this patch.

4

We are also not testing for the explicit-ness of the constructor. We can using the !is_convertible && is_constructible check.

[Mordante]

Rebased and addresses review comments

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     **C++ 26**
     ---------------------------------------------------------------------
     ``__cpp_lib_associative_heterogeneous_insertion``   *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_bind_back``                             *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_bind_front``                            ``202306L``
     --------------------------------------------------- -----------------
-    ``__cpp_lib_bitset``                                *unimplemented*
+    ``__cpp_lib_bitset``                                ``202306L``
     --------------------------------------------------- -----------------
     ``__cpp_lib_copyable_function``                     *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_fstream_native_handle``                 *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_function_ref``                          *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_hazard_pointer``                        *unimplemented*

libcxx/docs/ReleaseNotes/17.rst

 - P2505R5 - Monadic operations for ``std::expected``
 - P2711R1 - Making Multi-Param Constructors Of views explicit (``join_with_view`` is not done yet)
 - P2572R1 - ``std::format`` fill character allowances
 - P2510R3 - Formatting pointers
 - P2136R3 - ``invoke_r``
 - P2494R2 - Relaxing range adaptors to allow for move only types
 - P2585R0 - Improving default container formatting
 - P0408R7 - Efficient Access to ``basic_stringbuf``'s Buffer
-
+- P2697R1 - Interfacing ``bitset`` with ``string_view``
 
 Improvements and New Features
 -----------------------------
 - ``std::equal``, ``std::ranges::equal``, ``std::find``, and
   ``std::ranges::find``  are now forwarding to ``std::memcmp`` for trivially
   equality comparable types, which can lead up to 40x performance improvements.
 
 - ``std::string_view`` now provides iterators that check for out-of-bounds accesses when the safe

libcxx/docs/Status/Cxx2cPapers.csv

 "`P1901R2 <https://wg21.link/P1901R2>`__","LWG","Enabling the Use of ``weak_ptr`` as Keys in Unordered Associative Containers","Varna June 2023","","",""
 "`P1885R12 <https://wg21.link/P1885R12>`__","LWG","Naming Text Encodings to Demystify Them","Varna June 2023","","",""
 "`P0792R14 <https://wg21.link/P0792R14>`__","LWG","``function_ref``: a type-erased callable reference","Varna June 2023","","",""
 "`P2874R2 <https://wg21.link/P2874R2>`__","LWG","Mandating Annex D Require No More","Varna June 2023","","",""
 "`P2757R3 <https://wg21.link/P2757R3>`__","LWG","Type-checking format args","Varna June 2023","","","|format|"
 "`P2637R3 <https://wg21.link/P2637R3>`__","LWG","Member ``visit``","Varna June 2023","","","|format|"
 "`P2641R4 <https://wg21.link/P2641R4>`__","CWG, LWG","Checking if a ``union`` alternative is active","Varna June 2023","","",""
 "`P1759R6 <https://wg21.link/P1759R6>`__","LWG","Native handles and file streams","Varna June 2023","","",""
-"`P2697R1 <https://wg21.link/P2697R1>`__","LWG","Interfacing ``bitset`` with ``string_view``","Varna June 2023","","",""
+"`P2697R1 <https://wg21.link/P2697R1>`__","LWG","Interfacing ``bitset`` with ``string_view``","Varna June 2023","|Complete|","17.0",""
 "`P1383R2 <https://wg21.link/P1383R2>`__","LWG","More ``constexpr`` for ``<cmath>`` and ``<complex>``","Varna June 2023","","",""
 "`P2734R0 <https://wg21.link/P2734R0>`__","LWG","Adding the new SI prefixes","Varna June 2023","|Complete|","17.0",""
 "`P2548R6 <https://wg21.link/P2548R6>`__","LWG","``copyable_function``","Varna June 2023","","",""
 "`P2714R1 <https://wg21.link/P2714R1>`__","LWG","Bind front and back to NTTP callables","Varna June 2023","","",""
 "`P2630R4 <https://wg21.link/P2630R4>`__","LWG","``submdspan``","Varna June 2023","","",""
 "","","","","","",""

libcxx/include/bitset

public:
         bool operator~() const noexcept;                 // flips the bit
         operator bool() const noexcept;                  // for x = b[i];
         reference& flip() noexcept;                      // for b[i].flip();
     };
 
     // 23.3.5.1 constructors:
     constexpr bitset() noexcept;
     constexpr bitset(unsigned long long val) noexcept;
     template <class charT>
-        explicit bitset(const charT* str,
-                        typename basic_string<charT>::size_type n = basic_string<charT>::npos,
-                        charT zero = charT('0'), charT one = charT('1')); // constexpr since C++23
+        constexpr explicit bitset(
+            const charT* str,
+            typename basic_string_view<charT>::size_type n = basic_string_view<charT>::npos, // s/string/string_view since C++26
+            charT zero = charT('0'), charT one = charT('1'));                                // constexpr since C++23
+    template<class charT, class traits>
+        explicit bitset(
+            const basic_string_view<charT,traits>& str,
+            typename basic_string_view<charT,traits>::size_type pos = 0,
+            typename basic_string_view<charT,traits>::size_type n = basic_string_view<charT,traits>::npos,
+            charT zero = charT('0'), charT one = charT('1'));                                // since C++26
     template<class charT, class traits, class Allocator>
-        explicit bitset(const basic_string<charT,traits,Allocator>& str,
-                        typename basic_string<charT,traits,Allocator>::size_type pos = 0,
-                        typename basic_string<charT,traits,Allocator>::size_type n =
-                                 basic_string<charT,traits,Allocator>::npos,
-                        charT zero = charT('0'), charT one = charT('1')); // constexpr since C++23
+        constexpr explicit bitset(
+            const basic_string<charT,traits,Allocator>& str,
+            typename basic_string<charT,traits,Allocator>::size_type n = basic_string<charT,traits,Allocator>::npos,
+            charT zero = charT('0'), charT one = charT('1'));                                // constexpr since C++23
 
     // 23.3.5.2 bitset operations:
     bitset& operator&=(const bitset& rhs) noexcept; // constexpr since C++23
     bitset& operator|=(const bitset& rhs) noexcept; // constexpr since C++23
     bitset& operator^=(const bitset& rhs) noexcept; // constexpr since C++23
     bitset& operator<<=(size_t pos) noexcept;       // constexpr since C++23
     bitset& operator>>=(size_t pos) noexcept;       // constexpr since C++23
     bitset& set() noexcept;                         // constexpr since C++23
public:
 
     // 23.3.5.1 constructors:
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR bitset() _NOEXCEPT {}
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
         bitset(unsigned long long __v) _NOEXCEPT : base(__v) {}
     template <class _CharT, class = __enable_if_t<_IsCharLikeType<_CharT>::value> >
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit bitset(
         const _CharT* __str,
+#  if _LIBCPP_STD_VER >= 26
+        typename basic_string_view<_CharT>::size_type __n = basic_string_view<_CharT>::npos,
+#  else
         typename basic_string<_CharT>::size_type __n = basic_string<_CharT>::npos,
-        _CharT __zero                                = _CharT('0'),
-        _CharT __one                                 = _CharT('1')) {
+#  endif
+        _CharT __zero = _CharT('0'),
+        _CharT __one  = _CharT('1')) {
 
         size_t __rlen = std::min(__n, char_traits<_CharT>::length(__str));
         __init_from_string_view(basic_string_view<_CharT>(__str, __rlen), __zero, __one);
     }
+#if _LIBCPP_STD_VER >= 26
+    template <class _CharT, class _Traits>
+    _LIBCPP_HIDE_FROM_ABI constexpr explicit bitset(
+        basic_string_view<_CharT, _Traits> __str,
+        typename basic_string_view<_CharT, _Traits>::size_type __pos = 0,
+        typename basic_string_view<_CharT, _Traits>::size_type __n   = basic_string_view<_CharT, _Traits>::npos,
+        _CharT __zero                                                = _CharT('0'),
+        _CharT __one                                                 = _CharT('1')) {
+        if (__pos > __str.size())
+            __throw_out_of_range("bitset string pos out of range");
+
+        size_t __rlen = std::min(__n, __str.size() - __pos);
+        __init_from_string_view(basic_string_view<_CharT, _Traits>(__str.data() + __pos, __rlen), __zero, __one);
+    }
+#endif
     template <class _CharT, class _Traits, class _Allocator>
     _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit bitset(
         const basic_string<_CharT, _Traits, _Allocator>& __str,
         typename basic_string<_CharT, _Traits, _Allocator>::size_type __pos = 0,
         typename basic_string<_CharT, _Traits, _Allocator>::size_type __n =
             basic_string<_CharT, _Traits, _Allocator>::npos,
         _CharT __zero = _CharT('0'),
         _CharT __one  = _CharT('1')) {
private:
 
     _LIBCPP_INLINE_VISIBILITY
     size_t __hash_code() const _NOEXCEPT {return base::__hash_code();}
 
     friend struct hash<bitset>;
 };
 
 template <size_t _Size>
 inline
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
 bitset<_Size>&
 bitset<_Size>::operator&=(const bitset& __rhs) _NOEXCEPT
 {
     base::operator&=(__rhs);
     return *this;
 }
 
 template <size_t _Size>
 inline
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
 bitset<_Size>&
 bitset<_Size>::operator|=(const bitset& __rhs) _NOEXCEPT
 {
     base::operator|=(__rhs);
     return *this;
 }
 
 template <size_t _Size>
 inline
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
 bitset<_Size>&
 bitset<_Size>::operator^=(const bitset& __rhs) _NOEXCEPT
 {
     base::operator^=(__rhs);
     return *this;
 }
 
 template <size_t _Size>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
 bitset<_Size>&

libcxx/include/version

 #endif
 
 #if _LIBCPP_STD_VER >= 26
 // # define __cpp_lib_associative_heterogeneous_insertion  202306L
 # undef  __cpp_lib_bind_back
 // # define __cpp_lib_bind_back                            202306L
 # undef  __cpp_lib_bind_front
 # define __cpp_lib_bind_front                           202306L
-// # define __cpp_lib_bitset                               202306L
+# define __cpp_lib_bitset                               202306L
 // # define __cpp_lib_copyable_function                    202306L
 // # define __cpp_lib_fstream_native_handle                202306L
 // # define __cpp_lib_function_ref                         202306L
 // # define __cpp_lib_hazard_pointer                       202306L
 # define __cpp_lib_ratio                                202306L
 // # define __cpp_lib_rcu                                  202306L
 // # define __cpp_lib_smart_ptr_owner_equality             202306L
 // # define __cpp_lib_sstream_from_string_view             202306L
 // # define __cpp_lib_submdspan                            202306L
 // # define __cpp_lib_text_encoding                        202306L
 // # define __cpp_lib_within_lifetime                      202306L
 #endif
 
 // clang-format on
 
 #endif // _LIBCPP_VERSIONH

libcxx/test/std/language.support/support.limits/support.limits.general/bitset.version.compile.pass.cpp

 #   error "__cpp_lib_constexpr_bitset should be defined in c++23"
 # endif
 # if __cpp_lib_constexpr_bitset != 202207L
 #   error "__cpp_lib_constexpr_bitset should have the value 202207L in c++23"
 # endif
 
 #elif TEST_STD_VER > 23
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bitset
-#     error "__cpp_lib_bitset should be defined in c++26"
-#   endif
-#   if __cpp_lib_bitset != 202306L
-#     error "__cpp_lib_bitset should have the value 202306L in c++26"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bitset
-#     error "__cpp_lib_bitset should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_bitset
+#   error "__cpp_lib_bitset should be defined in c++26"
+# endif
+# if __cpp_lib_bitset != 202306L
+#   error "__cpp_lib_bitset should have the value 202306L in c++26"
+# endif
 
 # ifndef __cpp_lib_constexpr_bitset
 #   error "__cpp_lib_constexpr_bitset should be defined in c++26"
 # endif
 # if __cpp_lib_constexpr_bitset != 202207L
 #   error "__cpp_lib_constexpr_bitset should have the value 202207L in c++26"
 # endif
 
 #endif // TEST_STD_VER > 23
 

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp

 
 # ifndef __cpp_lib_bitops
 #   error "__cpp_lib_bitops should be defined in c++26"
 # endif
 # if __cpp_lib_bitops != 201907L
 #   error "__cpp_lib_bitops should have the value 201907L in c++26"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_bitset
-#     error "__cpp_lib_bitset should be defined in c++26"
-#   endif
-#   if __cpp_lib_bitset != 202306L
-#     error "__cpp_lib_bitset should have the value 202306L in c++26"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_bitset
-#     error "__cpp_lib_bitset should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_bitset
+#   error "__cpp_lib_bitset should be defined in c++26"
+# endif
+# if __cpp_lib_bitset != 202306L
+#   error "__cpp_lib_bitset should have the value 202306L in c++26"
+# endif
 
 # ifndef __cpp_lib_bool_constant
 #   error "__cpp_lib_bool_constant should be defined in c++26"
 # endif
 # if __cpp_lib_bool_constant != 201505L
 #   error "__cpp_lib_bool_constant should have the value 201505L in c++26"
 # endif
 

libcxx/test/std/utilities/template.bitset/bitset.cons/char_ptr_ctor.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // template <class charT>
 //     explicit bitset(const charT* str,
-//                     typename basic_string<charT>::size_type n = basic_string<charT>::npos,
+//                     typename basic_string_view<charT>::size_type n = basic_string_view<charT>::npos, // s/string/string_view since C++26
 //                     charT zero = charT('0'), charT one = charT('1')); // constexpr since C++23
 
 #include <bitset>
 #include <cassert>
 #include <algorithm> // for 'min' and 'max'
 #include <stdexcept> // for 'invalid_argument'
 
 #include "test_macros.h"

libcxx/test/std/utilities/template.bitset/bitset.cons/string_view_ctor.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20, c++23
+
+//    template<class charT, class traits>
+//        explicit bitset(
+//            const basic_string_view<charT,traits>& str,
+//            typename basic_string_view<charT,traits>::size_type pos = 0,
+//            typename basic_string_view<charT,traits>::size_type n = basic_string_view<charT,traits>::npos,
+//            charT zero = charT('0'), charT one = charT('1'));
+
+#include <algorithm> // for 'min' and 'max'
+#include <bitset>
+#include <cassert>
+#include <stdexcept> // for 'invalid_argument'
+#include <string_view>
+#include <type_traits>
+
+#include "test_macros.h"
+
+template <std::size_t N>
+constexpr void test_string_ctor() {
+#ifndef TEST_HAS_NO_EXCEPTIONS
+  if (!TEST_IS_CONSTANT_EVALUATED) {
+    try {
+      std::string_view s("xxx1010101010xxxx");
+      std::bitset<N> v(s, s.size() + 1, 10);
+      assert(false);
+    } catch (std::out_of_range&) {
+    }
+    try {
+      std::string_view s("xxx1010101010xxxx");
+      std::bitset<N> v(s, 2, 10);
+      assert(false);
+    } catch (std::invalid_argument&) {
+    }
+    try {
+      std::string_view s("xxxbababababaxxxx");
+      std::bitset<N> v(s, 2, 10, 'a', 'b');
+      assert(false);
+    } catch (std::invalid_argument&) {
+    }
+  }
+#endif // TEST_HAS_NO_EXCEPTIONS
+  {
+    std::string_view s("xxx1010101010xxxx");
+    std::bitset<N> v(s, 3, 10);
+    std::size_t M = std::min<std::size_t>(v.size(), 10);
+    for (std::size_t i = 0; i < M; ++i)
+      assert(v[i] == (s[3 + M - 1 - i] == '1'));
+    for (std::size_t i = 10; i < v.size(); ++i)
+      assert(v[i] == false);
+  }
+  {
+    std::string_view s("xxxbababababaxxxx");
+    std::bitset<N> v(s, 3, 10, 'a', 'b');
+    std::size_t M = std::min<std::size_t>(v.size(), 10);
+    for (std::size_t i = 0; i < M; ++i)
+      assert(v[i] == (s[3 + M - 1 - i] == 'b'));
+    for (std::size_t i = 10; i < v.size(); ++i)
+      assert(v[i] == false);
+  }
+}
+
+struct Nonsense {
+  virtual ~Nonsense() {}
+};
+
+constexpr void test_for_non_eager_instantiation() {
+  // Ensure we don't accidentally instantiate `std::basic_string_view<Nonsense>`
+  // since it may not be well formed and can cause an error in the
+  // non-immediate context.
+  static_assert(!std::is_constructible<std::bitset<3>, Nonsense*>::value, "");
+  static_assert(!std::is_constructible<std::bitset<3>, Nonsense*, std::size_t, Nonsense&, Nonsense&>::value, "");
+}
+
+constexpr bool test() {
+  test_string_ctor<0>();
+  test_string_ctor<1>();
+  test_string_ctor<31>();
+  test_string_ctor<32>();
+  test_string_ctor<33>();
+  test_string_ctor<63>();
+  test_string_ctor<64>();
+  test_string_ctor<65>();
+  test_string_ctor<1000>();
+  test_for_non_eager_instantiation();
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/utils/generate_feature_test_macro_components.py

for x in [
             "name": "__cpp_lib_bitops",
             "values": {"c++20": 201907},
             "headers": ["bit"],
         },
         {
             "name": "__cpp_lib_bitset",
             "values": {"c++26": 202306}, # P2697R1 Interfacing bitset with string_view
             "headers": ["bitset"],
-            "unimplemented": True,
         },
         {
             "name": "__cpp_lib_bool_constant",
             "values": {"c++17": 201505},
             "headers": ["type_traits"],
         },
         {
             "name": "__cpp_lib_bounded_array_traits",