[libc++] [P0482] [C++20] Implement missing bits for codecvt and codecvt_byname.

[curdeius]

Summary

Add codecvt*<char16_t, char8_t> and codecvt*<char32_t, char8_t>.
Deprecate codecvt<char(16|32)_t, char>.
Enable disabled tests.
Update _LIBCPP_STD_VER to use 20 for C++20. Add _LIBCPP_DEPRECATED_IN_CXX20 macro.

[curdeius]

• Clean up.

[curdeius]

• Get rid of unused __char8_t.

[curdeius]

Buildkite shows build failures with undefined references.
That's because libc++ (.so, .a) is compiled using -std=c++17 and I used #ifndef _LIBCPP_NO_HAS_CHAR8_T to guard the char8_t-related things.

_LIBCPP_NO_HAS_CHAR8_T is defined as:

#if _LIBCPP_STD_VER <= 17 || !defined(__cpp_char8_t)
#define _LIBCPP_NO_HAS_CHAR8_T
#endif

So, in the failing cases, src/ compiles with C++17 and so without char8_t, but include/ and test/ compile with C++20.

I haven't seen these failures locally before because I was compiling everything in C++20 mode (CXX_STANDARD 20 in libcxx/CMakeLists.txt).

I see 2 possible solutions:

1. Use CXX_STANDARD 20, but it might be an overkill.
2. Change guards in locale.cpp to just #ifdef __cpp_char8_t instead of #ifndef _LIBCPP_NO_HAS_CHAR8_T.

WDYT?

[ldionne]

In D91517#2399385, @curdeius wrote:

Buildkite shows build failures with undefined references.
That's because libc++ (.so, .a) is compiled using -std=c++17 and I used #ifndef _LIBCPP_NO_HAS_CHAR8_T to guard the char8_t-related things.

_LIBCPP_NO_HAS_CHAR8_T is defined as:

#if _LIBCPP_STD_VER <= 17 || !defined(__cpp_char8_t)
#define _LIBCPP_NO_HAS_CHAR8_T
#endif

So, in the failing cases, src/ compiles with C++17 and so without char8_t, but include/ and test/ compile with C++20.

I haven't seen these failures locally before because I was compiling everything in C++20 mode (CXX_STANDARD 20 in libcxx/CMakeLists.txt).

I see 2 possible solutions:

1. Use CXX_STANDARD 20, but it might be an overkill.

I think that is the right way to go. I think it makes sense to build the library with the latest standard available.

Furthermore, once we have moved people over to the runtimes build and we know that folks are building the library with a recent compiler, we should even be able to assume that the compiler provides char8_t.

libcxx/include/__locale

1252

I think it should be marked as deprecated whenever the standard says it is.

[curdeius]

Ok, thank you for your input. I'll update the things as necessary.

[curdeius]

• Use C++20 for libc++. Should we require standard? Or should we change to CXX_STANDARD_REQUIRED NO?
• Remove TODOs.

[curdeius]

• Disable deprecation warnings in forgotten tests.

[curdeius]

I'll create a new revision with only the bump of the C++ standard version, because that provokes some failures it seems.

[curdeius]

• Fix more deprecated warnings.

[curdeius]

Use C++20 in libc++abi too.

[curdeius]

Rebase

[curdeius]

• Rebase on top of D91691 to fix patch apply

[curdeius]

• Fix extra allocation for additional facets.
• Rebase.

[ldionne]

LGTM if CI passes, thanks!

[ldionne]

Does this pass check-cxx-abilist? It needs to. I think you may need to update the ABI lists.

[curdeius]

Ok, thanks. I still need to update ABI list and fix macOS backdeployment.

[ldionne]

I would suggest you wait for me to submit D92194 and then rebase on top of it. That'll provide you with additional coverage for the ABI lists. My goal with D92194 was specifically to make sure the CI would catch issues with ABI lists in changes like yours :-). Requesting changes so it shows up right in the queue.

[curdeius]

• Mark test as XFAIL on macosx10.*.

[curdeius]

Ok. Will wait for your patch. I just added XFAIL for macosx dylibs.

[ldionne]

In D91517#2419547, @curdeius wrote:

Ok. Will wait for your patch. I just added XFAIL for macosx dylibs.

Can you confirm that the issues you were seeing on older macOSes are that the tests are now exercising char8_t codecvt, so you're seeing runtime errors since those are not installed in older dylibs? I'm trying to make sure we understand the issue and don't silent something important.

[curdeius]

In D91517#2420181, @ldionne wrote:

In D91517#2419547, @curdeius wrote:

Ok. Will wait for your patch. I just added XFAIL for macosx dylibs.

Can you confirm that the issues you were seeing on older macOSes are that the tests are now exercising char8_t codecvt, so you're seeing runtime errors since those are not installed in older dylibs? I'm trying to make sure we understand the issue and don't silent something important.

Yes, all the 33 test failures in https://buildkite.com/llvm-project/libcxx-ci/builds/578#4979bae1-6f90-4d3a-a17e-9b9981aaedbf
were due to missing symbols, e.g.:

dyld: Symbol not found: __ZNKSt3__17codecvtIDiDu11__mbstate_tE10do_unshiftERS1_PDuS4_RS4_
  Referenced from: /private/tmp/buildkite-agent/builds/libcxx-mbp-local-1/llvm-project/libcxx-ci/build/x86_64-apple-system-backdeployment-10.9/projects/libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/Output/ctor_char32_t_char8_t.pass.cpp.dir/t.tmp.exe
  Expected in: /private/tmp/buildkite-agent/builds/libcxx-mbp-local-1/llvm-project/libcxx-ci/build/x86_64-apple-system-backdeployment-10.9/macos-roots/macOS/libc++/10.9/libc++.1.dylib

[curdeius]

• [abi] Update ABI list for linux (and changelog).
• Rebase to include changes from D92194

[curdeius]

• Fix linux ABI list.
• Re-generate ABI list (after a failed check) and get them as artifacts, so as to ease the development for contributors not having access to necessary platform.

[curdeius]

• Fix linux ABI list (again).
• Add forgotten artifact_paths.

[curdeius]

@ldionne, I've modified the run-buildbot script (and added *.abilist to artifact_paths in buildkite-pipeline.yml) so as to run generate-cxx-abilist if check-cxx-abilist failed.
The build will fail anyway but the regenerated ABI lists will be present among the artifacts.
That's for people, like me, that don't have access to one of the platforms on which we check ABI lists.
If you prefer, I'll spin off another patch to keep things apart.

[curdeius]

• Fix macOS ABI list.

[ldionne]

Nice! I love how we're building on top of the CI infrastructure to make our life simpler.

If you commit this before me, I'll rebase D92212 on top.

libcxx/CMakeLists.txt

 # FIXME(EricWF): See the FIXME on LIBCXX_ENABLE_PEDANTIC.
 # Remove the -pedantic flag and -Wno-pedantic and -pedantic-errors
 # so they don't get transformed into -Wno and -errors respectively.
 remove_flags(-Wno-pedantic -pedantic-errors -pedantic)
 
 # Required flags ==============================================================
 function(cxx_add_basic_build_flags target)
 
-  # Require C++17 for all targets. C++17 is needed to use aligned allocation
-  # in the dylib.
+  # Require C++20 for all targets. C++17 is needed to use aligned allocation
+  # in the dylib. C++20 is needed to use char8_t.
   set_target_properties(${target} PROPERTIES
-    CXX_STANDARD 17
+    CXX_STANDARD 20
     CXX_STANDARD_REQUIRED YES
     CXX_EXTENSIONS NO)
 
   # When building the dylib, don't warn for unavailable aligned allocation
   # functions based on the deployment target -- they are always available
   # because they are provided by the dylib itself with the excepton of z/OS.
   if (ZOS)
     target_add_compile_flags_if_supported(${target} PRIVATE -fno-aligned-allocation)

libcxx/include/__config

 #ifndef _LIBCPP_STD_VER
 #  if  __cplusplus <= 201103L
 #    define _LIBCPP_STD_VER 11
 #  elif __cplusplus <= 201402L
 #    define _LIBCPP_STD_VER 14
 #  elif __cplusplus <= 201703L
 #    define _LIBCPP_STD_VER 17
 #  else
-#    define _LIBCPP_STD_VER 18  // current year, or date of c++2a ratification
+#    define _LIBCPP_STD_VER 20  // current year, or date of c++2a ratification
 #  endif
 #endif  // _LIBCPP_STD_VER
 
 #if defined(__ELF__)
 #  define _LIBCPP_OBJECT_FORMAT_ELF   1
 #elif defined(__MACH__)
 #  define _LIBCPP_OBJECT_FORMAT_MACHO 1
 #elif defined(_WIN32)

 #endif
 
 #if _LIBCPP_STD_VER >= 17
 #  define _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_DEPRECATED
 #else
 #  define _LIBCPP_DEPRECATED_IN_CXX17
 #endif
 
+#if _LIBCPP_STD_VER >= 20
+#  define _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_DEPRECATED
+#else
+#  define _LIBCPP_DEPRECATED_IN_CXX20
+#endif
+
 // Macros to enter and leave a state where deprecation warnings are suppressed.
 #if !defined(_LIBCPP_SUPPRESS_DEPRECATED_PUSH) && \
     (defined(_LIBCPP_COMPILER_CLANG) || defined(_LIBCPP_COMPILER_GCC))
 #  define _LIBCPP_SUPPRESS_DEPRECATED_PUSH \
     _Pragma("GCC diagnostic push") \
     _Pragma("GCC diagnostic ignored \"-Wdeprecated\"")
 #  define _LIBCPP_SUPPRESS_DEPRECATED_POP \
     _Pragma("GCC diagnostic pop")

libcxx/include/__locale

static const char* __setlocale(const char* __locale) {
         __throw_bad_alloc();
       return __new_locale;
     }
     int __status;
     char* __locale_all = nullptr;
 };
 #endif
 
-
 class _LIBCPP_TYPE_VIS locale;
 
 template <class _Facet>
 _LIBCPP_INLINE_VISIBILITY
 bool
 has_facet(const locale&) _NOEXCEPT;
 
 template <class _Facet>
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;
 };
 
-// template <> class codecvt<char16_t, char, mbstate_t>
+// template <> class codecvt<char16_t, char, mbstate_t> // deprecated in C++20
 
 template <>
-class _LIBCPP_TYPE_VIS codecvt<char16_t, char, mbstate_t>
+class _LIBCPP_TYPE_VIS _LIBCPP_DEPRECATED_IN_CXX20 codecvt<char16_t, char, mbstate_t>
     : public locale::facet,
       public codecvt_base
 {
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
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;
 };
 
-// template <> class codecvt<char32_t, char, mbstate_t>
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+
+// 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
+{
+public:
+    typedef char16_t  intern_type;
+    typedef char8_t   extern_type;
+    typedef mbstate_t state_type;
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit codecvt(size_t __refs = 0)
+        : locale::facet(__refs) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    result out(state_type& __st,
+               const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
+               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
+    {
+        return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    result unshift(state_type& __st,
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
+    {
+        return do_unshift(__st, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    result in(state_type& __st,
+              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
+    {
+        return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    int encoding() const  _NOEXCEPT
+    {
+        return do_encoding();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool always_noconv() const  _NOEXCEPT
+    {
+        return do_always_noconv();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
+    {
+        return do_length(__st, __frm, __end, __mx);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    int max_length() const  _NOEXCEPT
+    {
+        return do_max_length();
+    }
+
+    static locale::id id;
+
+protected:
+    _LIBCPP_INLINE_VISIBILITY
+    explicit codecvt(const char*, size_t __refs = 0)
+        : locale::facet(__refs) {}
+
+    ~codecvt();
+
+    virtual result do_out(state_type& __st,
+                          const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
+                          extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+    virtual result do_in(state_type& __st,
+                         const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
+    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
+
+// template <> class codecvt<char32_t, char, mbstate_t> // deprecated in C++20
 
 template <>
-class _LIBCPP_TYPE_VIS codecvt<char32_t, char, mbstate_t>
+class _LIBCPP_TYPE_VIS _LIBCPP_DEPRECATED_IN_CXX20 codecvt<char32_t, char, mbstate_t>
     : public locale::facet,
       public codecvt_base
 {
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
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_NO_HAS_CHAR8_T
+
+// 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
+{
+public:
+    typedef char32_t  intern_type;
+    typedef char8_t   extern_type;
+    typedef mbstate_t state_type;
+
+    _LIBCPP_INLINE_VISIBILITY
+    explicit codecvt(size_t __refs = 0)
+        : locale::facet(__refs) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    result out(state_type& __st,
+               const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
+               extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
+    {
+        return do_out(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    result unshift(state_type& __st,
+                   extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const
+    {
+        return do_unshift(__st, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    result in(state_type& __st,
+              const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+              intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const
+    {
+        return do_in(__st, __frm, __frm_end, __frm_nxt, __to, __to_end, __to_nxt);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    int encoding() const  _NOEXCEPT
+    {
+        return do_encoding();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    bool always_noconv() const  _NOEXCEPT
+    {
+        return do_always_noconv();
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    int length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const
+    {
+        return do_length(__st, __frm, __end, __mx);
+    }
+
+    _LIBCPP_INLINE_VISIBILITY
+    int max_length() const  _NOEXCEPT
+    {
+        return do_max_length();
+    }
+
+    static locale::id id;
+
+protected:
+    _LIBCPP_INLINE_VISIBILITY
+    explicit codecvt(const char*, size_t __refs = 0)
+        : locale::facet(__refs) {}
+
+    ~codecvt();
+
+    virtual result do_out(state_type& __st,
+                          const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
+                          extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
+    virtual result do_in(state_type& __st,
+                         const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
+                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
+    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
+
 // 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_INLINE_VISIBILITY
     explicit codecvt_byname(const char* __nm, size_t __refs = 0)
         : codecvt<_InternT, _ExternT, _StateT>(__nm, __refs) {}
     _LIBCPP_INLINE_VISIBILITY
     explicit codecvt_byname(const string& __nm, size_t __refs = 0)
         : codecvt<_InternT, _ExternT, _StateT>(__nm.c_str(), __refs) {}
 protected:
     ~codecvt_byname();
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _InternT, class _ExternT, class _StateT>
 codecvt_byname<_InternT, _ExternT, _StateT>::~codecvt_byname()
 {
 }
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char, char, mbstate_t>)
 _LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<wchar_t, char, mbstate_t>)
-_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char16_t, char, mbstate_t>)
-_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char32_t, char, mbstate_t>)
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_DEPRECATED_IN_CXX20 codecvt_byname<char16_t, char, mbstate_t>) // deprecated in C++20
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS _LIBCPP_DEPRECATED_IN_CXX20 codecvt_byname<char32_t, char, mbstate_t>) // deprecated in C++20
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+_LIBCPP_EXTERN_TEMPLATE(class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS codecvt_byname<char16_t, char8_t, mbstate_t>) // C++20
+_LIBCPP_EXTERN_TEMPLATE(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>
     _OutputIterator
     operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const;
 };
 
 template <>
 struct __narrow_to_utf8<8>
 {
     template <class _OutputIterator, class _CharT>
     _LIBCPP_INLINE_VISIBILITY
     _OutputIterator
     operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
     {
         for (; __wb < __we; ++__wb, ++__s)
             *__s = *__wb;
         return __s;
     }
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 struct _LIBCPP_TEMPLATE_VIS __narrow_to_utf8<16>
     : public codecvt<char16_t, char, mbstate_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     __narrow_to_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
     _LIBCPP_EXPORTED_FROM_ABI ~__narrow_to_utf8();
 
     template <class _OutputIterator, class _CharT>
     _LIBCPP_INLINE_VISIBILITY
     _OutputIterator
     operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
     {
operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
             for (const char* __p = __buf; __p < __bn; ++__p, ++__s)
                 *__s = *__p;
             __wb = (const _CharT*)__wn;
         }
         return __s;
     }
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 struct _LIBCPP_TEMPLATE_VIS __narrow_to_utf8<32>
     : public codecvt<char32_t, char, mbstate_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     __narrow_to_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
     _LIBCPP_EXPORTED_FROM_ABI ~__narrow_to_utf8();
 
     template <class _OutputIterator, class _CharT>
     _LIBCPP_INLINE_VISIBILITY
     _OutputIterator
     operator()(_OutputIterator __s, const _CharT* __wb, const _CharT* __we) const
     {
struct __widen_from_utf8<8>
     operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
     {
         for (; __nb < __ne; ++__nb, ++__s)
             *__s = *__nb;
         return __s;
     }
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 struct _LIBCPP_TEMPLATE_VIS __widen_from_utf8<16>
     : public codecvt<char16_t, char, mbstate_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     __widen_from_utf8() : codecvt<char16_t, char, mbstate_t>(1) {}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
     _LIBCPP_EXPORTED_FROM_ABI ~__widen_from_utf8();
 
     template <class _OutputIterator>
     _LIBCPP_INLINE_VISIBILITY
     _OutputIterator
     operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
     {
operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
             for (const char16_t* __p = __buf; __p < __bn; ++__p, ++__s)
                 *__s = *__p;
             __nb = __nn;
         }
         return __s;
     }
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 struct _LIBCPP_TEMPLATE_VIS __widen_from_utf8<32>
     : public codecvt<char32_t, char, mbstate_t>
 {
     _LIBCPP_INLINE_VISIBILITY
     __widen_from_utf8() : codecvt<char32_t, char, mbstate_t>(1) {}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
     _LIBCPP_EXPORTED_FROM_ABI ~__widen_from_utf8();
 
     template <class _OutputIterator>
     _LIBCPP_INLINE_VISIBILITY
     _OutputIterator
     operator()(_OutputIterator __s, const char* __nb, const char* __ne) const
     {

libcxx/include/codecvt

virtual result
                    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;
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8<char16_t>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     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;
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8<char32_t>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
virtual result
                    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;
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, false>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     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;
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<char16_t, true>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     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;
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, false>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     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;
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf16<char32_t, true>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
virtual result
                    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;
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char32_t>
     : public codecvt<char32_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char32_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char32_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,
               intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
     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;
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <>
 class _LIBCPP_TYPE_VIS __codecvt_utf8_utf16<char16_t>
     : public codecvt<char16_t, char, mbstate_t>
 {
     unsigned long _Maxcode_;
     codecvt_mode _Mode_;
 public:
     typedef char16_t  intern_type;
     typedef char      extern_type;
     typedef mbstate_t state_type;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __codecvt_utf8_utf16(size_t __refs, unsigned long _Maxcode,
                             codecvt_mode _Mode)
         : codecvt<char16_t, char, mbstate_t>(__refs), _Maxcode_(_Maxcode),
           _Mode_(_Mode) {}
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+
 protected:
     virtual result
         do_out(state_type& __st,
                const intern_type* __frm, const intern_type* __frm_end, const intern_type*& __frm_nxt,
                extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
     virtual result
         do_in(state_type& __st,
               const extern_type* __frm, const extern_type* __frm_end, const extern_type*& __frm_nxt,

libcxx/src/locale.cpp

 {
     facets_.clear();
     install(&make<_VSTD::collate<char> >(1u));
     install(&make<_VSTD::collate<wchar_t> >(1u));
     install(&make<_VSTD::ctype<char> >(nullptr, false, 1u));
     install(&make<_VSTD::ctype<wchar_t> >(1u));
     install(&make<codecvt<char, char, mbstate_t> >(1u));
     install(&make<codecvt<wchar_t, char, mbstate_t> >(1u));
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
     install(&make<codecvt<char16_t, char, mbstate_t> >(1u));
     install(&make<codecvt<char32_t, char, mbstate_t> >(1u));
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+    install(&make<codecvt<char16_t, char8_t, mbstate_t> >(1u));
+    install(&make<codecvt<char32_t, char8_t, mbstate_t> >(1u));
+#endif
     install(&make<numpunct<char> >(1u));
     install(&make<numpunct<wchar_t> >(1u));
     install(&make<num_get<char> >(1u));
     install(&make<num_get<wchar_t> >(1u));
     install(&make<num_put<char> >(1u));
     install(&make<num_put<wchar_t> >(1u));
     install(&make<moneypunct<char, false> >(1u));
     install(&make<moneypunct<char, true> >(1u));
#endif  // _LIBCPP_NO_EXCEPTIONS
             if (facets_[i])
                 facets_[i]->__add_shared();
         install(new collate_byname<char>(name_));
         install(new collate_byname<wchar_t>(name_));
         install(new ctype_byname<char>(name_));
         install(new ctype_byname<wchar_t>(name_));
         install(new codecvt_byname<char, char, mbstate_t>(name_));
         install(new codecvt_byname<wchar_t, char, mbstate_t>(name_));
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
         install(new codecvt_byname<char16_t, char, mbstate_t>(name_));
         install(new codecvt_byname<char32_t, char, mbstate_t>(name_));
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+        install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name_));
+        install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name_));
+#endif
         install(new numpunct_byname<char>(name_));
         install(new numpunct_byname<wchar_t>(name_));
         install(new moneypunct_byname<char, false>(name_));
         install(new moneypunct_byname<char, true>(name_));
         install(new moneypunct_byname<wchar_t, false>(name_));
         install(new moneypunct_byname<wchar_t, true>(name_));
         install(new time_get_byname<char>(name_));
         install(new time_get_byname<wchar_t>(name_));
#endif  // _LIBCPP_NO_EXCEPTIONS
             install(new collate_byname<wchar_t>(name));
         }
         if (c & locale::ctype)
         {
             install(new ctype_byname<char>(name));
             install(new ctype_byname<wchar_t>(name));
             install(new codecvt_byname<char, char, mbstate_t>(name));
             install(new codecvt_byname<wchar_t, char, mbstate_t>(name));
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
             install(new codecvt_byname<char16_t, char, mbstate_t>(name));
             install(new codecvt_byname<char32_t, char, mbstate_t>(name));
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+            install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name));
+            install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name));
+#endif
         }
         if (c & locale::monetary)
         {
             install(new moneypunct_byname<char, false>(name));
             install(new moneypunct_byname<char, true>(name));
             install(new moneypunct_byname<wchar_t, false>(name));
             install(new moneypunct_byname<wchar_t, true>(name));
         }
#endif  // _LIBCPP_NO_EXCEPTIONS
             install_from<_VSTD::collate<char> >(one);
             install_from<_VSTD::collate<wchar_t> >(one);
         }
         if (c & locale::ctype)
         {
             install_from<_VSTD::ctype<char> >(one);
             install_from<_VSTD::ctype<wchar_t> >(one);
             install_from<_VSTD::codecvt<char, char, mbstate_t> >(one);
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
             install_from<_VSTD::codecvt<char16_t, char, mbstate_t> >(one);
             install_from<_VSTD::codecvt<char32_t, char, mbstate_t> >(one);
+_LIBCPP_SUPPRESS_DEPRECATED_POP
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+            install_from<_VSTD::codecvt<char16_t, char8_t, mbstate_t> >(one);
+            install_from<_VSTD::codecvt<char32_t, char8_t, mbstate_t> >(one);
+#endif
             install_from<_VSTD::codecvt<wchar_t, char, mbstate_t> >(one);
         }
         if (c & locale::monetary)
         {
             install_from<moneypunct<char, false> >(one);
             install_from<moneypunct<char, true> >(one);
             install_from<moneypunct<wchar_t, false> >(one);
             install_from<moneypunct<wchar_t, true> >(one);

 }
 
 int
 codecvt<char16_t, char, mbstate_t>::do_max_length() const  _NOEXCEPT
 {
     return 4;
 }
 
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+
+// template <> class codecvt<char16_t, char8_t, mbstate_t>
+
+locale::id codecvt<char16_t, char8_t, mbstate_t>::id;
+
+codecvt<char16_t, char8_t, mbstate_t>::~codecvt()
+{
+}
+
+codecvt<char16_t, char8_t, mbstate_t>::result
+codecvt<char16_t, char8_t, mbstate_t>::do_out(state_type&,
+    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
+    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
+{
+    const uint16_t* _frm = reinterpret_cast<const uint16_t*>(frm);
+    const uint16_t* _frm_end = reinterpret_cast<const uint16_t*>(frm_end);
+    const uint16_t* _frm_nxt = _frm;
+    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
+    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
+    uint8_t* _to_nxt = _to;
+    result r = utf16_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
+    frm_nxt = frm + (_frm_nxt - _frm);
+    to_nxt = to + (_to_nxt - _to);
+    return r;
+}
+
+codecvt<char16_t, char8_t, mbstate_t>::result
+codecvt<char16_t, char8_t, mbstate_t>::do_in(state_type&,
+    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
+    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
+{
+    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
+    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+    const uint8_t* _frm_nxt = _frm;
+    uint16_t* _to = reinterpret_cast<uint16_t*>(to);
+    uint16_t* _to_end = reinterpret_cast<uint16_t*>(to_end);
+    uint16_t* _to_nxt = _to;
+    result r = utf8_to_utf16(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
+    frm_nxt = frm + (_frm_nxt - _frm);
+    to_nxt = to + (_to_nxt - _to);
+    return r;
+}
+
+codecvt<char16_t, char8_t, mbstate_t>::result
+codecvt<char16_t, char8_t, mbstate_t>::do_unshift(state_type&,
+    extern_type* to, extern_type*, extern_type*& to_nxt) const
+{
+    to_nxt = to;
+    return noconv;
+}
+
+int
+codecvt<char16_t, char8_t, mbstate_t>::do_encoding() const  _NOEXCEPT
+{
+    return 0;
+}
+
+bool
+codecvt<char16_t, char8_t, mbstate_t>::do_always_noconv() const  _NOEXCEPT
+{
+    return false;
+}
+
+int
+codecvt<char16_t, char8_t, mbstate_t>::do_length(state_type&,
+    const extern_type* frm, const extern_type* frm_end, size_t mx) const
+{
+    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
+    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+    return utf8_to_utf16_length(_frm, _frm_end, mx);
+}
+
+int
+codecvt<char16_t, char8_t, mbstate_t>::do_max_length() const  _NOEXCEPT
+{
+    return 4;
+}
+
+#endif
+
 // template <> class codecvt<char32_t, char, mbstate_t>
 
 locale::id codecvt<char32_t, char, mbstate_t>::id;
 
 codecvt<char32_t, char, mbstate_t>::~codecvt()
 {
 }
 

 }
 
 int
 codecvt<char32_t, char, mbstate_t>::do_max_length() const  _NOEXCEPT
 {
     return 4;
 }
 
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+
+// template <> class codecvt<char32_t, char8_t, mbstate_t>
+
+locale::id codecvt<char32_t, char8_t, mbstate_t>::id;
+
+codecvt<char32_t, char8_t, mbstate_t>::~codecvt()
+{
+}
+
+codecvt<char32_t, char8_t, mbstate_t>::result
+codecvt<char32_t, char8_t, mbstate_t>::do_out(state_type&,
+    const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
+    extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
+{
+    const uint32_t* _frm = reinterpret_cast<const uint32_t*>(frm);
+    const uint32_t* _frm_end = reinterpret_cast<const uint32_t*>(frm_end);
+    const uint32_t* _frm_nxt = _frm;
+    uint8_t* _to = reinterpret_cast<uint8_t*>(to);
+    uint8_t* _to_end = reinterpret_cast<uint8_t*>(to_end);
+    uint8_t* _to_nxt = _to;
+    result r = ucs4_to_utf8(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
+    frm_nxt = frm + (_frm_nxt - _frm);
+    to_nxt = to + (_to_nxt - _to);
+    return r;
+}
+
+codecvt<char32_t, char8_t, mbstate_t>::result
+codecvt<char32_t, char8_t, mbstate_t>::do_in(state_type&,
+    const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
+    intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
+{
+    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
+    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+    const uint8_t* _frm_nxt = _frm;
+    uint32_t* _to = reinterpret_cast<uint32_t*>(to);
+    uint32_t* _to_end = reinterpret_cast<uint32_t*>(to_end);
+    uint32_t* _to_nxt = _to;
+    result r = utf8_to_ucs4(_frm, _frm_end, _frm_nxt, _to, _to_end, _to_nxt);
+    frm_nxt = frm + (_frm_nxt - _frm);
+    to_nxt = to + (_to_nxt - _to);
+    return r;
+}
+
+codecvt<char32_t, char8_t, mbstate_t>::result
+codecvt<char32_t, char8_t, mbstate_t>::do_unshift(state_type&,
+    extern_type* to, extern_type*, extern_type*& to_nxt) const
+{
+    to_nxt = to;
+    return noconv;
+}
+
+int
+codecvt<char32_t, char8_t, mbstate_t>::do_encoding() const  _NOEXCEPT
+{
+    return 0;
+}
+
+bool
+codecvt<char32_t, char8_t, mbstate_t>::do_always_noconv() const  _NOEXCEPT
+{
+    return false;
+}
+
+int
+codecvt<char32_t, char8_t, mbstate_t>::do_length(state_type&,
+    const extern_type* frm, const extern_type* frm_end, size_t mx) const
+{
+    const uint8_t* _frm = reinterpret_cast<const uint8_t*>(frm);
+    const uint8_t* _frm_end = reinterpret_cast<const uint8_t*>(frm_end);
+    return utf8_to_ucs4_length(_frm, _frm_end, mx);
+}
+
+int
+codecvt<char32_t, char8_t, mbstate_t>::do_max_length() const  _NOEXCEPT
+{
+    return 4;
+}
+
+#endif
+
 // __codecvt_utf8<wchar_t>
 
 __codecvt_utf8<wchar_t>::result
 __codecvt_utf8<wchar_t>::do_out(state_type&,
     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
 {
 #if defined(_LIBCPP_SHORT_WCHAR)

 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages<wchar_t>;
 
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<char>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS messages_byname<wchar_t>;
 
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char, char, mbstate_t>;
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<wchar_t, char, mbstate_t>;
-template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char, mbstate_t>;
-template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char, mbstate_t>;
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS _LIBCPP_DEPRECATED_IN_CXX20 codecvt_byname<char16_t, char, mbstate_t>;
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS _LIBCPP_DEPRECATED_IN_CXX20 codecvt_byname<char32_t, char, mbstate_t>;
+#ifndef _LIBCPP_NO_HAS_CHAR8_T
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char16_t, char8_t, mbstate_t>;
+template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS codecvt_byname<char32_t, char8_t, mbstate_t>;
+#endif
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/codecvt_byname_char16_t_char.depr_in_cxx20.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
-// template <> class codecvt<char16_t, char, mbstate_t>
+// codecvt_byname<char16_t, char, mbstate_t>
+//  deprecated in C++20
 
-// bool always_noconv() const throw();
+// UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <locale>
-#include <cassert>
 
+#include "../with_public_dtor.hpp"
 #include "test_macros.h"
 
-typedef std::codecvt<char16_t, char, std::mbstate_t> F;
-
-int main(int, char**)
+int main(int, char **)
 {
-    std::locale l = std::locale::classic();
-    const F& f = std::use_facet<F>(l);
-    assert(!f.always_noconv());
+    with_public_dtor<std::codecvt_byname<char16_t, char, std::mbstate_t>> cvt("", 0); // expected-warning {{'codecvt_byname<char16_t, char, __mbstate_t>' is deprecated}}
+    (void)cvt;
 
     return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/codecvt_byname_char32_t_char.depr_in_cxx20.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
-// template <> class codecvt<char16_t, char, mbstate_t>
+// codecvt_byname<char32_t, char, mbstate_t>
+//  deprecated in C++20
 
-// bool always_noconv() const throw();
+// UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <locale>
-#include <cassert>
 
+#include "../with_public_dtor.hpp"
 #include "test_macros.h"
 
-typedef std::codecvt<char16_t, char, std::mbstate_t> F;
-
-int main(int, char**)
+int main(int, char **)
 {
-    std::locale l = std::locale::classic();
-    const F& f = std::use_facet<F>(l);
-    assert(!f.always_noconv());
+    with_public_dtor<std::codecvt_byname<char32_t, char, std::mbstate_t>> cvt("", 0); // expected-warning {{'codecvt_byname<char32_t, char, __mbstate_t>' is deprecated}}
+    (void)cvt;
 
     return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char16_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt_byname<char16_t, char, mbstate_t>
 
 // explicit codecvt_byname(const char* nm, size_t refs = 0);
 // explicit codecvt_byname(const string& nm, size_t refs = 0);
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt_byname<char16_t, char, std::mbstate_t> F;
 
 class my_facet

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char16_t_char8_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
-// template <> class codecvt_byname<char16_t, char, mbstate_t>
+// template <> class codecvt_byname<char16_t, char8_t, mbstate_t>
 
 // explicit codecvt_byname(const char* nm, size_t refs = 0);
 // explicit codecvt_byname(const string& nm, size_t refs = 0);
 
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
-typedef std::codecvt_byname<char16_t, char, std::mbstate_t> F;
+typedef std::codecvt_byname<char16_t, char8_t, std::mbstate_t> F;
 
 class my_facet
     : public F
 {
 public:
     static int count;
 
     explicit my_facet(const char* nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char32_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt_byname<char32_t, char, mbstate_t>
 
 // explicit codecvt_byname(const char* nm, size_t refs = 0);
 // explicit codecvt_byname(const string& nm, size_t refs = 0);
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt_byname<char32_t, char, std::mbstate_t> F;
 
 class my_facet

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt.byname/ctor_char32_t_char8_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
-// template <> class codecvt_byname<char16_t, char, mbstate_t>
+// template <> class codecvt_byname<char32_t, char8_t, mbstate_t>
 
 // explicit codecvt_byname(const char* nm, size_t refs = 0);
 // explicit codecvt_byname(const string& nm, size_t refs = 0);
 
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
-typedef std::codecvt_byname<char16_t, char, std::mbstate_t> F;
+typedef std::codecvt_byname<char32_t, char8_t, std::mbstate_t> F;
 
 class my_facet
     : public F
 {
 public:
     static int count;
 
     explicit my_facet(const char* nm, std::size_t refs = 0)

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_char16_t_char.depr_in_cxx20.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
-// template <> class codecvt<char16_t, char, mbstate_t>
+// codecvt<char16_t, char, mbstate_t>
+//  deprecated in C++20
 
-// bool always_noconv() const throw();
+// UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <locale>
-#include <cassert>
 
+#include "../with_public_dtor.hpp"
 #include "test_macros.h"
 
-typedef std::codecvt<char16_t, char, std::mbstate_t> F;
-
-int main(int, char**)
+int main(int, char **)
 {
-    std::locale l = std::locale::classic();
-    const F& f = std::use_facet<F>(l);
-    assert(!f.always_noconv());
+    with_public_dtor<std::codecvt<char16_t, char, std::mbstate_t>> cvt("", 0); // expected-warning {{'codecvt<char16_t, char, __mbstate_t>' is deprecated}}
+    (void)cvt;
 
     return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/codecvt_char32_t_char.depr_in_cxx20.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
-// template <> class codecvt<char16_t, char, mbstate_t>
+// codecvt<char32_t, char, mbstate_t>
+//  deprecated in C++20
 
-// bool always_noconv() const throw();
+// UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <locale>
-#include <cassert>
 
+#include "../with_public_dtor.hpp"
 #include "test_macros.h"
 
-typedef std::codecvt<char16_t, char, std::mbstate_t> F;
-
-int main(int, char**)
+int main(int, char **)
 {
-    std::locale l = std::locale::classic();
-    const F& f = std::use_facet<F>(l);
-    assert(!f.always_noconv());
+    with_public_dtor<std::codecvt<char32_t, char, std::mbstate_t>> cvt("", 0); // expected-warning {{'codecvt<char32_t, char, __mbstate_t>' is deprecated}}
+    (void)cvt;
 
     return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char16_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char16_t, char, mbstate_t>
 
 // explicit codecvt(size_t refs = 0);
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
 //#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char16_t_char8_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char16_t, char8_t, mbstate_t>
 
 // explicit codecvt(size_t refs = 0);
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 using F = std::codecvt<char16_t, char8_t, std::mbstate_t>;
 
 struct my_facet : F {
   static int count;
 

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char32_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char32_t, char, mbstate_t>
 
 // explicit codecvt(size_t refs = 0);
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
 //#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/ctor_char32_t_char8_t.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char32_t, char8_t, mbstate_t>
 
 // explicit codecvt(size_t refs = 0);
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 using F = std::codecvt<char32_t, char8_t, std::mbstate_t>;
 
 struct my_facet : F {
   static int count;
 

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_always_noconv.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char16_t, char, mbstate_t>
 
 // bool always_noconv() const throw();
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
 int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(!f.always_noconv());
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_char8_t_always_noconv.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char16_t, char8_t, mbstate_t>
 
 // bool always_noconv() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char16_t, char8_t, std::mbstate_t>;
   const F& f = std::use_facet<F>(std::locale::classic());
   assert(!f.always_noconv());
   static_assert(noexcept(f.always_noconv()));
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_char8_t_encoding.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char16_t, char8_t, mbstate_t>
 
 // int encoding() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char16_t, char8_t, std::mbstate_t>;
   const F& f = std::use_facet<F>(std::locale::classic());
   assert(f.encoding() == 0);
   static_assert(noexcept(f.encoding()));
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_char8_t_in.pass.cpp

 // template <> class codecvt<char16_t, char8_t, mbstate_t>
 
 // result in(stateT& state,
 //           const externT* from, const externT* from_end, const externT*& from_next,
 //           internT* to, internT* to_end, internT*& to_next) const;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char16_t, char8_t, std::mbstate_t>;
   const F::extern_type from[] = u8"some text";
   F::intern_type to[9];
   const F& f = std::use_facet<F>(std::locale::classic());

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_char8_t_length.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char16_t, char8_t, mbstate_t>
 
 // int length(stateT& state, const externT* from, const externT* from_end, size_t max) const;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char16_t, char8_t, std::mbstate_t>;
   const F& f = std::use_facet<F>(std::locale::classic());
   std::mbstate_t mbs = {};
   const char8_t from[] = u8"some text";
   assert(f.length(mbs, from, from + 10, 0) == 0);
   assert(f.length(mbs, from, from + 10, 8) == 8);
   assert(f.length(mbs, from, from + 10, 9) == 9);
   assert(f.length(mbs, from, from + 10, 10) == 10);
   assert(f.length(mbs, from, from + 10, 100) == 10);
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_char8_t_max_length.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char16_t, char8_t, mbstate_t>
 
 // int max_length() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char16_t, char8_t, std::mbstate_t>;
   const F& f = std::use_facet<F>(std::locale::classic());
   assert(f.max_length() == 4);
   static_assert(noexcept(f.max_length()));
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_char8_t_out.pass.cpp

 // template <> class codecvt<char16_t, char8_t, mbstate_t>
 
 // result out(stateT& state,
 //            const internT* from, const internT* from_end, const internT*& from_next,
 //            externT* to, externT* to_end, externT*& to_next) const;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char16_t, char8_t, std::mbstate_t>;
   const F& f = std::use_facet<F>(std::locale::classic());
   F::intern_type from[9] = {'s', 'o', 'm', 'e', ' ', 't', 'e', 'x', 't'};
   F::extern_type to[9] = {0};

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_char8_t_unshift.pass.cpp

 
 // template <> class codecvt<char16_t, char8_t, mbstate_t>
 
 // result unshift(stateT& state,
 //                externT* to, externT* to_end, externT*& to_next) const;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char16_t, char8_t, std::mbstate_t>;
   const F& f = std::use_facet<F>(std::locale::classic());
   std::mbstate_t mbs = {};
   char8_t to[3];
   char8_t* to_next = nullptr;
   assert(f.unshift(mbs, to, to + 3, to_next) == F::noconv);
   assert(to_next == to);
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_encoding.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char16_t, char, mbstate_t>
 
 // int encoding() const throw();
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
 int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.encoding() == 0);
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_in.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char16_t, char, mbstate_t>
 
 // result in(stateT& state,
 //           const externT* from, const externT* from_end, const externT*& from_next,
 //           internT* to, internT* to_end, internT*& to_next) const;
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <string>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_length.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char16_t, char, mbstate_t>
 
 // int length(stateT& state, const externT* from, const externT* from_end, size_t max) const;
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
 int main(int, char**)

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_max_length.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char16_t, char, mbstate_t>
 
 // int max_length() const throw();
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;
 
 int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.max_length() == 4);
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_out.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char16_t, char, mbstate_t>
 
 // result out(stateT& state,
 //            const internT* from, const internT* from_end, const internT*& from_next,
 //            externT* to, externT* to_end, externT*& to_next) const;
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <string>
 #include <vector>
 #include <cassert>
 
 #include <stdio.h>
 
 #include "test_macros.h"

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char16_t_unshift.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char16_t, char, mbstate_t>
 
 // result unshift(stateT& state,
 //                externT* to, externT* to_end, externT*& to_next) const;
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <string>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt<char16_t, char, std::mbstate_t> F;

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_always_noconv.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char32_t, char, mbstate_t>
 
 // bool always_noconv() const throw();
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
 int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(!f.always_noconv());
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_char8_t_always_noconv.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char32_t, char8_t, mbstate_t>
 
 // bool always_noconv() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char32_t, char8_t, std::mbstate_t>;
   const F& f = std::use_facet<F>(std::locale::classic());
   assert(!f.always_noconv());
   static_assert(noexcept(f.always_noconv()));
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_char8_t_encoding.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char32_t, char8_t, mbstate_t>
 
 // int encoding() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char32_t, char8_t, std::mbstate_t>;
   const F& f = std::use_facet<F>(std::locale::classic());
   assert(f.encoding() == 0);
   static_assert(noexcept(f.encoding()));
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_char8_t_in.pass.cpp

 // template <> class codecvt<char32_t, char8_t, mbstate_t>
 
 // result in(stateT& state,
 //           const externT* from, const externT* from_end, const externT*& from_next,
 //           internT* to, internT* to_end, internT*& to_next) const;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char32_t, char8_t, std::mbstate_t>;
   const F::extern_type from[] = u8"some text";
   F::intern_type to[9];
   const F& f = std::use_facet<F>(std::locale::classic());

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_char8_t_length.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char32_t, char8_t, mbstate_t>
 
 // int length(stateT& state, const externT* from, const externT* from_end, size_t max) const;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char32_t, char8_t, std::mbstate_t>;
   const F& f = std::use_facet<F>(std::locale::classic());
   std::mbstate_t mbs = {};
   const char8_t from[] = u8"some text";
   assert(f.length(mbs, from, from + 10, 0) == 0);
   assert(f.length(mbs, from, from + 10, 8) == 8);
   assert(f.length(mbs, from, from + 10, 9) == 9);
   assert(f.length(mbs, from, from + 10, 10) == 10);
   assert(f.length(mbs, from, from + 10, 100) == 10);
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_char8_t_max_length.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char32_t, char8_t, mbstate_t>
 
 // int max_length() const noexcept;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char32_t, char8_t, std::mbstate_t>;
   const F& f = std::use_facet<F>(std::locale::classic());
   assert(f.max_length() == 4);
   static_assert(noexcept(f.max_length()));
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_char8_t_out.pass.cpp

 // template <> class codecvt<char32_t, char8_t, mbstate_t>
 
 // result out(stateT& state,
 //            const internT* from, const internT* from_end, const internT*& from_next,
 //            externT* to, externT* to_end, externT*& to_next) const;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char32_t, char8_t, std::mbstate_t>;
   const F& f = std::use_facet<F>(std::locale::classic());
   F::intern_type from[9] = {'s', 'o', 'm', 'e', ' ', 't', 'e', 'x', 't'};
   F::extern_type to[9] = {0};

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_char8_t_unshift.pass.cpp

 
 // template <> class codecvt<char32_t, char8_t, mbstate_t>
 
 // result unshift(stateT& state,
 //                externT* to, externT* to_end, externT*& to_next) const;
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 
 int main(int, char**) {
   using F = std::codecvt<char32_t, char8_t, std::mbstate_t>;
   const F& f = std::use_facet<F>(std::locale::classic());
   std::mbstate_t mbs = {};
   char8_t to[3];
   char8_t* to_next = nullptr;
   assert(f.unshift(mbs, to, to + 3, to_next) == F::noconv);
   assert(to_next == to);
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_encoding.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char32_t, char, mbstate_t>
 
 // int encoding() const throw();
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
 int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.encoding() == 0);
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_in.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char32_t, char, mbstate_t>
 
 // result in(stateT& state,
 //           const externT* from, const externT* from_end, const externT*& from_next,
 //           internT* to, internT* to_end, internT*& to_next) const;
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <string>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_length.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char32_t, char, mbstate_t>
 
 // int length(stateT& state, const externT* from, const externT* from_end, size_t max) const;
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
 int main(int, char**)

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_max_length.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char32_t, char, mbstate_t>
 
 // int max_length() const throw();
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;
 
 int main(int, char**)
 {
     std::locale l = std::locale::classic();
     const F& f = std::use_facet<F>(l);
     assert(f.max_length() == 4);
 
   return 0;
 }

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_out.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char32_t, char, mbstate_t>
 
 // result out(stateT& state,
 //            const internT* from, const internT* from_end, const internT*& from_next,
 //            externT* to, externT* to_end, externT*& to_next) const;
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <string>
 #include <vector>
 #include <cassert>
 
 #include <stdio.h>
 
 #include "test_macros.h"

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/char32_t_unshift.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <> class codecvt<char32_t, char, mbstate_t>
 
 // result unshift(stateT& state,
 //                externT* to, externT* to_end, externT*& to_next) const;
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <string>
 #include <vector>
 #include <cassert>
 
 #include "test_macros.h"
 
 typedef std::codecvt<char32_t, char, std::mbstate_t> F;

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/locale.codecvt.members/utf_sanity_check.pass.cpp

 // template <> class codecvt<char32_t, char, mbstate_t>
 // template <> class codecvt<char16_t, char, mbstate_t>
 // template <> class codecvt<char32_t, char8_t, mbstate_t> // C++20
 // template <> class codecvt<char16_t, char8_t, mbstate_t> // C++20
 // template <> class codecvt<char32_t, char16_t, mbstate_t>  // extension
 
 // sanity check
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <codecvt>
 #include <cassert>
 
 #include <stdio.h>
 
 #include "test_macros.h"
 
int main(int, char**) {
   const F16_8::intern_type* c_c16p;
   const F32_8::extern_type* c_c8p;
   F32_8::intern_type c32;
   F16_8::intern_type c16[2];
   char c16c[4];
   char* c16cp;
   F32_8::extern_type c8[4];
 
-// C++20 codecvt specializations for char8_t are not yet implemented
-#if TEST_STD_VER > 17 && !defined(_LIBCPP_VERSION)
+#if TEST_STD_VER > 17
   typedef std::codecvt<char32_t, char8_t, std::mbstate_t> F32_8T;
   typedef std::codecvt<char16_t, char8_t, std::mbstate_t> F16_8T;
   const F32_8T& f32_8t = std::use_facet<F32_8T>(std::locale::classic());
   const F16_8T& f16_8t = std::use_facet<F16_8T>(std::locale::classic());
   std::mbstate_t mbs32_8t = {};
   std::mbstate_t mbs16_8t = {};
   F32_8T::extern_type* c8tp;
   const F32_8T::extern_type* c_c8tp;
   F32_8T::extern_type c8t[4];
 #endif
 
   for (F32_8::intern_type c32x = 0; c32x < 0x110003; ++c32x) {
     if ((0xD800 <= c32x && c32x < 0xE000) || c32x >= 0x110000) {
 #ifndef _MSVC_STL_VERSION // Don't ask; eldritch horrors.
       assert(f32_16.out(mbs32_16, &c32x, &c32x + 1, c_c32p, c16c + 0, c16c + 4,
                         c16cp) == F32_8::error);
       assert(f32_8.out(mbs32_8, &c32x, &c32x + 1, c_c32p, c8, c8 + 4, c8p) ==
              F32_8::error);
 #endif
 
-// C++20 codecvt specializations for char8_t are not yet implemented
-#if TEST_STD_VER > 17 && !defined(_LIBCPP_VERSION)
+#if TEST_STD_VER > 17
       assert(f32_8t.out(mbs32_8t, &c32x, &c32x + 1, c_c32p, c8t, c8t + 4,
                         c8tp) == F32_8T::error);
 #endif
     } else {
       assert(f32_16.out(mbs32_16, &c32x, &c32x + 1, c_c32p, c16c, c16c + 4,
                         c16cp) == F32_8::ok);
       assert(c_c32p - &c32x == 1);
       if (c32x < 0x10000)
#endif
                        c32p) == F32_8::ok);
       if (c32x < 0x10000)
         assert(c_c16cp - c16c == 2);
       else
         assert(c_c16cp - c16c == 4);
       assert(c32p - &c32 == 1);
       assert(c32 == c32x);
 
-// C++20 codecvt specializations for char8_t are not yet implemented
-#if TEST_STD_VER > 17 && !defined(_LIBCPP_VERSION)
+#if TEST_STD_VER > 17
       assert(f32_8t.out(mbs32_8t, &c32x, &c32x + 1, c_c32p, c8t, c8t + 4,
                         c8tp) == F32_8T::ok);
       assert(c_c32p - &c32x == 1);
       if (c32x < 0x80)
         assert(c8tp - c8t == 1);
       else if (c32x < 0x800)
         assert(c8tp - c8t == 2);
       else if (c32x < 0x10000)

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char16_t.pass.cpp

 // {
 // public:
 //     typedef char16_t  intern_type;
 //     typedef char      extern_type;
 //     typedef mbstate_t state_type;
 //     ...
 // };
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char16_t_char8_t.pass.cpp

 //     typedef char16_t  intern_type;
 //     typedef char8_t   extern_type;
 //     typedef mbstate_t state_type;
 //     ...
 // };
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 #include <type_traits>
 
 int main(int, char**) {
   using F = std::codecvt<char16_t, char8_t, std::mbstate_t>;
   static_assert(std::is_base_of_v<std::locale::facet, F>);
   static_assert(std::is_base_of_v<std::codecvt_base, F>);

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char32_t.pass.cpp

 // {
 // public:
 //     typedef char32_t  intern_type;
 //     typedef char      extern_type;
 //     typedef mbstate_t state_type;
 //     ...
 // };
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {

libcxx/test/std/localization/locale.categories/category.ctype/locale.codecvt/types_char32_t_char8_t.pass.cpp

 //     typedef char32_t  intern_type;
 //     typedef char8_t   extern_type;
 //     typedef mbstate_t state_type;
 //     ...
 // };
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
-// C++20 codecvt specializations for char8_t are not yet implemented:
-// UNSUPPORTED: libc++
-
 #include <cassert>
 #include <locale>
 #include <type_traits>
 
 int main(int, char**) {
   using F = std::codecvt<char32_t, char8_t, std::mbstate_t>;
   static_assert(std::is_base_of_v<std::locale::facet, F>);
   static_assert(std::is_base_of_v<std::codecvt_base, F>);

libcxx/test/std/localization/locale.categories/category.ctype/with_public_dtor.hpp

+//===----------------------------------------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#include <utility>
+
+template <typename T>
+struct with_public_dtor : T
+{
+    template <typename... Args>
+    explicit with_public_dtor(Args &&... args)
+        : T(std::forward<Args>(args)...)
+    {
+    }
+};

libcxx/test/std/localization/locales/locale/locale.cons/assign.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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.ru_RU.UTF-8
 
 // <locale>
 
 // const locale& operator=(const locale& other) throw();
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 #include <new>
 
 #include "count_new.h"
 
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
 
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
     assert((std::has_facet<std::codecvt<char, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char16_t, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char32_t, char, std::mbstate_t> >(loc)));
+#if TEST_STD_VER > 17
+    assert((std::has_facet<std::codecvt<char16_t, char8_t, std::mbstate_t> >(loc)));
+    assert((std::has_facet<std::codecvt<char32_t, char8_t, std::mbstate_t> >(loc)));
+#endif
     assert((std::has_facet<std::codecvt<wchar_t, char, std::mbstate_t> >(loc)));
 
     assert((std::has_facet<std::moneypunct<char> >(loc)));
     assert((std::has_facet<std::moneypunct<wchar_t> >(loc)));
     assert((std::has_facet<std::money_get<char> >(loc)));
     assert((std::has_facet<std::money_get<wchar_t> >(loc)));
     assert((std::has_facet<std::money_put<char> >(loc)));
     assert((std::has_facet<std::money_put<wchar_t> >(loc)));

libcxx/test/std/localization/locales/locale/locale.cons/char_pointer.pass.cpp

 
 // REQUIRES: locale.ru_RU.UTF-8
 // REQUIRES: locale.zh_CN.UTF-8
 
 // <locale>
 
 // explicit locale(const char* std_name);
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <new>
 #include <cassert>
 
 #include "count_new.h"
 #include "platform_support.h" // locale name macros
 
 #include "test_macros.h"
 
 
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
     assert((std::has_facet<std::codecvt<char, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char16_t, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char32_t, char, std::mbstate_t> >(loc)));
+#if TEST_STD_VER > 17
+    assert((std::has_facet<std::codecvt<char16_t, char8_t, std::mbstate_t> >(loc)));
+    assert((std::has_facet<std::codecvt<char32_t, char8_t, std::mbstate_t> >(loc)));
+#endif
     assert((std::has_facet<std::codecvt<wchar_t, char, std::mbstate_t> >(loc)));
 
     assert((std::has_facet<std::moneypunct<char> >(loc)));
     assert((std::has_facet<std::moneypunct<wchar_t> >(loc)));
     assert((std::has_facet<std::money_get<char> >(loc)));
     assert((std::has_facet<std::money_get<wchar_t> >(loc)));
     assert((std::has_facet<std::money_put<char> >(loc)));
     assert((std::has_facet<std::money_put<wchar_t> >(loc)));

libcxx/test/std/localization/locales/locale/locale.cons/copy.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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.fr_FR.UTF-8
 
 // <locale>
 
 // locale(const locale& other) throw();
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 #include <new>
 
 #include "count_new.h"
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
     assert((std::has_facet<std::codecvt<char, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char16_t, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char32_t, char, std::mbstate_t> >(loc)));
+#if TEST_STD_VER > 17
+    assert((std::has_facet<std::codecvt<char16_t, char8_t, std::mbstate_t> >(loc)));
+    assert((std::has_facet<std::codecvt<char32_t, char8_t, std::mbstate_t> >(loc)));
+#endif
     assert((std::has_facet<std::codecvt<wchar_t, char, std::mbstate_t> >(loc)));
 
     assert((std::has_facet<std::moneypunct<char> >(loc)));
     assert((std::has_facet<std::moneypunct<wchar_t> >(loc)));
     assert((std::has_facet<std::money_get<char> >(loc)));
     assert((std::has_facet<std::money_get<wchar_t> >(loc)));
     assert((std::has_facet<std::money_put<char> >(loc)));
     assert((std::has_facet<std::money_put<wchar_t> >(loc)));

libcxx/test/std/localization/locales/locale/locale.cons/default.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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.en_US.UTF-8
 
 // <locale>
 
 // locale() throw();
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 #include "count_new.h"
 
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
     assert((std::has_facet<std::codecvt<char, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char16_t, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char32_t, char, std::mbstate_t> >(loc)));
+#if TEST_STD_VER > 17
+    assert((std::has_facet<std::codecvt<char16_t, char8_t, std::mbstate_t> >(loc)));
+    assert((std::has_facet<std::codecvt<char32_t, char8_t, std::mbstate_t> >(loc)));
+#endif
     assert((std::has_facet<std::codecvt<wchar_t, char, std::mbstate_t> >(loc)));
 
     assert((std::has_facet<std::moneypunct<char> >(loc)));
     assert((std::has_facet<std::moneypunct<wchar_t> >(loc)));
     assert((std::has_facet<std::money_get<char> >(loc)));
     assert((std::has_facet<std::money_get<wchar_t> >(loc)));
     assert((std::has_facet<std::money_put<char> >(loc)));
     assert((std::has_facet<std::money_put<wchar_t> >(loc)));

libcxx/test/std/localization/locales/locale/locale.cons/locale_char_pointer_cat.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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.en_US.UTF-8
 // REQUIRES: locale.ru_RU.UTF-8
 // UNSUPPORTED: sanitizer-new-delete
 
 // <locale>
 
 // locale(const locale& other, const char* std_name, category);
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <new>
 #include <cassert>
 
 #include "count_new.h"
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
     assert((std::has_facet<std::codecvt<char, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char16_t, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char32_t, char, std::mbstate_t> >(loc)));
+#if TEST_STD_VER > 17
+    assert((std::has_facet<std::codecvt<char16_t, char8_t, std::mbstate_t> >(loc)));
+    assert((std::has_facet<std::codecvt<char32_t, char8_t, std::mbstate_t> >(loc)));
+#endif
     assert((std::has_facet<std::codecvt<wchar_t, char, std::mbstate_t> >(loc)));
 
     assert((std::has_facet<std::moneypunct<char> >(loc)));
     assert((std::has_facet<std::moneypunct<wchar_t> >(loc)));
     assert((std::has_facet<std::money_get<char> >(loc)));
     assert((std::has_facet<std::money_get<wchar_t> >(loc)));
     assert((std::has_facet<std::money_put<char> >(loc)));
     assert((std::has_facet<std::money_put<wchar_t> >(loc)));

libcxx/test/std/localization/locales/locale/locale.cons/locale_facetptr.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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.ru_RU.UTF-8
 
 // <locale>
 
 // template <class Facet> locale(const locale& other, Facet* f);
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <new>
 #include <cassert>
 
 #include "count_new.h"
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
 
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
     assert((std::has_facet<std::codecvt<char, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char16_t, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char32_t, char, std::mbstate_t> >(loc)));
+#if TEST_STD_VER > 17
+    assert((std::has_facet<std::codecvt<char16_t, char8_t, std::mbstate_t> >(loc)));
+    assert((std::has_facet<std::codecvt<char32_t, char8_t, std::mbstate_t> >(loc)));
+#endif
     assert((std::has_facet<std::codecvt<wchar_t, char, std::mbstate_t> >(loc)));
 
     assert((std::has_facet<std::moneypunct<char> >(loc)));
     assert((std::has_facet<std::moneypunct<wchar_t> >(loc)));
     assert((std::has_facet<std::money_get<char> >(loc)));
     assert((std::has_facet<std::money_get<wchar_t> >(loc)));
     assert((std::has_facet<std::money_put<char> >(loc)));
     assert((std::has_facet<std::money_put<wchar_t> >(loc)));

libcxx/test/std/localization/locales/locale/locale.cons/locale_locale_cat.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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.en_US.UTF-8
 // REQUIRES: locale.ru_RU.UTF-8
 // UNSUPPORTED: sanitizer-new-delete
 
 // <locale>
 
 // locale(const locale& other, const locale& one, category cats);
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <new>
 #include <cassert>
 
 #include "count_new.h"
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
     assert((std::has_facet<std::codecvt<char, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char16_t, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char32_t, char, std::mbstate_t> >(loc)));
+#if TEST_STD_VER > 17
+    assert((std::has_facet<std::codecvt<char16_t, char8_t, std::mbstate_t> >(loc)));
+    assert((std::has_facet<std::codecvt<char32_t, char8_t, std::mbstate_t> >(loc)));
+#endif
     assert((std::has_facet<std::codecvt<wchar_t, char, std::mbstate_t> >(loc)));
 
     assert((std::has_facet<std::moneypunct<char> >(loc)));
     assert((std::has_facet<std::moneypunct<wchar_t> >(loc)));
     assert((std::has_facet<std::money_get<char> >(loc)));
     assert((std::has_facet<std::money_get<wchar_t> >(loc)));
     assert((std::has_facet<std::money_put<char> >(loc)));
     assert((std::has_facet<std::money_put<wchar_t> >(loc)));

libcxx/test/std/localization/locales/locale/locale.cons/locale_string_cat.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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.en_US.UTF-8
 // REQUIRES: locale.ru_RU.UTF-8
 // UNSUPPORTED: sanitizer-new-delete
 
 // <locale>
 
 // locale(const locale& other, const string& std_name, category cat);
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <new>
 #include <cassert>
 
 #include "count_new.h"
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
 
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
     assert((std::has_facet<std::codecvt<char, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char16_t, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char32_t, char, std::mbstate_t> >(loc)));
+#if TEST_STD_VER > 17
+    assert((std::has_facet<std::codecvt<char16_t, char8_t, std::mbstate_t> >(loc)));
+    assert((std::has_facet<std::codecvt<char32_t, char8_t, std::mbstate_t> >(loc)));
+#endif
     assert((std::has_facet<std::codecvt<wchar_t, char, std::mbstate_t> >(loc)));
 
     assert((std::has_facet<std::moneypunct<char> >(loc)));
     assert((std::has_facet<std::moneypunct<wchar_t> >(loc)));
     assert((std::has_facet<std::money_get<char> >(loc)));
     assert((std::has_facet<std::money_get<wchar_t> >(loc)));
     assert((std::has_facet<std::money_put<char> >(loc)));
     assert((std::has_facet<std::money_put<wchar_t> >(loc)));

libcxx/test/std/localization/locales/locale/locale.cons/string.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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.ru_RU.UTF-8
 // REQUIRES: locale.zh_CN.UTF-8
 
 // <locale>
 
 // explicit locale(const string& std_name);
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <new>
 #include <cassert>
 
 #include "count_new.h"
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
     assert((std::has_facet<std::codecvt<char, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char16_t, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char32_t, char, std::mbstate_t> >(loc)));
+#if TEST_STD_VER > 17
+    assert((std::has_facet<std::codecvt<char16_t, char8_t, std::mbstate_t> >(loc)));
+    assert((std::has_facet<std::codecvt<char32_t, char8_t, std::mbstate_t> >(loc)));
+#endif
     assert((std::has_facet<std::codecvt<wchar_t, char, std::mbstate_t> >(loc)));
 
     assert((std::has_facet<std::moneypunct<char> >(loc)));
     assert((std::has_facet<std::moneypunct<wchar_t> >(loc)));
     assert((std::has_facet<std::money_get<char> >(loc)));
     assert((std::has_facet<std::money_get<wchar_t> >(loc)));
     assert((std::has_facet<std::money_put<char> >(loc)));
     assert((std::has_facet<std::money_put<wchar_t> >(loc)));

libcxx/test/std/localization/locales/locale/locale.members/combine.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // template <class Facet> locale combine(const locale& other) const;
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <stdexcept>
 #include <cassert>
 
 #include "count_new.h"
 
 #include "test_macros.h"
 
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
     assert((std::has_facet<std::codecvt<char, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char16_t, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char32_t, char, std::mbstate_t> >(loc)));
+#if TEST_STD_VER > 17
+    assert((std::has_facet<std::codecvt<char16_t, char8_t, std::mbstate_t> >(loc)));
+    assert((std::has_facet<std::codecvt<char32_t, char8_t, std::mbstate_t> >(loc)));
+#endif
     assert((std::has_facet<std::codecvt<wchar_t, char, std::mbstate_t> >(loc)));
 
     assert((std::has_facet<std::moneypunct<char> >(loc)));
     assert((std::has_facet<std::moneypunct<wchar_t> >(loc)));
     assert((std::has_facet<std::money_get<char> >(loc)));
     assert((std::has_facet<std::money_get<wchar_t> >(loc)));
     assert((std::has_facet<std::money_put<char> >(loc)));
     assert((std::has_facet<std::money_put<wchar_t> >(loc)));

libcxx/test/std/localization/locales/locale/locale.statics/classic.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
 //
 //===----------------------------------------------------------------------===//
 
 // <locale>
 
 // static const locale& classic();
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
     assert((std::has_facet<std::codecvt<char, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char16_t, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char32_t, char, std::mbstate_t> >(loc)));
+#if TEST_STD_VER > 17
+    assert((std::has_facet<std::codecvt<char16_t, char8_t, std::mbstate_t> >(loc)));
+    assert((std::has_facet<std::codecvt<char32_t, char8_t, std::mbstate_t> >(loc)));
+#endif
     assert((std::has_facet<std::codecvt<wchar_t, char, std::mbstate_t> >(loc)));
 
     assert((std::has_facet<std::moneypunct<char> >(loc)));
     assert((std::has_facet<std::moneypunct<wchar_t> >(loc)));
     assert((std::has_facet<std::money_get<char> >(loc)));
     assert((std::has_facet<std::money_get<wchar_t> >(loc)));
     assert((std::has_facet<std::money_put<char> >(loc)));
     assert((std::has_facet<std::money_put<wchar_t> >(loc)));

libcxx/test/std/localization/locales/locale/locale.statics/global.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
 //
 //===----------------------------------------------------------------------===//
 
 // REQUIRES: locale.en_US.UTF-8
 
 // <locale>
 
 // static const locale& classic();
 
+// This test runs in C++20, but we have deprecated codecvt<char(16|32), char, mbstate_t> in C++20.
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <locale>
 #include <cassert>
 
 #include "test_macros.h"
 #include "platform_support.h" // locale name macros
 
 void check(const std::locale& loc)
 {
     assert(std::has_facet<std::collate<char> >(loc));
     assert(std::has_facet<std::collate<wchar_t> >(loc));
 
     assert(std::has_facet<std::ctype<char> >(loc));
     assert(std::has_facet<std::ctype<wchar_t> >(loc));
     assert((std::has_facet<std::codecvt<char, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char16_t, char, std::mbstate_t> >(loc)));
     assert((std::has_facet<std::codecvt<char32_t, char, std::mbstate_t> >(loc)));
+#if TEST_STD_VER > 17
+    assert((std::has_facet<std::codecvt<char16_t, char8_t, std::mbstate_t> >(loc)));
+    assert((std::has_facet<std::codecvt<char32_t, char8_t, std::mbstate_t> >(loc)));
+#endif
     assert((std::has_facet<std::codecvt<wchar_t, char, std::mbstate_t> >(loc)));
 
     assert((std::has_facet<std::moneypunct<char> >(loc)));
     assert((std::has_facet<std::moneypunct<wchar_t> >(loc)));
     assert((std::has_facet<std::money_get<char> >(loc)));
     assert((std::has_facet<std::money_get<wchar_t> >(loc)));
     assert((std::has_facet<std::money_put<char> >(loc)));
     assert((std::has_facet<std::money_put<wchar_t> >(loc)));

libcxxabi/src/CMakeLists.txt

if (LIBCXXABI_ENABLE_SHARED)
   if (TARGET pstl::ParallelSTL)
     target_link_libraries(cxxabi_shared PUBLIC pstl::ParallelSTL)
   endif()
   set_target_properties(cxxabi_shared
                         PROPERTIES
                           CXX_EXTENSIONS
                             OFF
                           CXX_STANDARD
-                            17
+                            20
                           CXX_STANDARD_REQUIRED
                             ON
                           COMPILE_FLAGS
                             "${LIBCXXABI_COMPILE_FLAGS}"
                           LINK_FLAGS
                             "${LIBCXXABI_LINK_FLAGS}"
                           OUTPUT_NAME
                             "c++abi"
if (LIBCXXABI_ENABLE_STATIC)
   if (TARGET pstl::ParallelSTL)
     target_link_libraries(cxxabi_static PUBLIC pstl::ParallelSTL)
   endif()
   set_target_properties(cxxabi_static
                         PROPERTIES
                           CXX_EXTENSIONS
                             OFF
                           CXX_STANDARD
-                            17
+                            20
                           CXX_STANDARD_REQUIRED
                             ON
                           COMPILE_FLAGS
                             "${LIBCXXABI_COMPILE_FLAGS}"
                           LINK_FLAGS
                             "${LIBCXXABI_LINK_FLAGS}"
                           OUTPUT_NAME
                             "c++abi")