[libc++] Implement P1423R3 (char8_t backward compatibility remediation)

[Mordante]

I like to see what happens in the CI. It's a bit curious no existing tests seem to be broken.

libcxx/docs/Status/Cxx20Papers.csv

118

Make sure to set the proper version number before landing.

libcxx/include/ostream

1130

Please update the synopsis.

1132

Next time for reviewing it would be easier to use the same order as the paper.

1164

This char8_t needs to be guarded.

1172

These wchar_t need to be guarded.

libcxx/test/std/input.output/iostream.format/output.streams/ostream/deleted_output_functions.verify.cpp

9

This should be restricted to version 20 and newer.

22–23

For clarity I would prefer and similar changes to other tests.

[h-vetinari]

Though you probably know, there's yet another DR on top of P1423 that has been accepted (only missing plenary vote): https://github.com/cplusplus/papers/issues/1171

Might be worth investigating to not needlessly introduce breakage that will then have to be undone again.

[philnik]

• Address comments

libcxx/include/ostream

1132

I first put it in the same order as in the paper, but that would have meant 3x the amount preprocessor directives, which would be a lot less readable in the long term IMO.

libcxx/test/std/input.output/iostream.format/output.streams/ostream/deleted_output_functions.verify.cpp

22–23

I think explicitly naming the types makes it a lot clearer. I have to think a lot harder to know what u8, u, U and L mean (I actually had to look these up).

[philnik]

In D129195#3650796, @h-vetinari wrote:

Though you probably know, there's yet another DR on top of P1423 that has been accepted (only missing plenary vote): https://github.com/cplusplus/papers/issues/1171

Might be worth investigating to not needlessly introduce breakage that will then have to be undone again.

The paper you linked only changes core wording, so it shouldn't make any difference for the library part. Or am I missing something?

[h-vetinari]

In D129195#3652046, @philnik wrote:

In D129195#3650796, @h-vetinari wrote:

Though you probably know, there's yet another DR on top of P1423 that has been accepted (only missing plenary vote): https://github.com/cplusplus/papers/issues/1171

Might be worth investigating to not needlessly introduce breakage that will then have to be undone again.

The paper you linked only changes core wording, so it shouldn't make any difference for the library part. Or am I missing something?

It's more likely me who missed something, but I just thought I'd point out that paper since it builds on top of P1423 and also bumps that feature macro AFAICT.

[Mordante]

SGTM, but I like to have a quick look after the CI passes. Feel free to ping me on Discord when the CI is green.

libcxx/include/ostream

1132

That might be true, I can only say that when I would see that version. But at least the synopsis was a breeze to review :-)

libcxx/test/std/input.output/iostream.format/output.streams/ostream/deleted_output_functions.verify.cpp

21–22

I expect that is cause of the CI failures, but I guess you need to use more guards since sw is used unguarded below.

22–23

For me it's exactly the other way around, for these types I have to look at a lot of "noise" to see the type. But I don't feel this is wrong so feel free to keep it as-is unless other reviews also prefer L and friends.

24

Mainly curious, but will std::declval<wchar_t*>(); be valid? I expect it will.

[philnik]

• Address comments

libcxx/test/std/input.output/iostream.format/output.streams/ostream/deleted_output_functions.verify.cpp

24

No it isn't valid. The deleted const wchar_t* overload is the best match.

[Mordante]

LGTM with one question. Please make sure to update the version number before landing.

libcxx/test/std/input.output/iostream.format/output.streams/ostream/deleted_output_functions.verify.cpp

24

How do you feel about adding explicit test cases?

[philnik]

• Address comments

libcxx/test/std/input.output/iostream.format/output.streams/ostream/deleted_output_functions.verify.cpp

24

Sure, I don't expect CharT* and const CharT* to ever have different behaviour. I think that would be very surprising.

[Mordante]

libcxx/test/std/input.output/iostream.format/output.streams/ostream/deleted_output_functions.verify.cpp

24

The Standard has some hidden gems where the const matters ;-)
https://cplusplus.github.io/LWG/issue3701

But generally I agree.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_bind_front``                          ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_bit_cast``                            ``201806L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_bitops``                              *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_bounded_array_traits``                ``201902L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_char8_t``                             ``201811L``
+    ``__cpp_lib_char8_t``                             ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_concepts``                            ``202002L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_algorithms``                ``201806L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_complex``                   *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_dynamic_alloc``             ``201907L``

libcxx/docs/ReleaseNotes.rst

 - P1165R1 (Make stateful allocator propagation more consistent for ``operator+(basic_string)``)
 - P0674R1 (Support arrays in ``make_shared`` and ``allocate_shared``)
 - P0980R1 (Making ``std::string`` constexpr)
 - P2216R3 (std::format improvements)
 - P0174R2 (Deprecating Vestigial Library Parts in C++17)
 - N4190 (Removing auto_ptr, random_shuffle(), And Old <functional> Stuff)
 - P0154R1 (Hardware inference size)
 - P0618R0 (Deprecating <codecvt>)
+- P1423R3 (char8_t backward compatibility remediation)
 
 - Marked the following papers as "Complete" (note that some of those might have
   been implemented in a previous release but not marked as such):
 
     - P1207R4 (Movability of Single-pass Iterators);
     - P1474R1 (Helpful pointers for ``ContiguousIterator``);
     - P1522R1 (Iterator Difference Type and Integer Overflow);
     - P1523R1 (Views and Size Types);

libcxx/docs/Status/Cxx20Papers.csv

 "`P1004R2 <https://wg21.link/P1004R2>`__","LWG","Making std::vector constexpr","Cologne","",""
 "`P1035R7 <https://wg21.link/P1035R7>`__","LWG","Input Range Adaptors","Cologne","",""
 "`P1065R2 <https://wg21.link/P1065R2>`__","LWG","Constexpr INVOKE","Cologne","|Complete|","12.0"
 "`P1135R6 <https://wg21.link/P1135R6>`__","LWG","The C++20 Synchronization Library","Cologne","|Complete|","11.0"
 "`P1207R4 <https://wg21.link/P1207R4>`__","LWG","Movability of Single-pass Iterators","Cologne","|Complete|","15.0"
 "`P1208R6 <https://wg21.link/P1208R6>`__","LWG","Adopt source_location for C++20","Cologne","",""
 "`P1355R2 <https://wg21.link/P1355R2>`__","LWG","Exposing a narrow contract for ceil2","Cologne","|Complete|","9.0"
 "`P1361R2 <https://wg21.link/P1361R2>`__","LWG","Integration of chrono with text formatting","Cologne","",""
-"`P1423R3 <https://wg21.link/P1423R3>`__","LWG","char8_t backward compatibility remediation","Cologne","|In Progress|",""
+"`P1423R3 <https://wg21.link/P1423R3>`__","LWG","char8_t backward compatibility remediation","Cologne","|Complete|",""
 "`P1424R1 <https://wg21.link/P1424R1>`__","LWG","'constexpr' feature macro concerns","Cologne","Superseded by `P1902 <https://wg21.link/P1902>`__",""
 "`P1466R3 <https://wg21.link/P1466R3>`__","LWG","Miscellaneous minor fixes for chrono","Cologne","",""
 "`P1474R1 <https://wg21.link/P1474R1>`__","LWG","Helpful pointers for ContiguousIterator","Cologne","|Complete|","15.0"
 "`P1502R1 <https://wg21.link/P1502R1>`__","LWG","Standard library header units for C++20","Cologne","",""
 "`P1522R1 <https://wg21.link/P1522R1>`__","LWG","Iterator Difference Type and Integer Overflow","Cologne","|Complete|","15.0"
 "`P1523R1 <https://wg21.link/P1523R1>`__","LWG","Views and Size Types","Cologne","|Complete|","15.0"
 "`P1612R1 <https://wg21.link/P1612R1>`__","LWG","Relocate Endian's Specification","Cologne","|Complete|","10.0"
 "`P1614R2 <https://wg21.link/P1614R2>`__","LWG","The Mothership has Landed","Cologne","|In Progress|",""

libcxx/include/ostream

 
 template <class charT, class traits>
   basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os);
 
 // rvalue stream insertion
 template <class Stream, class T>
   Stream&& operator<<(Stream&& os, const T& x);
 
+template<class traits>
+basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, wchar_t) = delete;               // since C++20
+template<class traits>
+basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char8_t) = delete;               // since C++20
+template<class traits>
+basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char16_t) = delete;              // since C++20
+template<class traits>
+basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, char32_t) = delete;              // since C++20
+template<class traits>
+basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, char8_t) = delete;         // since C++20
+template<class traits>
+basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, char16_t) = delete;        // since C++20
+template<class traits>
+basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, char32_t) = delete;        // since C++20
+template<class traits>
+basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const wchar_t*) = delete;        // since C++20
+template<class traits>
+basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char8_t*) = delete;        // since C++20
+template<class traits>
+basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char16_t*) = delete;       // since C++20
+template<class traits>
+basic_ostream<char, traits>& operator<<(basic_ostream<char, traits>&, const char32_t*) = delete;       // since C++20
+template<class traits>
+basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char8_t*) = delete;  // since C++20
+template<class traits>
+basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char16_t*) = delete; // since C++20
+template<class traits>
+basic_ostream<wchar_t, traits>& operator<<(basic_ostream<wchar_t, traits>&, const char32_t*) = delete; // since C++20
+
 }  // std
 
 */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__config>
 #include <bitset>
 #include <ios>

 basic_ostream<_CharT, _Traits>&
 operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
 {
     return __os << __x.template to_string<_CharT, _Traits>
                         (use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
                          use_facet<ctype<_CharT> >(__os.getloc()).widen('1'));
 }
 
+#if _LIBCPP_STD_VER > 17
+
+#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, wchar_t) = delete;
+
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const wchar_t*) = delete;
+
+template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char16_t) = delete;
+
+template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char32_t) = delete;
+
+template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char16_t*) = delete;
+
+template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char32_t*) = delete;
+
+#endif // _LIBCPP_HAS_NO_WIDE_CHARACTERS
+
+#ifndef _LIBCPP_HAS_NO_CHAR8_T
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char8_t) = delete;
+
+template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, char8_t) = delete;
+
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char8_t*) = delete;
+
+template <class _Traits>
+basic_ostream<wchar_t, _Traits>& operator<<(basic_ostream<wchar_t, _Traits>&, const char8_t*) = delete;
+#endif
+
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char16_t) = delete;
+
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, char32_t) = delete;
+
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char16_t*) = delete;
+
+template <class _Traits>
+basic_ostream<char, _Traits>& operator<<(basic_ostream<char, _Traits>&, const char32_t*) = delete;
+
+#endif // _LIBCPP_STD_VER > 17
+
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<char>;
 #ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
 extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS basic_ostream<wchar_t>;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_OSTREAM

libcxx/include/version

 __cpp_lib_bind_front                                    201907L <functional>
 __cpp_lib_bit_cast                                      201806L <bit>
 __cpp_lib_bitops                                        201907L <bit>
 __cpp_lib_bool_constant                                 201505L <type_traits>
 __cpp_lib_bounded_array_traits                          201902L <type_traits>
 __cpp_lib_boyer_moore_searcher                          201603L <functional>
 __cpp_lib_byte                                          201603L <cstddef>
 __cpp_lib_byteswap                                      202110L <bit>
-__cpp_lib_char8_t                                       201811L <atomic> <filesystem> <istream>
+__cpp_lib_char8_t                                       201907L <atomic> <filesystem> <istream>
                                                                 <limits> <locale> <ostream>
                                                                 <string> <string_view>
 __cpp_lib_chrono                                        201611L <chrono>
 __cpp_lib_chrono_udls                                   201304L <chrono>
 __cpp_lib_clamp                                         201603L <algorithm>
 __cpp_lib_complex_udls                                  201309L <complex>
 __cpp_lib_concepts                                      202002L <concepts>
 __cpp_lib_constexpr_algorithms                          201806L <algorithm>

 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_barrier)
 #   define __cpp_lib_barrier                            201907L
 # endif
 # define __cpp_lib_bind_front                           201907L
 # define __cpp_lib_bit_cast                             201806L
 // # define __cpp_lib_bitops                               201907L
 # define __cpp_lib_bounded_array_traits                 201902L
 # if !defined(_LIBCPP_HAS_NO_CHAR8_T)
-#   define __cpp_lib_char8_t                            201811L
+#   define __cpp_lib_char8_t                            201907L
 # endif
 # define __cpp_lib_concepts                             202002L
 # define __cpp_lib_constexpr_algorithms                 201806L
 // # define __cpp_lib_constexpr_complex                    201711L
 # define __cpp_lib_constexpr_dynamic_alloc              201907L
 # define __cpp_lib_constexpr_functional                 201907L
 # define __cpp_lib_constexpr_iterator                   201811L
 # define __cpp_lib_constexpr_memory                     201811L

libcxx/test/std/input.output/iostream.format/output.streams/ostream/deleted_output_functions.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
+
+// <ostream>
+
+#include <ostream>
+#include <sstream>
+#include <utility>
+
+#include "test_macros.h"
+
+int main() {
+  std::ostringstream s;
+  std::wostringstream sw;
+#ifndef TEST_HAS_NO_WIDE_CHARACTERS
+  s << wchar_t();                      // expected-error {{overload resolution selected deleted operator '<<'}}
+  s << std::declval<const wchar_t*>(); // expected-error {{overload resolution selected deleted operator '<<'}}
+#endif
+#ifndef TEST_HAS_NO_CHAR8_T
+  s << char8_t();                       // expected-error {{overload resolution selected deleted operator '<<'}}
+  sw << char8_t();                      // expected-error {{overload resolution selected deleted operator '<<'}}
+  s << std::declval<const char8_t*>();  // expected-error {{overload resolution selected deleted operator '<<'}}
+  sw << std::declval<const char8_t*>(); // expected-error {{overload resolution selected deleted operator '<<'}}
+#endif
+  s << char16_t();                       // expected-error {{overload resolution selected deleted operator '<<'}}
+  sw << char16_t();                      // expected-error {{overload resolution selected deleted operator '<<'}}
+  s << std::declval<const char16_t*>();  // expected-error {{overload resolution selected deleted operator '<<'}}
+  sw << std::declval<const char16_t*>(); // expected-error {{overload resolution selected deleted operator '<<'}}
+  s << char32_t();                       // expected-error {{overload resolution selected deleted operator '<<'}}
+  sw << char32_t();                      // expected-error {{overload resolution selected deleted operator '<<'}}
+  s << std::declval<const char32_t*>();  // expected-error {{overload resolution selected deleted operator '<<'}}
+  sw << std::declval<const char32_t*>(); // expected-error {{overload resolution selected deleted operator '<<'}}
+}

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

/*  Constant                                   Value
     __cpp_lib_atomic_flag_test                 201907L [C++20]
     __cpp_lib_atomic_float                     201711L [C++20]
     __cpp_lib_atomic_is_always_lock_free       201603L [C++17]
     __cpp_lib_atomic_lock_free_type_aliases    201907L [C++20]
     __cpp_lib_atomic_ref                       201806L [C++20]
     __cpp_lib_atomic_shared_ptr                201711L [C++20]
     __cpp_lib_atomic_value_initialization      201911L [C++20]
     __cpp_lib_atomic_wait                      201907L [C++20]
-    __cpp_lib_char8_t                          201811L [C++20]
+    __cpp_lib_char8_t                          201907L [C++20]
 */
 
 #include <atomic>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_atomic_flag_test

 #     error "__cpp_lib_atomic_wait should not be defined when !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait) is not defined!"
 #   endif
 # endif
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++20"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++20"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 #elif TEST_STD_VER > 20

 #     error "__cpp_lib_atomic_wait should not be defined when !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_atomic_wait) is not defined!"
 #   endif
 # endif
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++2b"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++2b"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 #endif // TEST_STD_VER > 20
 

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

 
 // UNSUPPORTED: no-filesystem
 
 // <filesystem>
 
 // Test the feature test macros defined by <filesystem>
 
 /*  Constant                Value
-    __cpp_lib_char8_t       201811L [C++20]
+    __cpp_lib_char8_t       201907L [C++20]
     __cpp_lib_filesystem    201703L [C++17]
 */
 
 #include <filesystem>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 

 # endif
 
 #elif TEST_STD_VER == 20
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++20"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++20"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)

 # endif
 
 #elif TEST_STD_VER > 20
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++2b"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++2b"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 # if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)

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

 
 // UNSUPPORTED: no-localization
 
 // <istream>
 
 // Test the feature test macros defined by <istream>
 
 /*  Constant             Value
-    __cpp_lib_char8_t    201811L [C++20]
+    __cpp_lib_char8_t    201907L [C++20]
 */
 
 #include <istream>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_char8_t

 # endif
 
 #elif TEST_STD_VER == 20
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++20"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++20"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 #elif TEST_STD_VER > 20
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++2b"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++2b"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 #endif // TEST_STD_VER > 20
 

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

 //
 // clang-format off
 
 // <limits>
 
 // Test the feature test macros defined by <limits>
 
 /*  Constant             Value
-    __cpp_lib_char8_t    201811L [C++20]
+    __cpp_lib_char8_t    201907L [C++20]
 */
 
 #include <limits>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_char8_t

 # endif
 
 #elif TEST_STD_VER == 20
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++20"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++20"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 #elif TEST_STD_VER > 20
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++2b"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++2b"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 #endif // TEST_STD_VER > 20
 

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

 
 // UNSUPPORTED: no-localization
 
 // <locale>
 
 // Test the feature test macros defined by <locale>
 
 /*  Constant             Value
-    __cpp_lib_char8_t    201811L [C++20]
+    __cpp_lib_char8_t    201907L [C++20]
 */
 
 #include <locale>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_char8_t

 # endif
 
 #elif TEST_STD_VER == 20
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++20"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++20"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 #elif TEST_STD_VER > 20
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++2b"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++2b"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 #endif // TEST_STD_VER > 20
 

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

 
 // UNSUPPORTED: no-localization
 
 // <ostream>
 
 // Test the feature test macros defined by <ostream>
 
 /*  Constant             Value
-    __cpp_lib_char8_t    201811L [C++20]
+    __cpp_lib_char8_t    201907L [C++20]
 */
 
 #include <ostream>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
 # ifdef __cpp_lib_char8_t

 # endif
 
 #elif TEST_STD_VER == 20
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++20"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++20"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 #elif TEST_STD_VER > 20
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++2b"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++2b"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 #endif // TEST_STD_VER > 20
 

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

 // clang-format off
 
 // <string>
 
 // Test the feature test macros defined by <string>
 
 /*  Constant                                      Value
     __cpp_lib_allocator_traits_is_always_equal    201411L [C++17]
-    __cpp_lib_char8_t                             201811L [C++20]
+    __cpp_lib_char8_t                             201907L [C++20]
     __cpp_lib_constexpr_string                    201907L [C++20]
     __cpp_lib_erase_if                            202002L [C++20]
     __cpp_lib_nonmember_container_access          201411L [C++17]
     __cpp_lib_ranges_to_container                 202202L [C++2b]
     __cpp_lib_starts_ends_with                    201711L [C++20]
     __cpp_lib_string_contains                     202011L [C++2b]
     __cpp_lib_string_resize_and_overwrite         202110L [C++2b]
     __cpp_lib_string_udls                         201304L [C++14]

 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++20"
 # endif
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++20"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++20"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_constexpr_string

 # if __cpp_lib_allocator_traits_is_always_equal != 201411L
 #   error "__cpp_lib_allocator_traits_is_always_equal should have the value 201411L in c++2b"
 # endif
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++2b"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++2b"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_constexpr_string

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

 //
 // clang-format off
 
 // <string_view>
 
 // Test the feature test macros defined by <string_view>
 
 /*  Constant                           Value
-    __cpp_lib_char8_t                  201811L [C++20]
+    __cpp_lib_char8_t                  201907L [C++20]
     __cpp_lib_constexpr_string_view    201811L [C++20]
     __cpp_lib_starts_ends_with         201711L [C++20]
     __cpp_lib_string_contains          202011L [C++2b]
     __cpp_lib_string_view              201606L [C++17]
                                        201803L [C++20]
 */
 
 #include <string_view>

 # endif
 
 #elif TEST_STD_VER == 20
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++20"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++20"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_constexpr_string_view

 # endif
 
 #elif TEST_STD_VER > 20
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++2b"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++2b"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_constexpr_string_view

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

/*  Constant                                       Value
     __cpp_lib_bind_front                           201907L [C++20]
     __cpp_lib_bit_cast                             201806L [C++20]
     __cpp_lib_bitops                               201907L [C++20]
     __cpp_lib_bool_constant                        201505L [C++17]
     __cpp_lib_bounded_array_traits                 201902L [C++20]
     __cpp_lib_boyer_moore_searcher                 201603L [C++17]
     __cpp_lib_byte                                 201603L [C++17]
     __cpp_lib_byteswap                             202110L [C++2b]
-    __cpp_lib_char8_t                              201811L [C++20]
+    __cpp_lib_char8_t                              201907L [C++20]
     __cpp_lib_chrono                               201611L [C++17]
     __cpp_lib_chrono_udls                          201304L [C++14]
     __cpp_lib_clamp                                201603L [C++17]
     __cpp_lib_complex_udls                         201309L [C++14]
     __cpp_lib_concepts                             202002L [C++20]
     __cpp_lib_constexpr_algorithms                 201806L [C++20]
     __cpp_lib_constexpr_cmath                      202202L [C++2b]
     __cpp_lib_constexpr_complex                    201711L [C++20]

 # ifdef __cpp_lib_byteswap
 #   error "__cpp_lib_byteswap should not be defined before c++2b"
 # endif
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++20"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++20"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_chrono

 # if __cpp_lib_byteswap != 202110L
 #   error "__cpp_lib_byteswap should have the value 202110L in c++2b"
 # endif
 
 # if defined(__cpp_char8_t)
 #   ifndef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should be defined in c++2b"
 #   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L in c++2b"
+#   if __cpp_lib_char8_t != 201907L
+#     error "__cpp_lib_char8_t should have the value 201907L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_char8_t
 #     error "__cpp_lib_char8_t should not be defined when defined(__cpp_char8_t) is not defined!"
 #   endif
 # endif
 
 # ifndef __cpp_lib_chrono

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "values": { "c++17": 201603 },
     "headers": ["cstddef"],
   }, {
     "name": "__cpp_lib_byteswap",
     "values": { "c++2b": 202110 },
     "headers": ["bit"],
   }, {
     "name": "__cpp_lib_char8_t",
-    "values": { "c++20": 201811 },
+    "values": { "c++20": 201907 },
     "headers": ["atomic", "filesystem", "istream", "limits", "locale", "ostream", "string", "string_view"],
     "test_suite_guard": "defined(__cpp_char8_t)",
     "libcxx_guard": "!defined(_LIBCPP_HAS_NO_CHAR8_T)",
   }, {
     "name": "__cpp_lib_chrono",
     "values": { "c++17": 201611 },
     "headers": ["chrono"],
   }, {