[libc++][WIP] remove _LIBCPP_HAS_NO_CHAR8_T.

[Mordante]

Summary

Needs a few more cleanups, just want to make sure it passes the CI.

[Mordante]

Rebase to trigger CI.

[Mordante]

Since clang offers ways not to support char8_t this patch has no use.

libcxx/include/__config

 #if defined(__APPLE__) || defined(__FreeBSD__)
 #define _LIBCPP_HAS_DEFAULTRUNELOCALE
 #endif
 
 #if defined(__APPLE__) || defined(__FreeBSD__) || defined(__sun__)
 #define _LIBCPP_WCTYPE_IS_MASK
 #endif
 
-#if _LIBCPP_STD_VER <= 17 || !defined(__cpp_char8_t)
-#define _LIBCPP_HAS_NO_CHAR8_T
-#endif
-
 // Deprecation macros.
 //
 // Deprecations warnings are always enabled, except when users explicitly opt-out
 // by defining _LIBCPP_DISABLE_DEPRECATION_WARNINGS.
 #if !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS)
 #  if __has_attribute(deprecated)
 #    define _LIBCPP_DEPRECATED __attribute__ ((deprecated))
 #  elif _LIBCPP_STD_VER > 11

 #endif
 
 #if _LIBCPP_STD_VER > 17
 #  define _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_DEPRECATED
 #else
 #  define _LIBCPP_DEPRECATED_IN_CXX20
 #endif
 
-#if !defined(_LIBCPP_HAS_NO_CHAR8_T)
+#if  _LIBCPP_STD_VER <= 17
 #  define _LIBCPP_DEPRECATED_WITH_CHAR8_T _LIBCPP_DEPRECATED
 #else
 #  define _LIBCPP_DEPRECATED_WITH_CHAR8_T
 #endif
 
 // Macros to enter and leave a state where deprecation warnings are suppressed.
 #if defined(_LIBCPP_COMPILER_CLANG_BASED) || defined(_LIBCPP_COMPILER_GCC)
 #   define _LIBCPP_SUPPRESS_DEPRECATED_PUSH \

libcxx/include/__functional/hash.h

 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
     _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
     _LIBCPP_DEPRECATED_IN_CXX17 typedef unsigned char argument_type;
 #endif
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 };
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<char8_t>
 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES)
     : public unary_function<char8_t, size_t>
 #endif
 {
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
     _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
     _LIBCPP_DEPRECATED_IN_CXX17 typedef char8_t argument_type;
 #endif
     _LIBCPP_INLINE_VISIBILITY
     size_t operator()(char8_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
 };
-#endif // !_LIBCPP_HAS_NO_CHAR8_T
 
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 struct _LIBCPP_TEMPLATE_VIS hash<char16_t>
 #if !defined(_LIBCPP_ABI_NO_BINDER_BASES)
     : public unary_function<char16_t, size_t>

libcxx/include/__locale

protected:
     virtual result do_unshift(state_type& __st,
                               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual int do_encoding() const  _NOEXCEPT;
     virtual bool do_always_noconv() const  _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
     virtual int do_max_length() const  _NOEXCEPT;
 };
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 
 // template <> class codecvt<char16_t, char8_t, mbstate_t> // C++20
 
 template <>
 class _LIBCPP_TYPE_VIS codecvt<char16_t, char8_t, mbstate_t>
     : public locale::facet,
       public codecvt_base
 {
protected:
     virtual result do_unshift(state_type& __st,
                               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual int do_encoding() const  _NOEXCEPT;
     virtual bool do_always_noconv() const  _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
     virtual int do_max_length() const  _NOEXCEPT;
 };
 
-#endif
+#endif // _LIBCPP_STD_VER > 17
 
 // template <> class codecvt<char32_t, char, mbstate_t> // deprecated in C++20
 
 template <>
 class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_TYPE_VIS codecvt<char32_t, char, mbstate_t>
     : public locale::facet,
       public codecvt_base
 {
protected:
     virtual result do_unshift(state_type& __st,
                               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual int do_encoding() const  _NOEXCEPT;
     virtual bool do_always_noconv() const  _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
     virtual int do_max_length() const  _NOEXCEPT;
 };
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 
 // template <> class codecvt<char32_t, char8_t, mbstate_t> // C++20
 
 template <>
 class _LIBCPP_TYPE_VIS codecvt<char32_t, char8_t, mbstate_t>
     : public locale::facet,
       public codecvt_base
 {
protected:
     virtual result do_unshift(state_type& __st,
                               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual int do_encoding() const  _NOEXCEPT;
     virtual bool do_always_noconv() const  _NOEXCEPT;
     virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
     virtual int do_max_length() const  _NOEXCEPT;
 };
 
-#endif
+#endif // _LIBCPP_STD_VER > 17
 
 // template <class _InternT, class _ExternT, class _StateT> class codecvt_byname
 
 template <class _InternT, class _ExternT, class _StateT>
 class _LIBCPP_TEMPLATE_VIS codecvt_byname
     : public codecvt<_InternT, _ExternT, _StateT>
 {
 public:

 {
 }
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
 _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char, char, mbstate_t>)
 _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<wchar_t, char, mbstate_t>)
 _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char16_t, char, mbstate_t>) // deprecated in C++20
 _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char32_t, char, mbstate_t>) // deprecated in C++20
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char16_t, char8_t, mbstate_t>) // C++20
 _LIBCPP_EXTERN_TEMPLATE_EVEN_IN_DEBUG_MODE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char32_t, char8_t, mbstate_t>) // C++20
 #endif
 
 template <size_t _Np>
 struct __narrow_to_utf8
 {
     template <class _OutputIterator, class _CharT>

libcxx/include/__string

 inline size_t __char_traits_length_checked(const typename _Traits::char_type* __s) _NOEXCEPT {
 #if _LIBCPP_DEBUG_LEVEL >= 1
   return __s ? _Traits::length(__s) : (_VSTD::__libcpp_debug_function(_VSTD::__libcpp_debug_info(__FILE__, __LINE__, "p == nullptr", "null pointer pass to non-null argument of char_traits<...>::length")), 0);
 #else
   return _Traits::length(__s);
 #endif
 }
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char8_t>
 {
     typedef char8_t        char_type;
     typedef unsigned int   int_type;
     typedef streamoff      off_type;
     typedef u8streampos    pos_type;
char_traits<char8_t>::find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT
     {
         if (eq(*__s, __a))
             return __s;
         ++__s;
     }
     return nullptr;
 }
 
-#endif // #_LIBCPP_HAS_NO_CHAR8_T
+#endif // _LIBCPP_STD_VER > 17
 
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 
 template <>
 struct _LIBCPP_TEMPLATE_VIS char_traits<char16_t>
 {
     typedef char16_t       char_type;
     typedef uint_least16_t int_type;

libcxx/include/__utility/cmp.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___UTILITY_CMP_H

 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_CONCEPTS)
 template<class _Tp, class... _Up>
 struct _IsSameAsAny : _Or<_IsSame<_Tp, _Up>...> {};
 
 template<class _Tp>
 concept __is_safe_integral_cmp = is_integral_v<_Tp> &&
-                      !_IsSameAsAny<_Tp, bool, char,
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
-                                    char8_t,
-#endif
+                      !_IsSameAsAny<_Tp, bool, char, char8_t,
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
                                     char16_t, char32_t,
 #endif
                                     wchar_t>::value;
 
 template<__is_safe_integral_cmp _Tp, __is_safe_integral_cmp _Up>
 _LIBCPP_INLINE_VISIBILITY constexpr
 bool cmp_equal(_Tp __t, _Up __u) noexcept

libcxx/include/atomic

 _Tp kill_dependency(_Tp __y) _NOEXCEPT
 {
     return __y;
 }
 
 #if defined(__CLANG_ATOMIC_BOOL_LOCK_FREE)
 # define ATOMIC_BOOL_LOCK_FREE      __CLANG_ATOMIC_BOOL_LOCK_FREE
 # define ATOMIC_CHAR_LOCK_FREE      __CLANG_ATOMIC_CHAR_LOCK_FREE
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 # define ATOMIC_CHAR8_T_LOCK_FREE   __CLANG_ATOMIC_CHAR8_T_LOCK_FREE
 #endif
 # define ATOMIC_CHAR16_T_LOCK_FREE  __CLANG_ATOMIC_CHAR16_T_LOCK_FREE
 # define ATOMIC_CHAR32_T_LOCK_FREE  __CLANG_ATOMIC_CHAR32_T_LOCK_FREE
 # define ATOMIC_WCHAR_T_LOCK_FREE   __CLANG_ATOMIC_WCHAR_T_LOCK_FREE
 # define ATOMIC_SHORT_LOCK_FREE     __CLANG_ATOMIC_SHORT_LOCK_FREE
 # define ATOMIC_INT_LOCK_FREE       __CLANG_ATOMIC_INT_LOCK_FREE
 # define ATOMIC_LONG_LOCK_FREE      __CLANG_ATOMIC_LONG_LOCK_FREE
 # define ATOMIC_LLONG_LOCK_FREE     __CLANG_ATOMIC_LLONG_LOCK_FREE
 # define ATOMIC_POINTER_LOCK_FREE   __CLANG_ATOMIC_POINTER_LOCK_FREE
 #elif defined(__GCC_ATOMIC_BOOL_LOCK_FREE)
 # define ATOMIC_BOOL_LOCK_FREE      __GCC_ATOMIC_BOOL_LOCK_FREE
 # define ATOMIC_CHAR_LOCK_FREE      __GCC_ATOMIC_CHAR_LOCK_FREE
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 # define ATOMIC_CHAR8_T_LOCK_FREE   __GCC_ATOMIC_CHAR8_T_LOCK_FREE
 #endif
 # define ATOMIC_CHAR16_T_LOCK_FREE  __GCC_ATOMIC_CHAR16_T_LOCK_FREE
 # define ATOMIC_CHAR32_T_LOCK_FREE  __GCC_ATOMIC_CHAR32_T_LOCK_FREE
 # define ATOMIC_WCHAR_T_LOCK_FREE   __GCC_ATOMIC_WCHAR_T_LOCK_FREE
 # define ATOMIC_SHORT_LOCK_FREE     __GCC_ATOMIC_SHORT_LOCK_FREE
 # define ATOMIC_INT_LOCK_FREE       __GCC_ATOMIC_INT_LOCK_FREE
 # define ATOMIC_LONG_LOCK_FREE      __GCC_ATOMIC_LONG_LOCK_FREE

 #else
 
 template<typename _Tp> struct __cxx_is_always_lock_free { enum { __value = false }; };
 // Implementations must match the C ATOMIC_*_LOCK_FREE macro values.
 template<> struct __cxx_is_always_lock_free<bool> { enum { __value = 2 == ATOMIC_BOOL_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<char> { enum { __value = 2 == ATOMIC_CHAR_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<signed char> { enum { __value = 2 == ATOMIC_CHAR_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<unsigned char> { enum { __value = 2 == ATOMIC_CHAR_LOCK_FREE }; };
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 template<> struct __cxx_is_always_lock_free<char8_t> { enum { __value = 2 == ATOMIC_CHAR8_T_LOCK_FREE }; };
 #endif
 template<> struct __cxx_is_always_lock_free<char16_t> { enum { __value = 2 == ATOMIC_CHAR16_T_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<char32_t> { enum { __value = 2 == ATOMIC_CHAR32_T_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<wchar_t> { enum { __value = 2 == ATOMIC_WCHAR_T_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<short> { enum { __value = 2 == ATOMIC_SHORT_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<unsigned short> { enum { __value = 2 == ATOMIC_SHORT_LOCK_FREE }; };
 template<> struct __cxx_is_always_lock_free<int> { enum { __value = 2 == ATOMIC_INT_LOCK_FREE }; };

 typedef atomic<short>              atomic_short;
 typedef atomic<unsigned short>     atomic_ushort;
 typedef atomic<int>                atomic_int;
 typedef atomic<unsigned int>       atomic_uint;
 typedef atomic<long>               atomic_long;
 typedef atomic<unsigned long>      atomic_ulong;
 typedef atomic<long long>          atomic_llong;
 typedef atomic<unsigned long long> atomic_ullong;
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 typedef atomic<char8_t>            atomic_char8_t;
 #endif
 typedef atomic<char16_t>           atomic_char16_t;
 typedef atomic<char32_t>           atomic_char32_t;
 typedef atomic<wchar_t>            atomic_wchar_t;
 
 typedef atomic<int_least8_t>   atomic_int_least8_t;
 typedef atomic<uint_least8_t>  atomic_uint_least8_t;

libcxx/include/cstddef

 #endif
 
 template <class _Tp> struct __libcpp_is_integral                     { enum { value = 0 }; };
 template <>          struct __libcpp_is_integral<bool>               { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<char>               { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<signed char>        { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<unsigned char>      { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<wchar_t>            { enum { value = 1 }; };
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 template <>          struct __libcpp_is_integral<char8_t>            { enum { value = 1 }; };
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 template <>          struct __libcpp_is_integral<char16_t>           { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<char32_t>           { enum { value = 1 }; };
 #endif
 template <>          struct __libcpp_is_integral<short>              { enum { value = 1 }; };
 template <>          struct __libcpp_is_integral<unsigned short>     { enum { value = 1 }; };

libcxx/include/filesystem

struct __can_convert_char<char> {
   static const bool value = true;
   using __char_type = char;
 };
 template <>
 struct __can_convert_char<wchar_t> {
   static const bool value = true;
   using __char_type = wchar_t;
 };
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 template <>
 struct __can_convert_char<char8_t> {
   static const bool value = true;
   using __char_type = char8_t;
 };
 #endif
 template <>
 struct __can_convert_char<char16_t> {

 __is_separator(_ECharT __e) {
 #if defined(_LIBCPP_WIN32API)
   return __e == _ECharT('/') || __e == _ECharT('\\');
 #else
   return __e == _ECharT('/');
 #endif
 }
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 typedef u8string __u8_string;
 #else
 typedef string __u8_string;
 #endif
 
 struct _NullSentinel {};
 
 template <class _Tp>

 template <>
 struct _PathExport<char16_t> {
   template <class _Str>
   static void __append(_Str& __dest, const __path_string& __src) {
     __dest.append(__src.begin(), __src.end());
   }
 };
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 template <>
 struct _PathExport<char8_t> {
   typedef __narrow_to_utf8<sizeof(wchar_t) * __CHAR_BIT__> _Narrower;
 
   template <class _Str>
   static void __append(_Str& __dest, const __path_string& __src) {
     _Narrower()(back_inserter(__dest), __src.data(), __src.data() + __src.size());
   }
 };
-#endif /* !_LIBCPP_HAS_NO_CHAR8_T */
+#endif /* _LIBCPP_STD_VER > 17 */
 #endif /* _LIBCPP_WIN32API */
 
 class _LIBCPP_TYPE_VIS path {
   template <class _SourceOrIter, class _Tp = path&>
   using _EnableIfPathable =
       typename enable_if<__is_pathable<_SourceOrIter>::value, _Tp>::type;
 
   template <class _Tp>
__u8_string generic_u8string() const {
     __u8_string __s = u8string();
     _VSTD::replace(__s.begin(), __s.end(), '\\', '/');
     return __s;
   }
 #endif /* !_LIBCPP_HAS_NO_LOCALIZATION */
 #else /* _LIBCPP_WIN32API */
 
   _LIBCPP_INLINE_VISIBILITY _VSTD::string string() const { return __pn_; }
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
   _LIBCPP_INLINE_VISIBILITY _VSTD::u8string u8string() const { return _VSTD::u8string(__pn_.begin(), __pn_.end()); }
 #else
   _LIBCPP_INLINE_VISIBILITY _VSTD::string u8string() const { return __pn_; }
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
   template <class _ECharT, class _Traits = char_traits<_ECharT>,
             class _Allocator = allocator<_ECharT> >
#if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
   }
   _LIBCPP_INLINE_VISIBILITY _VSTD::u32string u32string() const {
     return string<char32_t>();
   }
 #endif /* !_LIBCPP_HAS_NO_LOCALIZATION */
 
   // generic format observers
   _VSTD::string generic_string() const { return __pn_; }
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
   _VSTD::u8string generic_u8string() const { return _VSTD::u8string(__pn_.begin(), __pn_.end()); }
 #else
   _VSTD::string generic_u8string() const { return __pn_; }
 #endif
 
 #if !defined(_LIBCPP_HAS_NO_LOCALIZATION)
   template <class _ECharT, class _Traits = char_traits<_ECharT>,
             class _Allocator = allocator<_ECharT> >

 _LIBCPP_FUNC_VIS
 size_t hash_value(const path& __p) noexcept;
 
 template <class _InputIt>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T
     typename enable_if<__is_pathable<_InputIt>::value, path>::type
     u8path(_InputIt __f, _InputIt __l) {
   static_assert(
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
       is_same<typename __is_pathable<_InputIt>::__char_type, char8_t>::value ||
 #endif
       is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
       "u8path(Iter, Iter) requires Iter have a value_type of type 'char'"
       " or 'char8_t'");
 #if defined(_LIBCPP_WIN32API)
   string __tmp(__f, __l);
   using _CVT = __widen_from_utf8<sizeof(wchar_t) * __CHAR_BIT__>;
   _VSTD::wstring __w;
   __w.reserve(__tmp.size());
   _CVT()(back_inserter(__w), __tmp.data(), __tmp.data() + __tmp.size());
   return path(__w);
 #else
   return path(__f, __l);
 #endif /* !_LIBCPP_WIN32API */
 }
 
 #if defined(_LIBCPP_WIN32API)
 template <class _InputIt>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T
     typename enable_if<__is_pathable<_InputIt>::value, path>::type
     u8path(_InputIt __f, _NullSentinel) {
   static_assert(
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
       is_same<typename __is_pathable<_InputIt>::__char_type, char8_t>::value ||
 #endif
       is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
       "u8path(Iter, Iter) requires Iter have a value_type of type 'char'"
       " or 'char8_t'");
   string __tmp;
   const char __sentinel = char{};
   for (; *__f != __sentinel; ++__f)
     __tmp.push_back(*__f);
   using _CVT = __widen_from_utf8<sizeof(wchar_t) * __CHAR_BIT__>;
   _VSTD::wstring __w;
   __w.reserve(__tmp.size());
   _CVT()(back_inserter(__w), __tmp.data(), __tmp.data() + __tmp.size());
   return path(__w);
 }
 #endif /* _LIBCPP_WIN32API */
 
 template <class _Source>
 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_WITH_CHAR8_T
     typename enable_if<__is_pathable<_Source>::value, path>::type
     u8path(const _Source& __s) {
   static_assert(
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
       is_same<typename __is_pathable<_Source>::__char_type, char8_t>::value ||
 #endif
       is_same<typename __is_pathable<_Source>::__char_type, char>::value,
       "u8path(Source const&) requires Source have a character type of type "
       "'char' or 'char8_t'");
 #if defined(_LIBCPP_WIN32API)
   using _Traits = __is_pathable<_Source>;
   return u8path(_VSTD::__unwrap_iter(_Traits::__range_begin(__s)), _VSTD::__unwrap_iter(_Traits::__range_end(__s)));

libcxx/include/iosfwd

 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_TYPE_VIS ios_base;
 
 template<class _CharT>  struct _LIBCPP_TEMPLATE_VIS char_traits;
 template<> struct char_traits<char>;
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 template<> struct char_traits<char8_t>;
 #endif
 template<> struct char_traits<char16_t>;
 template<> struct char_traits<char32_t>;
 template<> struct char_traits<wchar_t>;
 
 template<class _Tp>     class _LIBCPP_TEMPLATE_VIS allocator;
 

 template <class _CharT, class _Traits>
     class _LIBCPP_PREFERRED_NAME(ofstream) _LIBCPP_PREFERRED_NAME(wofstream) basic_ofstream;
 template <class _CharT, class _Traits>
     class _LIBCPP_PREFERRED_NAME(fstream) _LIBCPP_PREFERRED_NAME(wfstream) basic_fstream;
 
 template <class _State>             class _LIBCPP_TEMPLATE_VIS fpos;
 typedef fpos<mbstate_t>    streampos;
 typedef fpos<mbstate_t>    wstreampos;
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 typedef fpos<mbstate_t>    u8streampos;
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 typedef fpos<mbstate_t>    u16streampos;
 typedef fpos<mbstate_t>    u32streampos;
 #endif
 
 #if defined(_NEWLIB_VERSION)

libcxx/include/string

 
 template <class _CharT>
 struct __padding<_CharT, 1>
 {
 };
 
 #endif // _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 typedef basic_string<char8_t> u8string;
 #endif
 
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 typedef basic_string<char16_t> u16string;
 typedef basic_string<char32_t> u32string;
 #endif
 
 template<class _CharT, class _Traits, class _Allocator>
 class
     _LIBCPP_TEMPLATE_VIS
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
     _LIBCPP_PREFERRED_NAME(u8string)
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     _LIBCPP_PREFERRED_NAME(u16string)
     _LIBCPP_PREFERRED_NAME(u32string)
 #endif
     basic_string
     : private __basic_string_common<true>
inline namespace string_literals
     }
 
     inline _LIBCPP_INLINE_VISIBILITY
     basic_string<wchar_t> operator "" s( const wchar_t *__str, size_t __len )
     {
         return basic_string<wchar_t> (__str, __len);
     }
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
     inline _LIBCPP_INLINE_VISIBILITY
     basic_string<char8_t> operator "" s(const char8_t *__str, size_t __len) _NOEXCEPT
     {
         return basic_string<char8_t> (__str, __len);
     }
 #endif
 
     inline _LIBCPP_INLINE_VISIBILITY

libcxx/include/string_view

 
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template<class _CharT, class _Traits = char_traits<_CharT> >
     class _LIBCPP_TEMPLATE_VIS basic_string_view;
 
 typedef basic_string_view<char>     string_view;
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
 typedef basic_string_view<char8_t>  u8string_view;
 #endif
 typedef basic_string_view<char16_t> u16string_view;
 typedef basic_string_view<char32_t> u32string_view;
 typedef basic_string_view<wchar_t>  wstring_view;
 
 template<class _CharT, class _Traits>
 class
     _LIBCPP_PREFERRED_NAME(string_view)
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
     _LIBCPP_PREFERRED_NAME(u8string_view)
 #endif
     _LIBCPP_PREFERRED_NAME(u16string_view)
     _LIBCPP_PREFERRED_NAME(u32string_view)
     _LIBCPP_PREFERRED_NAME(wstring_view)
     basic_string_view {
 public:
     // types
inline namespace string_view_literals
     }
 
     inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     basic_string_view<wchar_t> operator "" sv(const wchar_t *__str, size_t __len) _NOEXCEPT
     {
         return basic_string_view<wchar_t> (__str, __len);
     }
 
-#ifndef _LIBCPP_HAS_NO_CHAR8_T
+#if _LIBCPP_STD_VER > 17
     inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
     basic_string_view<char8_t> operator "" sv(const char8_t *__str, size_t __len) _NOEXCEPT
     {
         return basic_string_view<char8_t> (__str, __len);
     }
 #endif
 
     inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR

libcxx/include/version

 # endif
 # 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
-# endif
+# define __cpp_lib_char8_t                              201811L
 # 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
 # define __cpp_lib_constexpr_numeric                    201911L

libcxx/test/std/atomics/atomics.lockfree/isalwayslockfree.pass.cpp

do {                                                                         \
     typedef T type;                                                            \
     checkAlwaysLockFree<type>();                                               \
   } while (0)
 
     CHECK_ALWAYS_LOCK_FREE(bool);
     CHECK_ALWAYS_LOCK_FREE(char);
     CHECK_ALWAYS_LOCK_FREE(signed char);
     CHECK_ALWAYS_LOCK_FREE(unsigned char);
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     CHECK_ALWAYS_LOCK_FREE(char8_t);
 #endif
     CHECK_ALWAYS_LOCK_FREE(char16_t);
     CHECK_ALWAYS_LOCK_FREE(char32_t);
     CHECK_ALWAYS_LOCK_FREE(wchar_t);
     CHECK_ALWAYS_LOCK_FREE(short);
     CHECK_ALWAYS_LOCK_FREE(unsigned short);
     CHECK_ALWAYS_LOCK_FREE(int);
#endif // __has_attribute(vector_size) && defined(_LIBCPP_VERSION)
     CHECK_ALWAYS_LOCK_FREE(struct Padding { char c; /* padding */ long long int i; });
     CHECK_ALWAYS_LOCK_FREE(union IntFloat { int i; float f; });
 
     // C macro and static constexpr must be consistent.
     static_assert(std::atomic<bool>::is_always_lock_free == (2 == ATOMIC_BOOL_LOCK_FREE), "");
     static_assert(std::atomic<char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");
     static_assert(std::atomic<signed char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");
     static_assert(std::atomic<unsigned char>::is_always_lock_free == (2 == ATOMIC_CHAR_LOCK_FREE), "");
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     static_assert(std::atomic<char8_t>::is_always_lock_free == (2 == ATOMIC_CHAR8_T_LOCK_FREE), "");
 #endif
     static_assert(std::atomic<char16_t>::is_always_lock_free == (2 == ATOMIC_CHAR16_T_LOCK_FREE), "");
     static_assert(std::atomic<char32_t>::is_always_lock_free == (2 == ATOMIC_CHAR32_T_LOCK_FREE), "");
     static_assert(std::atomic<wchar_t>::is_always_lock_free == (2 == ATOMIC_WCHAR_T_LOCK_FREE), "");
     static_assert(std::atomic<short>::is_always_lock_free == (2 == ATOMIC_SHORT_LOCK_FREE), "");
     static_assert(std::atomic<unsigned short>::is_always_lock_free == (2 == ATOMIC_SHORT_LOCK_FREE), "");
     static_assert(std::atomic<int>::is_always_lock_free == (2 == ATOMIC_INT_LOCK_FREE), "");

libcxx/test/std/atomics/atomics.lockfree/lockfree.pass.cpp

 int main(int, char**)
 {
     assert(ATOMIC_BOOL_LOCK_FREE == 0 ||
            ATOMIC_BOOL_LOCK_FREE == 1 ||
            ATOMIC_BOOL_LOCK_FREE == 2);
     assert(ATOMIC_CHAR_LOCK_FREE == 0 ||
            ATOMIC_CHAR_LOCK_FREE == 1 ||
            ATOMIC_CHAR_LOCK_FREE == 2);
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     assert(ATOMIC_CHAR8_T_LOCK_FREE == 0 ||
            ATOMIC_CHAR8_T_LOCK_FREE == 1 ||
            ATOMIC_CHAR8_T_LOCK_FREE == 2);
 #endif
     assert(ATOMIC_CHAR16_T_LOCK_FREE == 0 ||
            ATOMIC_CHAR16_T_LOCK_FREE == 1 ||
            ATOMIC_CHAR16_T_LOCK_FREE == 2);
     assert(ATOMIC_CHAR32_T_LOCK_FREE == 0 ||

libcxx/test/std/atomics/atomics.types.generic/integral.pass.cpp

int main(int, char**)
     test<std::atomic_short, short>();
     test<std::atomic_ushort, unsigned short>();
     test<std::atomic_int, int>();
     test<std::atomic_uint, unsigned int>();
     test<std::atomic_long, long>();
     test<std::atomic_ulong, unsigned long>();
     test<std::atomic_llong, long long>();
     test<std::atomic_ullong, unsigned long long>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<std::atomic_char8_t, char8_t>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<std::atomic_char16_t, char16_t>();
     test<std::atomic_char32_t, char32_t>();
 #endif
     test<std::atomic_wchar_t, wchar_t>();
 

libcxx/test/std/atomics/atomics.types.generic/integral_typedefs.pass.cpp

int main(int, char**)
     static_assert((std::is_same<std::atomic<unsigned short>, std::atomic_ushort>::value), "");
     static_assert((std::is_same<std::atomic<int>, std::atomic_int>::value), "");
     static_assert((std::is_same<std::atomic<unsigned int>, std::atomic_uint>::value), "");
     static_assert((std::is_same<std::atomic<long>, std::atomic_long>::value), "");
     static_assert((std::is_same<std::atomic<unsigned long>, std::atomic_ulong>::value), "");
     static_assert((std::is_same<std::atomic<long long>, std::atomic_llong>::value), "");
     static_assert((std::is_same<std::atomic<unsigned long long>, std::atomic_ullong>::value), "");
     static_assert((std::is_same<std::atomic<wchar_t>, std::atomic_wchar_t>::value), "");
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     static_assert((std::is_same<std::atomic<char8_t>, std::atomic_char8_t>::value), "");
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     static_assert((std::is_same<std::atomic<char16_t>, std::atomic_char16_t>::value), "");
     static_assert((std::is_same<std::atomic<char32_t>, std::atomic_char32_t>::value), "");
 #endif
 
 //  Added by LWG 2441

libcxx/test/std/atomics/types.pass.cpp

int main(int, char**)
     test<short>              ();
     test<unsigned short>     ();
     test<int>                ();
     test<unsigned int>       ();
     test<long>               ();
     test<unsigned long>      ();
     test<long long>          ();
     test<unsigned long long> ();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t>            ();
 #endif
     test<char16_t>           ();
     test<char32_t>           ();
     test<wchar_t>            ();
 
     test<int_least8_t>   ();
     test<uint_least8_t>  ();

libcxx/test/std/input.output/filesystems/class.path/path.member/path.construct/source.pass.cpp

void test_sfinae() {
   {
     static_assert(!std::is_constructible<path, int*>::value, "");
   }
 }
 
 int main(int, char**) {
   for (auto const& MS : PathList) {
     RunTestCase<char>(MS);
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     RunTestCase<char8_t>(MS);
 #endif
     RunTestCase<wchar_t>(MS);
     RunTestCase<char16_t>(MS);
     RunTestCase<char32_t>(MS);
   }
   test_sfinae();
 
   return 0;
 }

libcxx/test/std/input.output/filesystems/class.path/path.member/path.generic.obs/named_overloads.pass.cpp

int main(int, char**)
   auto const& MS = ref;
   const char* value = input;
   const path p(value);
   {
     std::string s = p.generic_string();
     assert(s == (const char*)MS);
   }
   {
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     ASSERT_SAME_TYPE(decltype(p.generic_u8string()), std::u8string);
     std::u8string s = p.generic_u8string();
     assert(s == (const char8_t*)MS);
 #else
     ASSERT_SAME_TYPE(decltype(p.generic_u8string()), std::string);
     std::string s = p.generic_u8string();
     assert(s == (const char*)MS);
 #endif

libcxx/test/std/input.output/filesystems/class.path/path.member/path.native.obs/named_overloads.pass.cpp

int main(int, char**)
   auto const& MS = longString;
   const char* value = longString;
   const path p(value);
   {
     std::string s = p.string();
     assert(s == value);
   }
   {
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     ASSERT_SAME_TYPE(decltype(p.u8string()), std::u8string);
     std::u8string s = p.u8string();
     assert(s == (const char8_t*)MS);
 #else
     ASSERT_SAME_TYPE(decltype(p.u8string()), std::string);
     std::string s = p.u8string();
     assert(s == (const char*)MS);
 #endif

libcxx/test/std/input.output/filesystems/class.path/path.nonmember/path.factory.pass.cpp

int main(int, char**)
   {
     path p = fs::u8path(In2.data());
     assert(p == In1);
   }
   {
     path p = fs::u8path(In3, In3End);
     assert(p == In1);
   }
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t) && defined(_LIBCPP_VERSION) && \
-    !defined(_LIBCPP_HAS_NO_LOCALIZATION)
+#if TEST_STD_VER > 17 && defined(_LIBCPP_VERSION) && !defined(_LIBCPP_HAS_NO_LOCALIZATION)
   const char8_t* u8In1 = u8"abcd/efg";
   const std::u8string u8In2(u8In1);
   const auto u8In3 = u8In2.begin();
   const auto u8In3End = u8In2.end();
   // Proposed in P1423, marked tested only for libc++
   {
     path p = fs::u8path(u8In1);
     assert(p == In1);

libcxx/test/std/language.support/support.limits/limits/is_specialized.pass.cpp

static_assert(std::numeric_limits<const volatile T>::is_specialized,
                  "std::numeric_limits<const volatile T>::is_specialized");
 }
 
 int main(int, char**)
 {
     test<bool>();
     test<char>();
     test<wchar_t>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t>();
     test<char32_t>();
 #endif
     test<signed char>();
     test<unsigned char>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/const_data_members.pass.cpp

int main(int, char**)
     TEST_NUMERIC_LIMITS(const volatile unsigned char)
 
     // wchar_t
     TEST_NUMERIC_LIMITS(wchar_t)
     TEST_NUMERIC_LIMITS(const wchar_t)
     TEST_NUMERIC_LIMITS(volatile wchar_t)
     TEST_NUMERIC_LIMITS(const volatile wchar_t)
 
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     // char8_t
     TEST_NUMERIC_LIMITS(char8_t)
     TEST_NUMERIC_LIMITS(const char8_t)
     TEST_NUMERIC_LIMITS(volatile char8_t)
     TEST_NUMERIC_LIMITS(const volatile char8_t)
 #endif
 
     // char16_t

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/denorm_min.pass.cpp

 
 int main(int, char**)
 {
     test<bool>(false);
     test<char>(0);
     test<signed char>(0);
     test<unsigned char>(0);
     test<wchar_t>(0);
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t>(0);
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t>(0);
     test<char32_t>(0);
 #endif
     test<short>(0);
     test<unsigned short>(0);

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/digits.pass.cpp

 
 int main(int, char**)
 {
     test<bool, 1>();
     test<char, std::numeric_limits<char>::is_signed ? 7 : 8>();
     test<signed char, 7>();
     test<unsigned char, 8>();
     test<wchar_t, std::numeric_limits<wchar_t>::is_signed ? sizeof(wchar_t)*8-1 : sizeof(wchar_t)*8>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, 8>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, 16>();
     test<char32_t, 32>();
 #endif
     test<short, 15>();
     test<unsigned short, 16>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/digits10.pass.cpp

 
 int main(int, char**)
 {
     test<bool, 0>();
     test<char, 2>();
     test<signed char, 2>();
     test<unsigned char, 2>();
     test<wchar_t, 5*sizeof(wchar_t)/2-1>();  // 4 -> 9 and 2 -> 4
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, 2>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, 4>();
     test<char32_t, 9>();
 #endif
     test<short, 4>();
     test<unsigned short, 4>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/epsilon.pass.cpp

 
 int main(int, char**)
 {
     test<bool>(false);
     test<char>(0);
     test<signed char>(0);
     test<unsigned char>(0);
     test<wchar_t>(0);
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t>(0);
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t>(0);
     test<char32_t>(0);
 #endif
     test<short>(0);
     test<unsigned short>(0);

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm.pass.cpp

 
 int main(int, char**)
 {
     test<bool, std::denorm_absent>();
     test<char, std::denorm_absent>();
     test<signed char, std::denorm_absent>();
     test<unsigned char, std::denorm_absent>();
     test<wchar_t, std::denorm_absent>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, std::denorm_absent>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, std::denorm_absent>();
     test<char32_t, std::denorm_absent>();
 #endif
     test<short, std::denorm_absent>();
     test<unsigned short, std::denorm_absent>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/has_denorm_loss.pass.cpp

 
 int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
     test<signed char, false>();
     test<unsigned char, false>();
     test<wchar_t, false>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, false>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
 #endif
     test<short, false>();
     test<unsigned short, false>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/has_infinity.pass.cpp

 
 int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
     test<signed char, false>();
     test<unsigned char, false>();
     test<wchar_t, false>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, false>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
 #endif
     test<short, false>();
     test<unsigned short, false>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/has_quiet_NaN.pass.cpp

 
 int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
     test<signed char, false>();
     test<unsigned char, false>();
     test<wchar_t, false>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, false>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
 #endif
     test<short, false>();
     test<unsigned short, false>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/has_signaling_NaN.pass.cpp

 
 int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
     test<signed char, false>();
     test<unsigned char, false>();
     test<wchar_t, false>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, false>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
 #endif
     test<short, false>();
     test<unsigned short, false>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/infinity.pass.cpp

 
 int main(int, char**)
 {
     test<bool>(false);
     test<char>(0);
     test<signed char>(0);
     test<unsigned char>(0);
     test<wchar_t>(0);
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t>(0);
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t>(0);
     test<char32_t>(0);
 #endif
     test<short>(0);
     test<unsigned short>(0);

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/is_bounded.pass.cpp

 
 int main(int, char**)
 {
     test<bool, true>();
     test<char, true>();
     test<signed char, true>();
     test<unsigned char, true>();
     test<wchar_t, true>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, true>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, true>();
     test<char32_t, true>();
 #endif
     test<short, true>();
     test<unsigned short, true>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/is_exact.pass.cpp

 
 int main(int, char**)
 {
     test<bool, true>();
     test<char, true>();
     test<signed char, true>();
     test<unsigned char, true>();
     test<wchar_t, true>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, true>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, true>();
     test<char32_t, true>();
 #endif
     test<short, true>();
     test<unsigned short, true>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/is_iec559.pass.cpp

 
 int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
     test<signed char, false>();
     test<unsigned char, false>();
     test<wchar_t, false>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, false>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
 #endif
     test<short, false>();
     test<unsigned short, false>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/is_integer.pass.cpp

 
 int main(int, char**)
 {
     test<bool, true>();
     test<char, true>();
     test<signed char, true>();
     test<unsigned char, true>();
     test<wchar_t, true>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, true>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, true>();
     test<char32_t, true>();
 #endif
     test<short, true>();
     test<unsigned short, true>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/is_modulo.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
 //
 //===----------------------------------------------------------------------===//
 
 // test numeric_limits

 
 int main(int, char**)
 {
     test<bool, false>();
 //    test<char, false>(); // don't know
     test<signed char, false>();
     test<unsigned char, true>();
 //    test<wchar_t, false>(); // don't know
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, true>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, true>();
     test<char32_t, true>();
 #endif
     test<short, false>();
     test<unsigned short, true>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/is_signed.pass.cpp

 
 int main(int, char**)
 {
     test<bool, false>();
     test<char, char(-1) < char(0)>();
     test<signed char, true>();
     test<unsigned char, false>();
     test<wchar_t, wchar_t(-1) < wchar_t(0)>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, false>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
 #endif
     test<short, true>();
     test<unsigned short, false>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/lowest.pass.cpp

 
 int main(int, char**)
 {
     test<bool>(false);
     test<char>(CHAR_MIN);
     test<signed char>(SCHAR_MIN);
     test<unsigned char>(0);
     test<wchar_t>(WCHAR_MIN);
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t>(0);
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t>(0);
     test<char32_t>(0);
 #endif
     test<short>(SHRT_MIN);
     test<unsigned short>(0);

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/max.pass.cpp

 
 int main(int, char**)
 {
     test<bool>(true);
     test<char>(CHAR_MAX);
     test<signed char>(SCHAR_MAX);
     test<unsigned char>(UCHAR_MAX);
     test<wchar_t>(WCHAR_MAX);
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t>(UCHAR_MAX); // ??
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t>(USHRT_MAX);
     test<char32_t>(UINT_MAX);
 #endif
     test<short>(SHRT_MAX);
     test<unsigned short>(USHRT_MAX);

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/max_digits10.pass.cpp

 
 int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
     test<signed char, 0>();
     test<unsigned char, 0>();
     test<wchar_t, 0>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, 0>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, 0>();
     test<char32_t, 0>();
 #endif
     test<short, 0>();
     test<unsigned short, 0>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent.pass.cpp

 
 int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
     test<signed char, 0>();
     test<unsigned char, 0>();
     test<wchar_t, 0>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, 0>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, 0>();
     test<char32_t, 0>();
 #endif
     test<short, 0>();
     test<unsigned short, 0>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/max_exponent10.pass.cpp

 
 int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
     test<signed char, 0>();
     test<unsigned char, 0>();
     test<wchar_t, 0>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, 0>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, 0>();
     test<char32_t, 0>();
 #endif
     test<short, 0>();
     test<unsigned short, 0>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/min.pass.cpp

 
 int main(int, char**)
 {
     test<bool>(false);
     test<char>(CHAR_MIN);
     test<signed char>(SCHAR_MIN);
     test<unsigned char>(0);
     test<wchar_t>(WCHAR_MIN);
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t>(0);
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t>(0);
     test<char32_t>(0);
 #endif
     test<short>(SHRT_MIN);
     test<unsigned short>(0);

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent.pass.cpp

 
 int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
     test<signed char, 0>();
     test<unsigned char, 0>();
     test<wchar_t, 0>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, 0>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, 0>();
     test<char32_t, 0>();
 #endif
     test<short, 0>();
     test<unsigned short, 0>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/min_exponent10.pass.cpp

 
 int main(int, char**)
 {
     test<bool, 0>();
     test<char, 0>();
     test<signed char, 0>();
     test<unsigned char, 0>();
     test<wchar_t, 0>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, 0>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, 0>();
     test<char32_t, 0>();
 #endif
     test<short, 0>();
     test<unsigned short, 0>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/quiet_NaN.pass.cpp

 
 int main(int, char**)
 {
     test<bool>();
     test<char>();
     test<signed char>();
     test<unsigned char>();
     test<wchar_t>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t>();
     test<char32_t>();
 #endif
     test<short>();
     test<unsigned short>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/radix.pass.cpp

 
 int main(int, char**)
 {
     test<bool, 2>();
     test<char, 2>();
     test<signed char, 2>();
     test<unsigned char, 2>();
     test<wchar_t, 2>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, 2>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, 2>();
     test<char32_t, 2>();
 #endif
     test<short, 2>();
     test<unsigned short, 2>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/round_error.pass.cpp

 
 int main(int, char**)
 {
     test<bool>(false);
     test<char>(0);
     test<signed char>(0);
     test<unsigned char>(0);
     test<wchar_t>(0);
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t>(0);
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t>(0);
     test<char32_t>(0);
 #endif
     test<short>(0);
     test<unsigned short>(0);

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/round_style.pass.cpp

 
 int main(int, char**)
 {
     test<bool, std::round_toward_zero>();
     test<char, std::round_toward_zero>();
     test<signed char, std::round_toward_zero>();
     test<unsigned char, std::round_toward_zero>();
     test<wchar_t, std::round_toward_zero>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, std::round_toward_zero>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, std::round_toward_zero>();
     test<char32_t, std::round_toward_zero>();
 #endif
     test<short, std::round_toward_zero>();
     test<unsigned short, std::round_toward_zero>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/signaling_NaN.pass.cpp

 
 int main(int, char**)
 {
     test<bool>();
     test<char>();
     test<signed char>();
     test<unsigned char>();
     test<wchar_t>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t>();
     test<char32_t>();
 #endif // _LIBCPP_HAS_NO_UNICODE_CHARS
     test<short>();
     test<unsigned short>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/tinyness_before.pass.cpp

 
 int main(int, char**)
 {
     test<bool, false>();
     test<char, false>();
     test<signed char, false>();
     test<unsigned char, false>();
     test<wchar_t, false>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, false>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, false>();
     test<char32_t, false>();
 #endif
     test<short, false>();
     test<unsigned short, false>();

libcxx/test/std/language.support/support.limits/limits/numeric.limits.members/traps.pass.cpp

 
 int main(int, char**)
 {
     test<bool, false>();
     test<char, integral_types_trap>();
     test<signed char, integral_types_trap>();
     test<unsigned char, integral_types_trap>();
     test<wchar_t, integral_types_trap>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t, integral_types_trap>();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     test<char16_t, integral_types_trap>();
     test<char32_t, integral_types_trap>();
 #endif
     test<short, integral_types_trap>();
     test<unsigned short, integral_types_trap>();

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

 #     error "__cpp_lib_atomic_wait should have the value 201907L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_atomic_wait
 #     error "__cpp_lib_atomic_wait should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) && !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"
-#   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_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"
+# endif
 
 #elif TEST_STD_VER > 20
 
 # if !defined(_LIBCPP_HAS_NO_THREADS)
 #   ifndef __cpp_lib_atomic_flag_test
 #     error "__cpp_lib_atomic_flag_test should be defined in c++2b"
 #   endif
 #   if __cpp_lib_atomic_flag_test != 201907L

 #     error "__cpp_lib_atomic_wait should have the value 201907L in c++2b"
 #   endif
 # else
 #   ifdef __cpp_lib_atomic_wait
 #     error "__cpp_lib_atomic_wait should not be defined when !defined(_LIBCPP_HAS_NO_THREADS) && !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"
-#   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_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"
+# endif
 
 #endif // TEST_STD_VER > 20
 
 int main(int, char**) { return 0; }

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

 # else
 #   ifdef __cpp_lib_filesystem
 #     error "__cpp_lib_filesystem should not be defined when !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem) 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++20"
-#   endif
-#   if __cpp_lib_char8_t != 201811L
-#     error "__cpp_lib_char8_t should have the value 201811L 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_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"
+# endif
 
 # if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)
 #   ifndef __cpp_lib_filesystem
 #     error "__cpp_lib_filesystem should be defined in c++20"
 #   endif
 #   if __cpp_lib_filesystem != 201703L
 #     error "__cpp_lib_filesystem should have the value 201703L in c++20"
 #   endif
 # else
 #   ifdef __cpp_lib_filesystem
 #     error "__cpp_lib_filesystem should not be defined when !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem) 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"
-#   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_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"
+# endif
 
 # if !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_filesystem)
 #   ifndef __cpp_lib_filesystem
 #     error "__cpp_lib_filesystem should be defined in c++2b"
 #   endif
 #   if __cpp_lib_filesystem != 201703L
 #     error "__cpp_lib_filesystem should have the value 201703L in c++2b"
 #   endif

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

 #elif TEST_STD_VER == 17
 
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++20"
 # 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"
-#   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_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"
+# 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"
-#   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_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"
+# endif
 
 #endif // TEST_STD_VER > 20
 
 int main(int, char**) { return 0; }

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

 #elif TEST_STD_VER == 17
 
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++20"
 # 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"
-#   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_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"
+# 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"
-#   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_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"
+# endif
 
 #endif // TEST_STD_VER > 20
 
 int main(int, char**) { return 0; }

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

 #elif TEST_STD_VER == 17
 
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++20"
 # 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"
-#   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_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"
+# 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"
-#   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_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"
+# endif
 
 #endif // TEST_STD_VER > 20
 
 int main(int, char**) { return 0; }

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

 #elif TEST_STD_VER == 17
 
 # ifdef __cpp_lib_char8_t
 #   error "__cpp_lib_char8_t should not be defined before c++20"
 # 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"
-#   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_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"
+# 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"
-#   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_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"
+# endif
 
 #endif // TEST_STD_VER > 20
 
 int main(int, char**) { return 0; }

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

 
 # ifndef __cpp_lib_allocator_traits_is_always_equal
 #   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++20"
 # endif
 # 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"
-#   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_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"
+# endif
 
 # ifndef __cpp_lib_constexpr_string
 #   error "__cpp_lib_constexpr_string should be defined in c++20"
 # endif
 # if __cpp_lib_constexpr_string != 201811L
 #   error "__cpp_lib_constexpr_string should have the value 201811L in c++20"
 # endif
 

 
 # ifndef __cpp_lib_allocator_traits_is_always_equal
 #   error "__cpp_lib_allocator_traits_is_always_equal should be defined in c++2b"
 # endif
 # 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"
-#   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_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"
+# endif
 
 # ifndef __cpp_lib_constexpr_string
 #   error "__cpp_lib_constexpr_string should be defined in c++2b"
 # endif
 # if __cpp_lib_constexpr_string != 201811L
 #   error "__cpp_lib_constexpr_string should have the value 201811L in c++2b"
 # endif
 

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

 #   error "__cpp_lib_string_view should be defined in c++17"
 # endif
 # if __cpp_lib_string_view != 201606L
 #   error "__cpp_lib_string_view should have the value 201606L in c++17"
 # 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"
-#   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_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"
+# endif
 
 # ifndef __cpp_lib_constexpr_string_view
 #   error "__cpp_lib_constexpr_string_view should be defined in c++20"
 # endif
 # if __cpp_lib_constexpr_string_view != 201811L
 #   error "__cpp_lib_constexpr_string_view should have the value 201811L in c++20"
 # endif
 

 #   error "__cpp_lib_string_view should be defined in c++20"
 # endif
 # if __cpp_lib_string_view != 201803L
 #   error "__cpp_lib_string_view should have the value 201803L in c++20"
 # 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"
-#   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_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"
+# endif
 
 # ifndef __cpp_lib_constexpr_string_view
 #   error "__cpp_lib_constexpr_string_view should be defined in c++2b"
 # endif
 # if __cpp_lib_constexpr_string_view != 201811L
 #   error "__cpp_lib_constexpr_string_view should have the value 201811L in c++2b"
 # endif
 

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

 
 # ifndef __cpp_lib_byte
 #   error "__cpp_lib_byte should be defined in c++20"
 # endif
 # if __cpp_lib_byte != 201603L
 #   error "__cpp_lib_byte should have the value 201603L 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"
-#   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_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"
+# endif
 
 # ifndef __cpp_lib_chrono
 #   error "__cpp_lib_chrono should be defined in c++20"
 # endif
 # if __cpp_lib_chrono != 201611L
 #   error "__cpp_lib_chrono should have the value 201611L in c++20"
 # endif
 

 
 # ifndef __cpp_lib_byte
 #   error "__cpp_lib_byte should be defined in c++2b"
 # endif
 # if __cpp_lib_byte != 201603L
 #   error "__cpp_lib_byte should have the value 201603L 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"
-#   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_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"
+# endif
 
 # ifndef __cpp_lib_chrono
 #   error "__cpp_lib_chrono should be defined in c++2b"
 # endif
 # if __cpp_lib_chrono != 201611L
 #   error "__cpp_lib_chrono should have the value 201611L in c++2b"
 # endif
 

libcxx/test/std/strings/basic.string.hash/char_type_hash.fail.cpp

struct trait // copied from <__string>
     static inline int_type eof() { return int_type(EOF); }
 };
 
 template <class CharT>
 void test() {
     typedef std::basic_string<CharT, trait<CharT> > str_t;
     std::hash<str_t>
         h; // expected-error-re 4 {{{{call to implicitly-deleted default constructor of 'std::hash<str_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     // expected-error-re@-2 {{{{call to implicitly-deleted default constructor of 'std::hash<str_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
 #endif
     (void)h;
 }
 
 int main(int, char**) {
     test<char>();
     test<wchar_t>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t>();
 #endif
     test<char16_t>();
     test<char32_t>();
 
     return 0;
 }

libcxx/test/std/strings/string.view/string.view.hash/char_type.hash.fail.cpp

struct trait // copied from <__string>
     static inline int_type eof() { return int_type(EOF); }
 };
 
 template <class CharT>
 void test() {
     typedef std::basic_string_view<CharT, trait<CharT> > strv_t;
     std::hash<strv_t>
         h; // expected-error-re 4 {{{{call to implicitly-deleted default constructor of 'std::hash<strv_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     // expected-error-re@-2 {{{{call to implicitly-deleted default constructor of 'std::hash<strv_t>'|implicit instantiation of undefined template}} {{.+}}}}}}
 #endif
     (void)h;
 }
 
 int main(int, char**) {
     test<char>();
     test<wchar_t>();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     test<char8_t>();
 #endif
     test<char16_t>();
     test<char32_t>();
 
     return 0;
 }

libcxx/test/support/atomic_helpers.h

void operator()() const {
     TestFunctor<unsigned short>()();
     TestFunctor<int>()();
     TestFunctor<unsigned int>()();
     TestFunctor<long>()();
     TestFunctor<unsigned long>()();
     TestFunctor<long long>()();
     TestFunctor<unsigned long long>()();
     TestFunctor<wchar_t>()();
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
     TestFunctor<char8_t>()();
 #endif
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
     TestFunctor<char16_t>()();
     TestFunctor<char32_t>()();
 #endif
     TestFunctor<int8_t>()();
     TestFunctor<uint8_t>()();

libcxx/test/support/make_string.h

 //===----------------------------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SUPPORT_TEST_MAKE_STRING_H
 #define SUPPORT_TEST_MAKE_STRING_H
 
 #include "test_macros.h"
 
 #if TEST_STD_VER < 11
 #error This header requires C++11 or greater
 #endif
 
 #include <string>
 
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
 #define CHAR8_ONLY(x) x,
 #else
 #define CHAR8_ONLY(x)
 #endif
 
 #define MKSTR(Str)                                                             \
   {                                                                            \
     Str, TEST_CONCAT(L, Str),                                                  \
         CHAR8_ONLY(TEST_CONCAT(u8, Str)) TEST_CONCAT(u, Str),                  \
         TEST_CONCAT(U, Str)                                                    \
   }
 
 struct MultiStringType {
   const char* s;
   const wchar_t* w;
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
   const char8_t* u8;
 #endif
   const char16_t* u16;
   const char32_t* u32;
 
   constexpr operator const char*() const { return s; }
   constexpr operator const wchar_t*() const { return w; }
-#if TEST_STD_VER > 17 && defined(__cpp_char8_t)
+#if TEST_STD_VER > 17
   constexpr operator const char8_t*() const { return u8; }
 #endif
   constexpr operator const char16_t*() const { return u16; }
   constexpr operator const char32_t*() const { return u32; }
 };
 
 // Helper to convert a const char* string to a basic_string<CharT>.
 // This helper is used in unit tests to make them generic. The input should be

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
   }, {
     "name": "__cpp_lib_byte",
     "values": { "c++17": 201603 },
     "headers": ["cstddef"],
   }, {
     "name": "__cpp_lib_char8_t",
     "values": { "c++20": 201811 },
     "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"],
   }, {
     "name": "__cpp_lib_chrono_udls",
     "values": { "c++14": 201304 },
     "headers": ["chrono"],