[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

835

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?

844–858

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

835

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

844–858

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

[philnik]

libcxx/include/bitset

835

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

835

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/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|","Clang 17",""
 "`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","","",""
 "`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

 #include <__bit_reference>
 #include <__config>
 #include <__functional/hash.h>
 #include <__functional/unary_function.h>
 #include <__type_traits/is_char_like_type.h>
 #include <climits>
 #include <cstddef>
 #include <stdexcept>
+#include <string_view>
 #include <version>
 
 // standard-mandated includes
 
 // [bitset.syn]
 #include <iosfwd>
 #include <string>
 
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,
+#endif
                         _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));
+#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'));
+#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:
 
     friend struct hash<bitset>;
 };
 
 template <size_t _Size>
 template<class _CharT, class>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
 bitset<_Size>::bitset(const _CharT* __str,
+#if _LIBCPP_STD_VER >= 26
+                      typename basic_string_view<_CharT>::size_type __n,
+#else
                       typename basic_string<_CharT>::size_type __n,
+#endif
                       _CharT __zero, _CharT __one)
 {
     size_t __rlen = _VSTD::min(__n, char_traits<_CharT>::length(__str));
     for (size_t __i = 0; __i < __rlen; ++__i)
         if (__str[__i] != __zero && __str[__i] != __one)
             __throw_invalid_argument("bitset string ctor has invalid argument");
 
     size_t __mp = _VSTD::min(__rlen, _Size);
     size_t __i = 0;
     for (; __i < __mp; ++__i)
     {
         _CharT __c = __str[__mp - 1 - __i];
         (*this)[__i] = (__c == __one);
     }
     _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
 }
 
+#if _LIBCPP_STD_VER >= 26
+template <size_t _Size>
+template <class _CharT, class _Traits>
+_LIBCPP_HIDE_FROM_ABI constexpr bitset<_Size>::bitset(
+    basic_string_view<_CharT, _Traits> __str,
+    typename basic_string_view<_CharT, _Traits>::size_type __pos,
+    typename basic_string_view<_CharT, _Traits>::size_type __n,
+    _CharT __zero,
+    _CharT __one) {
+    if (__pos > __str.size())
+        __throw_out_of_range("bitset string pos out of range");
+
+    size_t __rlen = std::min(__n, __str.size() - __pos);
+    for (size_t __i = __pos; __i < __pos + __rlen; ++__i)
+        if (!_Traits::eq(__str[__i], __zero) && !_Traits::eq(__str[__i], __one))
+            __throw_invalid_argument("bitset string ctor has invalid argument");
+
+    size_t __mp = std::min(__rlen, _Size);
+    size_t __i  = 0;
+    for (; __i < __mp; ++__i) {
+        _CharT __c   = __str[__pos + __mp - 1 - __i];
+        (*this)[__i] = _Traits::eq(__c, __one);
+    }
+    std::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
+}
+#endif // _LIBCPP_STD_VER >= 26
+
 template <size_t _Size>
 template<class _CharT, class _Traits, class _Allocator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23
 bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
        typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos,
        typename basic_string<_CharT,_Traits,_Allocator>::size_type __n,
        _CharT __zero, _CharT __one)
 {

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                         202606L
 // # 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

 #     error "__cpp_lib_bitops should have the value 201907L in c++26"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_bitops
 #     error "__cpp_lib_bitops should not be defined because it is unimplemented in libc++!"
 #   endif
 # 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 [
             "values": {"c++20": 201907},
             "headers": ["bit"],
             "unimplemented": True,
         },
         {
             "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",