[libc++][charconv] Adds operator bool.

[Mordante]

Summary

Implements

• P2497R0 Testing for success or failure of <charconv> functions

Depends on D153192

[Mordante]

Rebased on dependency.

[Mordante]

CI fixes.

[Mordante]

Rebased and update status table.

[Mordante]

Rebased to test CI.

[Mordante]

Rebased since main was broken.

[Mordante]

Rebased and target LLVM-18 as shipping vehicle.

[ldionne]

LGTM w/ comments and CI!

libcxx/test/std/utilities/charconv/charconv.syn/from_chars_result.operator_bool.verify.cpp

20

I would suggest instead doing

static_assert(!std::is_convertible<std::from_chars_result, bool>::value);
static_assert( std::is_constructible<bool, std::from_chars_result>::value);

This way we are also testing that this is SFINAE-friendly, which tests explicit more tightly than if we check for the error. We also decouple from the error message and we're able to merge this test into the .pass.cpp test you added.

[Mordante]

Rebased and address review comments.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_smart_ptr_owner_equality``              *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_sstream_from_string_view``              *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_submdspan``                             *unimplemented*
     --------------------------------------------------- -----------------
     ``__cpp_lib_text_encoding``                         *unimplemented*
     --------------------------------------------------- -----------------
+    ``__cpp_lib_to_chars``                              *unimplemented*
+    --------------------------------------------------- -----------------
     ``__cpp_lib_within_lifetime``                       *unimplemented*
     =================================================== =================
 

libcxx/docs/Status/Cxx2cPapers.csv

 "Paper #","Group","Paper Name","Meeting","Status","First released version","Labels"
-"`P2497R0 <https://wg21.link/P2497R0>`__","LWG","Testing for success or failure of ``<charconv>`` functions","Varna June 2023","","",""
+"`P2497R0 <https://wg21.link/P2497R0>`__","LWG","Testing for success or failure of ``<charconv>`` functions","Varna June 2023","|Complete|","17.0",""
 "`P2592R3 <https://wg21.link/P2592R3>`__","LWG","Hashing support for ``std::chrono`` value classes","Varna June 2023","","",""
 "`P2587R3 <https://wg21.link/P2587R3>`__","LWG","``to_string`` or not ``to_string``","Varna June 2023","","","|format|"
 "`P2562R1 <https://wg21.link/P2562R1>`__","LWG","``constexpr`` Stable Sorting","Varna June 2023","","",""
 "`P2545R4 <https://wg21.link/P2545R4>`__","LWG","Read-Copy Update (RCU)","Varna June 2023","","",""
 "`P2530R3 <https://wg21.link/P2530R3>`__","LWG","Hazard Pointers for C++26","Varna June 2023","","",""
 "`P2538R1 <https://wg21.link/P2538R1>`__","LWG","ADL-proof ``std::projected``","Varna June 2023","","","|ranges|"
 "`P2495R3 <https://wg21.link/P2495R3>`__","LWG","Interfacing ``stringstreams`` with ``string_view``","Varna June 2023","","",""
 "`P2510R3 <https://wg21.link/P2510R3>`__","LWG","Formatting pointers","Varna June 2023","|Complete| [#note-P2510R3]_","17.0","|format|"

libcxx/include/__charconv/from_chars_result.h

 #if _LIBCPP_STD_VER >= 17
 
 struct _LIBCPP_EXPORTED_FROM_ABI from_chars_result {
   const char* ptr;
   errc ec;
 #  if _LIBCPP_STD_VER >= 20
   _LIBCPP_HIDE_FROM_ABI friend bool operator==(const from_chars_result&, const from_chars_result&) = default;
 #  endif
+#  if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return ec == errc{}; }
+#  endif
 };
 
 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___CHARCONV_FROM_CHARS_RESULT_H

libcxx/include/__charconv/to_chars_result.h

 #if _LIBCPP_STD_VER >= 17
 
 struct _LIBCPP_EXPORTED_FROM_ABI to_chars_result {
   char* ptr;
   errc ec;
 #  if _LIBCPP_STD_VER >= 20
   _LIBCPP_HIDE_FROM_ABI friend bool operator==(const to_chars_result&, const to_chars_result&) = default;
 #  endif
+#  if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return ec == errc{}; }
+#  endif
 };
 
 #endif // _LIBCPP_STD_VER >= 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___CHARCONV_TO_CHARS_RESULT_H

libcxx/include/charconv

enum class chars_format {
     general = fixed | scientific
   };
 
   // 23.20.2, primitive numerical output conversion
   struct to_chars_result {
     char* ptr;
     errc ec;
     friend bool operator==(const to_chars_result&, const to_chars_result&) = default; // since C++20
+    constexpr explicit operator bool() const noexcept { return ec == errc{}; }        // since C++26
   };
 
   constexpr to_chars_result to_chars(char* first, char* last, see below value,
                                      int base = 10);                                  // constexpr since C++23
   to_chars_result to_chars(char* first, char* last, bool value,
                            int base = 10) = delete;
 
   to_chars_result to_chars(char* first, char* last, float value);
namespace std {
   to_chars_result to_chars(char* first, char* last, long double value,
                            chars_format fmt, int precision);
 
   // 23.20.3, primitive numerical input conversion
   struct from_chars_result {
     const char* ptr;
     errc ec;
     friend bool operator==(const from_chars_result&, const from_chars_result&) = default; // since C++20
+    constexpr explicit operator bool() const noexcept { return ec == errc{}; }            // since C++26
   };
 
   constexpr from_chars_result from_chars(const char* first, const char* last,
                                see below& value, int base = 10);                         // constexpr since C++23
 
 } // namespace std
 
 */

libcxx/include/version

 __cpp_lib_string_view                                   201803L <string> <string_view>
                                                         201606L // C++17
 __cpp_lib_submdspan                                     202306L <mdspan>
 __cpp_lib_syncbuf                                       201803L <syncstream>
 __cpp_lib_text_encoding                                 202306L <text_encoding>
 __cpp_lib_three_way_comparison                          201907L <compare>
 __cpp_lib_to_address                                    201711L <memory>
 __cpp_lib_to_array                                      201907L <array>
-__cpp_lib_to_chars                                      201611L <charconv>
+__cpp_lib_to_chars                                      202306L <charconv>
+                                                        201611L // C++17
 __cpp_lib_to_string                                     202306L <string>
 __cpp_lib_to_underlying                                 202102L <utility>
 __cpp_lib_transformation_trait_aliases                  201304L <type_traits>
 __cpp_lib_transparent_operators                         201510L <functional> <memory>
                                                         201210L // C++14
 __cpp_lib_tuple_element_t                               201402L <tuple>
 __cpp_lib_tuples_by_type                                201304L <tuple> <utility>
 __cpp_lib_type_identity                                 201806L <type_traits>

 // # 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
+# undef  __cpp_lib_to_chars
+// # define __cpp_lib_to_chars                             202306L
 // # define __cpp_lib_within_lifetime                      202306L
 #endif
 
 // clang-format on
 
 #endif // _LIBCPP_VERSIONH

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

 
 // <charconv>
 
 // Test the feature test macros defined by <charconv>
 
 /*  Constant                        Value
     __cpp_lib_constexpr_charconv    202207L [C++23]
     __cpp_lib_to_chars              201611L [C++17]
+                                    202306L [C++26]
 */
 
 #include <charconv>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_constexpr_charconv

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

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

__cpp_lib_string_view                            201606L [C++17]
                                                      201803L [C++20]
     __cpp_lib_submdspan                              202306L [C++26]
     __cpp_lib_syncbuf                                201803L [C++20]
     __cpp_lib_text_encoding                          202306L [C++26]
     __cpp_lib_three_way_comparison                   201907L [C++20]
     __cpp_lib_to_address                             201711L [C++20]
     __cpp_lib_to_array                               201907L [C++20]
     __cpp_lib_to_chars                               201611L [C++17]
+                                                     202306L [C++26]
     __cpp_lib_to_string                              202306L [C++23]
     __cpp_lib_to_underlying                          202102L [C++23]
     __cpp_lib_transformation_trait_aliases           201304L [C++14]
     __cpp_lib_transparent_operators                  201210L [C++14]
                                                      201510L [C++17]
     __cpp_lib_tuple_element_t                        201402L [C++14]
     __cpp_lib_tuples_by_type                         201304L [C++14]
     __cpp_lib_type_identity                          201806L [C++20]

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

libcxx/test/std/utilities/charconv/charconv.syn/from_chars_result.operator_bool.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
+
+// <charconv>
+
+// struct from_chars_result
+//   constexpr explicit operator bool() const noexcept { return ec == errc{}; }
+
+#include <charconv>
+
+#include <cassert>
+
+#include "test_macros.h"
+
+constexpr bool test() {
+  // True
+  {
+    std::from_chars_result value{nullptr, std::errc{}};
+    assert(bool(value) == true);
+    static_assert(noexcept(bool(true)) == true);
+  }
+  // False
+  {
+    std::from_chars_result value{nullptr, std::errc::value_too_large};
+    assert(bool(value) == false);
+    static_assert(noexcept(bool(true)) == true);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  assert(test());
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/charconv/charconv.syn/from_chars_result.operator_bool.verify.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
+
+// <charconv>
+
+// struct from_chars_result
+//   constexpr explicit operator bool() const noexcept { return ec == errc{}; }
+
+#include <charconv>
+
+void test() {
+  // expected-error@+1 {{no viable conversion from 'std::from_chars_result' to 'bool'}}
+  [[maybe_unused]] bool implicit = std::from_chars_result{nullptr, std::errc{}};
+  if (std::from_chars_result{nullptr, std::errc{}}) {
+  }
+}

libcxx/test/std/utilities/charconv/charconv.syn/to_chars_result.operator_bool.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
+
+// <charconv>
+
+// struct to_chars_result
+//   constexpr explicit operator bool() const noexcept { return ec == errc{}; }
+
+#include <charconv>
+
+#include <cassert>
+
+#include "test_macros.h"
+
+constexpr bool test() {
+  // True
+  {
+    std::to_chars_result value{nullptr, std::errc{}};
+    assert(bool(value) == true);
+    static_assert(noexcept(bool(true)) == true);
+  }
+  // False
+  {
+    std::to_chars_result value{nullptr, std::errc::value_too_large};
+    assert(bool(value) == false);
+    static_assert(noexcept(bool(true)) == true);
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  assert(test());
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/utilities/charconv/charconv.syn/to_chars_result.operator_bool.verify.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
+
+// <charconv>
+
+// struct to_chars_result
+//   constexpr explicit operator bool() const noexcept { return ec == errc{}; }
+
+#include <charconv>
+
+void test() {
+  // expected-error@+1 {{no viable conversion from 'std::to_chars_result' to 'bool'}}
+  [[maybe_unused]] bool implicit = std::to_chars_result{nullptr, std::errc{}};
+  if (std::to_chars_result{nullptr, std::errc{}}) {
+  }
+}

libcxx/utils/generate_feature_test_macro_components.py

for x in [
             "name": "__cpp_lib_to_array",
             "values": {"c++20": 201907},
             "headers": ["array"],
         },
         {
             "name": "__cpp_lib_to_chars",
             "values": {
                          "c++17": 201611,
-                         #"c++26: 202306, # P2497R0 Testing for success or failure of <charconv> functions
+                         "c++26": 202306, # P2497R0 Testing for success or failure of <charconv> functions
                       },
             "headers": ["charconv"],
             "unimplemented": True,
         },
         {
             "name": "__cpp_lib_to_string",
             "values": {"c++23": 202306}, # P2587R3 to_string or not to_string
             "headers": ["string"],