[libc++] Make charconv require C++17 or later.

[Mordante]

Summary

Implementing the paper
P2291R3 Add Constexpr Modifiers to Functions to_chars and from_chars for

Integral Types in <charconv> Header

Gives issues in language versions prior to C++17. As suggested in
D131855 disable the code prior to C++17. This removes libc++'s
extension.

[Mordante]

Rebased and changed XFAIL to UNSUPPORTED as it should be.

[ldionne]

We would need to add a release note.

[ldionne]

Note to self: 100513369

[ldionne]

I do not foresee this being a big issue. I didn't find any instances of code breaking internally, which should give a rough idea that this is not a super commonly relied on extension.

[Mordante]

Rebased and updates release notes.

[philnik]

I think it's a good idea, but this is ultimately a vendor question, so I'll leave final approval to Louis.

[ldionne]

In D133216#3834376, @philnik wrote:

I think it's a good idea, but this is ultimately a vendor question, so I'll leave final approval to Louis.

I did an internal survey and couldn't find any uses of the extension. It doesn't mean that it'll break zero code, but I don't think it's going to be a big deal (for instance the removal of binary_function and unary_function was much more disruptive but we still did it).

libcxx/docs/ReleaseNotes.rst

83–84

libcxx/docs/ReleaseNotes.rst

- Several incidental transitive includes have been removed from libc++. Those
   incidental transitive includes more aggressively, in particular regardless
   of the language version in use.
 
 - The legacy testing system for libc++, libc++abi and libunwind has been removed.
   All known clients have been migrated to the new configuration system, but please
   reach out to the libc++ developers if you find something missing in the new
   configuration system.
 
+- The functions ``to_chars`` and ``from_chars`` for integral types are
+  available starting with C++17. Libc++ offered these functions in C++11 and
+  C++14 as an undocumented extension. This extension makes it hard to implement
+  the C++23 paper that makes these functions ``constexpr``. Therefore extension
+  has been removed.
+
 Upcoming Deprecations and Removals
 ----------------------------------
 
 API Changes
 -----------
 - The comparison operators on ``thread::id`` are now defined as free-standing
   functions instead of as hidden friends, in conformance with the C++ standard.
   Also see `issue 56187 <https://github.com/llvm/llvm-project/issues/56187>`_.

libcxx/include/__charconv/chars_format.h

 #include <__utility/to_underlying.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER > 14
 
 enum class _LIBCPP_ENUM_VIS chars_format
 {
     scientific = 0x1,
     fixed = 0x2,
     hex = 0x4,
     general = fixed | scientific
 };

 }
 
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX14 chars_format&
 operator^=(chars_format& __x, chars_format __y) {
   __x = __x ^ __y;
   return __x;
 }
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___CHARCONV_CHARS_FORMAT_H

libcxx/include/__charconv/from_chars_result.h

 #include <__errc>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER > 14
 
 struct _LIBCPP_TYPE_VIS from_chars_result
 {
     const char* ptr;
     errc ec;
 #  if _LIBCPP_STD_VER > 17
     _LIBCPP_HIDE_FROM_ABI friend bool operator==(const from_chars_result&, const from_chars_result&) = default;
 #  endif
 };
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___CHARCONV_FROM_CHARS_RESULT_H

libcxx/include/__charconv/tables.h

 #include <cstdint>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER > 14
 
 namespace __itoa {
 
 /// Contains the charconv helper tables.
 ///
 /// In C++17 these could be inline constexpr variable, but libc++ supports
 /// charconv for integrals in C++11 mode.
 template <class = void>
const char __table<_Tp>::__digits_base_10[200] = {
     '6', '0', '6', '1', '6', '2', '6', '3', '6', '4', '6', '5', '6', '6', '6', '7', '6', '8', '6', '9',
     '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '7', '5', '7', '6', '7', '7', '7', '8', '7', '9',
     '8', '0', '8', '1', '8', '2', '8', '3', '8', '4', '8', '5', '8', '6', '8', '7', '8', '8', '8', '9',
     '9', '0', '9', '1', '9', '2', '9', '3', '9', '4', '9', '5', '9', '6', '9', '7', '9', '8', '9', '9'};
 // clang-format on
 
 } // namespace __itoa
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___CHARCONV_TABLES

libcxx/include/__charconv/to_chars_base_10.h

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER > 14
 
 namespace __itoa {
 
 _LIBCPP_HIDE_FROM_ABI inline char* __append1(char* __first, uint32_t __value) noexcept {
   *__first = '0' + static_cast<char>(__value);
   return __first + 1;
 }
 
_LIBCPP_HIDE_FROM_ABI inline char* __base_10_u128(char* __buffer, __uint128_t __value) noexcept {
   __buffer = __itoa::__append9(__buffer, static_cast<uint32_t>(__value / 10000000000));
   __buffer = __itoa::__append10(__buffer, static_cast<uint64_t>(__value % 10000000000));
 
   return __buffer;
 }
 #  endif
 } // namespace __itoa
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP___CHARCONV_TO_CHARS_BASE_10_H

libcxx/include/__charconv/to_chars_result.h

 #include <__errc>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER > 14
 
 struct _LIBCPP_TYPE_VIS to_chars_result
 {
     char* ptr;
     errc ec;
 #  if _LIBCPP_STD_VER > 17
     _LIBCPP_HIDE_FROM_ABI friend bool operator==(const to_chars_result&, const to_chars_result&) = default;
 #  endif
 };
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___CHARCONV_TO_CHARS_RESULT_H

libcxx/include/charconv

 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER > 14
 
 to_chars_result to_chars(char*, char*, bool, int = 10) = delete;
 from_chars_result from_chars(const char*, const char*, bool, int = 10) = delete;
 
 namespace __itoa
 {
 
 template <typename _Tp, typename = void>

 template <typename _Tp, typename enable_if<is_integral<_Tp>::value, int>::type = 0>
 inline _LIBCPP_HIDE_FROM_ABI from_chars_result
 from_chars(const char* __first, const char* __last, _Tp& __value, int __base)
 {
     _LIBCPP_ASSERT(2 <= __base && __base <= 36, "base not in [2, 36]");
     return __from_chars_integral(__first, __last, __value, __base);
 }
 
-// Floating-point implementation starts here.
-// Unlike the other parts of charconv this is only available in C++17 and newer.
-#if _LIBCPP_STD_VER > 14
-
 _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS
 to_chars_result to_chars(char* __first, char* __last, float __value);
 
 _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS
 to_chars_result to_chars(char* __first, char* __last, double __value);
 
 _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS
 to_chars_result to_chars(char* __first, char* __last, long double __value);

 to_chars_result to_chars(char* __first, char* __last, float __value, chars_format __fmt, int __precision);
 
 _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS
 to_chars_result to_chars(char* __first, char* __last, double __value, chars_format __fmt, int __precision);
 
 _LIBCPP_AVAILABILITY_TO_CHARS_FLOATING_POINT _LIBCPP_FUNC_VIS
 to_chars_result to_chars(char* __first, char* __last, long double __value, chars_format __fmt, int __precision);
 
-#  endif // _LIBCPP_STD_VER > 14
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER > 14
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <iosfwd>
 #endif
 
 #endif // _LIBCPP_CHARCONV

libcxx/test/std/utilities/charconv/charconv.from.chars/integral.bool.fail.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
-// UNSUPPORTED: !stdlib=libc++ && c++11
-// UNSUPPORTED: !stdlib=libc++ && c++14
+// UNSUPPORTED: c++03, c++11, c++14
+
 // <charconv>
 
 // In
 //
 // from_chars_result from_chars(const char* first, const char* last,
 //                              Integral& value, int base = 10)
 //
 // Integral cannot be bool.

libcxx/test/std/utilities/charconv/charconv.from.chars/integral.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
-// UNSUPPORTED: !stdlib=libc++ && c++11
-// UNSUPPORTED: !stdlib=libc++ && c++14
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <charconv>
 
 // from_chars_result from_chars(const char* first, const char* last,
 //                              Integral& value, int base = 10)
 
 #include <charconv>
 #include "test_macros.h"

libcxx/test/std/utilities/charconv/charconv.from.chars/integral.roundtrip.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
-// UNSUPPORTED: !stdlib=libc++ && c++11
-// UNSUPPORTED: !stdlib=libc++ && c++14
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <charconv>
 
 // from_chars_result from_chars(const char* first, const char* last,
 //                              Integral& value, int base = 10)
 
 #include <charconv>
 #include "test_macros.h"

libcxx/test/std/utilities/charconv/charconv.syn/chars_format.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
 //
 //===----------------------------------------------------------------------===//
 
-// Note: chars_format is a C++17 feature backported to C++11. Assert isn't
-// allowed in a constexpr function in C++11. To keep the code readable, C++11
-// support is untested.
-// UNSUPPORTED: c++03, c++11
+// UNSUPPORTED: c++03, c++11, c++14
 
 // <charconv>
 
 // Bitmask type
 // enum class chars_format {
 //   scientific = unspecified,
 //   fixed = unspecified,
 //   hex = unspecified,

libcxx/test/std/utilities/charconv/charconv.to.chars/integral.bool.fail.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
-// UNSUPPORTED: !stdlib=libc++ && c++11
-// UNSUPPORTED: !stdlib=libc++ && c++14
+// UNSUPPORTED: c++03, c++11, c++14
+
 // <charconv>
 
 // In
 //
 // to_chars_result to_chars(char* first, char* last, Integral value,
 //                          int base = 10)
 //
 // Integral cannot be bool.

libcxx/test/std/utilities/charconv/charconv.to.chars/integral.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
-// UNSUPPORTED: !stdlib=libc++ && c++11
-// UNSUPPORTED: !stdlib=libc++ && c++14
+// UNSUPPORTED: c++03, c++11, c++14
 
 // ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-steps): -fconstexpr-steps=12712420
 // ADDITIONAL_COMPILE_FLAGS(has-fconstexpr-ops-limit): -fconstexpr-ops-limit=12712420
 
 // <charconv>
 
 // to_chars_result to_chars(char* first, char* last, Integral value,
 //                          int base = 10)