[libc++] Move library fundamentals to fundamentals_v3 namespace and C++20 and remove deprecated symbols

[philnik]

Summary

The library fundamentals TSv3 is based on C++20, so everything should be moved to that. Most of the LFTSv1 and v2 stuff has been implemented anyways, so this will affect only very few users. This allows us to clean up the implementation soon and remove

[Mordante]

Can you move the removal to its own patch? The removal patch should update the release notes too.

libcxx/include/experimental/__config

24

We typically have two cycles for depreciation.
Can you add a TODO too?

libcxx/docs/Status/LFTSv3.rst

+.. lftsv3-status:
+
+========================================
+libc++ Library Fundamentals TS v3 Status
+========================================
+
+.. include:: ../Helpers/Styles.rst
+
+.. contents::
+   :local:
+
+
+Overview
+========
+
+This document contains the status of the Library Fundamentals TS v3 (LFTSv3) in libc++.
+It is used to track both the status of the sub-projects and who is assigned to
+these sub-projects. This is imperative to effective implementation so that work
+is not duplicated and implementors are not blocked by each other.
+
+If you are interested in contributing to the libc++ LFTSv3, please send
+a message to the #libcxx channel in the LLVM discord. Please *do not* start
+working on any of the assigned items below.
+
+Sub-Projects in the Format library
+==================================
+
+.. csv-table::
+   :file: FormatPaper.csv
+   :header-rows: 1
+   :widths: auto

libcxx/docs/Status/LFTSv3Paper.csv

+Section,Description,Dependencies,Status
+`[utilities] <https://wg21.link/N4920>`_,"",,Not assigned,|Complete|
+`[propagate_const] <https://wg21.link/N4920>`_,"",,,|Complete|
+`[meta] <https://wg21.link/N4920>`_,"",,Not assigned,|Partial|
+`[func] <https://wg21.link/N4920>`_,"",,Not assigned,|Not Started|
+`[memory] <https://wg21.link/N4920>`_,"",,Not assigned,|Not Started|
+`[iterator] <https://wg21.link/N4920>`_,"",,,|Complete|
+`[futures] <https://wg21.link/N4920>`_,"",,Not assigned,|Not Started|
+`[algorithms] <https://wg21.link/N4920>`_,"",,Not assigned,|Not Started|
+`[numeric] <https://wg21.link/N4920>`_,"",,Not assigned,|Not Started|

libcxx/include/experimental/__config

 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 #define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL namespace std { namespace experimental {
 #define _LIBCPP_END_NAMESPACE_EXPERIMENTAL  } }
 #define _VSTD_EXPERIMENTAL std::experimental
 
-#define _LIBCPP_BEGIN_NAMESPACE_LFTS _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v1 {
+#if _LIBCPP_STD_VER <= 17
+#define _LIBCPP_DEPRECATED_LFTS_IS_NOW_CXX20(symbol) _LIBCPP_DEPRECATED_("The library fundamentals TS is now based on C++20. " symbol " will only be available in C++20 in LLVM 19.")
+#else
+#define _LIBCPP_DEPRECATED_LFTS_IS_NOW_CXX20(symbol)
+#endif
+
+#define _LIBCPP_BEGIN_NAMESPACE_LFTS _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v3 {
 #define _LIBCPP_END_NAMESPACE_LFTS  } } }
-#define _VSTD_LFTS _VSTD_EXPERIMENTAL::fundamentals_v1
+#define _VSTD_LFTS _VSTD_EXPERIMENTAL::fundamentals_v3
 
-#define _LIBCPP_BEGIN_NAMESPACE_LFTS_V2 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v2 {
+#define _LIBCPP_BEGIN_NAMESPACE_LFTS_V2 _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace fundamentals_v3 {
 #define _LIBCPP_END_NAMESPACE_LFTS_V2  } } }
-#define _VSTD_LFTS_V2 _VSTD_EXPERIMENTAL::fundamentals_v2
-
-#define _LIBCPP_BEGIN_NAMESPACE_LFTS_PMR _LIBCPP_BEGIN_NAMESPACE_LFTS namespace pmr {
-#define _LIBCPP_END_NAMESPACE_LFTS_PMR _LIBCPP_END_NAMESPACE_LFTS }
-#define _VSTD_LFTS_PMR _VSTD_LFTS::pmr
+#define _VSTD_LFTS_V2 _VSTD_EXPERIMENTAL::fundamentals_v3
 
 #define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD \
     _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL inline namespace parallelism_v2 {
 
 #define _LIBCPP_END_NAMESPACE_EXPERIMENTAL_SIMD \
     } _LIBCPP_END_NAMESPACE_EXPERIMENTAL
 
 #define _LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL_SIMD_ABI \

libcxx/include/experimental/__memory

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL___MEMORY
-#define _LIBCPP_EXPERIMENTAL___MEMORY
-
-#include <__memory/allocator_arg_t.h>
-#include <__memory/uses_allocator.h>
-#include <__type_traits/conditional.h>
-#include <__type_traits/is_constructible.h>
-#include <__type_traits/is_convertible.h>
-#include <__type_traits/is_same.h>
-#include <experimental/__config>
-#include <experimental/utility> // for erased_type
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS
-
-template <
-    class _Tp, class _Alloc
-  , bool = uses_allocator<_Tp, _Alloc>::value
-  , bool = __has_allocator_type<_Tp>::value
-  >
-struct __lfts_uses_allocator : public false_type {};
-
-template <class _Tp, class _Alloc>
-struct __lfts_uses_allocator<_Tp, _Alloc, false, false> : public false_type {};
-
-template <class _Tp, class _Alloc, bool HasAlloc>
-struct __lfts_uses_allocator<_Tp, _Alloc, true, HasAlloc> : public true_type {};
-
-template <class _Tp, class _Alloc>
-struct __lfts_uses_allocator<_Tp, _Alloc, false, true>
-  : public integral_constant<bool
-    , is_convertible<_Alloc, typename _Tp::allocator_type>::value
-      || is_same<erased_type, typename _Tp::allocator_type>::value
-    >
-{};
-
-template <bool _UsesAlloc, class _Tp, class _Alloc, class ..._Args>
-struct __lfts_uses_alloc_ctor_imp
-{
-    static const int value = 0;
-};
-
-template <class _Tp, class _Alloc, class ..._Args>
-struct __lfts_uses_alloc_ctor_imp<true, _Tp, _Alloc, _Args...>
-{
-    static const bool __ic_first
-        = is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>::value;
-
-    static const bool __ic_second =
-        __conditional_t<
-            __ic_first,
-            false_type,
-            is_constructible<_Tp, _Args..., _Alloc>
-        >::value;
-
-    static_assert(__ic_first || __ic_second,
-                  "Request for uses allocator construction is ill-formed");
-
-    static const int value = __ic_first ? 1 : 2;
-};
-
-template <class _Tp, class _Alloc, class ..._Args>
-struct __lfts_uses_alloc_ctor
-  : integral_constant<int,
-        __lfts_uses_alloc_ctor_imp<
-            __lfts_uses_allocator<_Tp, _Alloc>::value
-          , _Tp, _Alloc, _Args...
-        >::value
-    >
-{};
-
-template <class _Tp, class _Allocator, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void __user_alloc_construct_impl (integral_constant<int, 0>, _Tp *__storage, const _Allocator &, _Args &&... __args )
-{
-    new (__storage) _Tp (_VSTD::forward<_Args>(__args)...);
-}
-
-// FIXME: This should have a version which takes a non-const alloc.
-template <class _Tp, class _Allocator, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void __user_alloc_construct_impl (integral_constant<int, 1>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
-{
-    new (__storage) _Tp (allocator_arg_t(), __a, _VSTD::forward<_Args>(__args)...);
-}
-
-// FIXME: This should have a version which takes a non-const alloc.
-template <class _Tp, class _Allocator, class... _Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void __user_alloc_construct_impl (integral_constant<int, 2>, _Tp *__storage, const _Allocator &__a, _Args &&... __args )
-{
-    new (__storage) _Tp (_VSTD::forward<_Args>(__args)..., __a);
-}
-
-template <class _Tp, class _Alloc, class ..._Args>
-inline _LIBCPP_INLINE_VISIBILITY
-void __lfts_user_alloc_construct(
-    _Tp * __store, const _Alloc & __a, _Args &&... __args)
-{
-    ::std::experimental::fundamentals_v1::__user_alloc_construct_impl(
-        typename __lfts_uses_alloc_ctor<_Tp, _Alloc, _Args...>::type()
-       , __store, __a, _VSTD::forward<_Args>(__args)...
-       );
-}
-
-_LIBCPP_END_NAMESPACE_LFTS
-
-#endif /* _LIBCPP_EXPERIMENTAL___MEMORY */

libcxx/include/experimental/deque

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_DEQUE
-#define _LIBCPP_EXPERIMENTAL_DEQUE
-
-/*
-    experimental/deque synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class T>
-  using deque = std::deque<T,polymorphic_allocator<T>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <deque>
-#include <experimental/__config>
-#include <experimental/memory_resource>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _ValueT>
-using deque = _VSTD::deque<_ValueT, polymorphic_allocator<_ValueT>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_DEQUE */

libcxx/include/experimental/forward_list

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_FORWARD_LIST
-#define _LIBCPP_EXPERIMENTAL_FORWARD_LIST
-
-/*
-    experimental/forward_list synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class T>
-  using forward_list = std::forward_list<T,polymorphic_allocator<T>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <forward_list>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _ValueT>
-using forward_list = _VSTD::forward_list<_ValueT, polymorphic_allocator<_ValueT>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_FORWARD_LIST */

libcxx/include/experimental/iterator

 #  pragma GCC system_header
 #endif
 
 #if _LIBCPP_STD_VER >= 14
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
 template <class _Delim, class _CharT = char, class _Traits = char_traits<_CharT>>
-class ostream_joiner {
+class _LIBCPP_DEPRECATED_LFTS_IS_NOW_CXX20("ostream_joiner") ostream_joiner {
 public:
 
     typedef _CharT                               char_type;
     typedef _Traits                              traits_type;
     typedef basic_ostream<char_type,traits_type> ostream_type;
     typedef output_iterator_tag                  iterator_category;
     typedef void                                 value_type;
     typedef void                                 difference_type;

 private:
     ostream_type*   __output_iter_;
     _Delim          __delim_;
     bool            __first_;
 };
 
 
 template <class _CharT, class _Traits, class _Delim>
+_LIBCPP_DEPRECATED_LFTS_IS_NOW_CXX20("make_ostream_joiner")
 _LIBCPP_HIDE_FROM_ABI ostream_joiner<__decay_t<_Delim>, _CharT, _Traits>
 make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim && __d)
 { return ostream_joiner<__decay_t<_Delim>, _CharT, _Traits>(__os, _VSTD::forward<_Delim>(__d)); }
 
 _LIBCPP_END_NAMESPACE_LFTS
 
 #endif // _LIBCPP_STD_VER >= 14
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_EXPERIMENTAL_ITERATOR

libcxx/include/experimental/list

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_LIST
-#define _LIBCPP_EXPERIMENTAL_LIST
-
-/*
-    experimental/list synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class T>
-  using list = std::list<T,polymorphic_allocator<T>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <list>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _ValueT>
-using list = _VSTD::list<_ValueT, polymorphic_allocator<_ValueT>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_LIST */

libcxx/include/experimental/map

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_MAP
-#define _LIBCPP_EXPERIMENTAL_MAP
-
-/*
-    experimental/map synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class Key, class T, class Compare = less<Key>>
-  using map = std::map<Key, T, Compare,
-                       polymorphic_allocator<pair<const Key,T>>>;
-
-  template <class Key, class T, class Compare = less<Key>>
-  using multimap = std::multimap<Key, T, Compare,
-                                 polymorphic_allocator<pair<const Key,T>>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <map>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Key, class _Value, class  _Compare = less<_Key>>
-using map = _VSTD::map<_Key, _Value, _Compare,
-                        polymorphic_allocator<pair<const _Key, _Value>>>;
-
-template <class _Key, class _Value, class  _Compare = less<_Key>>
-using multimap = _VSTD::multimap<_Key, _Value, _Compare,
-                        polymorphic_allocator<pair<const _Key, _Value>>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_MAP */

libcxx/include/experimental/memory_resource

 
 // C++1y
 
 namespace std {
 namespace experimental {
 inline namespace fundamentals_v1 {
 namespace pmr {
 
-  class memory_resource;
-
-  bool operator==(const memory_resource& a,
-                  const memory_resource& b) noexcept;
-  bool operator!=(const memory_resource& a,
-                  const memory_resource& b) noexcept;
-
-  template <class Tp> class polymorphic_allocator;
-
-  template <class T1, class T2>
-  bool operator==(const polymorphic_allocator<T1>& a,
-                  const polymorphic_allocator<T2>& b) noexcept;
-  template <class T1, class T2>
-  bool operator!=(const polymorphic_allocator<T1>& a,
-                  const polymorphic_allocator<T2>& b) noexcept;
-
   // The name resource_adaptor_imp is for exposition only.
   template <class Allocator> class resource_adaptor_imp;
 
   template <class Allocator>
     using resource_adaptor = resource_adaptor_imp<
       allocator_traits<Allocator>::rebind_alloc<char>>;
 
-  // Global memory resources
-  memory_resource* new_delete_resource() noexcept;
-  memory_resource* null_memory_resource() noexcept;
-
-  // The default memory resource
-  memory_resource* set_default_resource(memory_resource* r) noexcept;
-  memory_resource* get_default_resource() noexcept;
-
-  // Standard memory resources
-  struct pool_options;
-  class synchronized_pool_resource;
-  class unsynchronized_pool_resource;
-  class monotonic_buffer_resource;
-
 } // namespace pmr
 } // namespace fundamentals_v1
 } // namespace experimental
 } // namespace std
 
  */
 
 #include <__assert> // all public C++ headers provide the assertion handler
 #include <__memory/allocator_traits.h>
 #include <__type_traits/aligned_storage.h>
 #include <__utility/move.h>
 #include <cstddef>
 #include <experimental/__config>
-#include <experimental/__memory>
 #include <limits>
+#include <memory_resource>
 #include <new>
 #include <stdexcept>
 #include <tuple>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#define _LIBCPP_DEPCREATED_MEMORY_RESOURCE(name)                                                                       \
-  _LIBCPP_DEPRECATED_("'std::experimental::pmr::" name                                                                 \
-                      "' is deprecated and will be removed in LLVM 18. Use 'std::pmr::" name "' instead.")
+namespace std::experimental::inline fundamentals_v3::pmr {
 
-#ifndef _LIBCPP_CXX03_LANG
+#if _LIBCPP_STD_VER >= 20
 
 // Round __s up to next multiple of __a.
 inline _LIBCPP_INLINE_VISIBILITY
 size_t __aligned_allocation_size(size_t __s, size_t __a) _NOEXCEPT
 {
     _LIBCPP_ASSERT_UNCATEGORIZED(__s + __a > __s, "aligned allocation size overflows");
     return (__s + __a - 1) & ~(__a - 1);
 }
 
-// 8.5, memory.resource
-class _LIBCPP_DEPCREATED_MEMORY_RESOURCE("memory_resource") _LIBCPP_EXPORTED_FROM_ABI memory_resource
-{
-    static const size_t __max_align = _LIBCPP_ALIGNOF(max_align_t);
-
-// 8.5.2, memory.resource.public
-public:
-    _LIBCPP_HIDE_FROM_ABI_VIRTUAL virtual ~memory_resource() = default;
-
-    _LIBCPP_INLINE_VISIBILITY
-    void* allocate(size_t __bytes, size_t __align = __max_align)
-        { return do_allocate(__bytes, __align); }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void deallocate(void * __p, size_t __bytes, size_t __align = __max_align)
-        { do_deallocate(__p, __bytes, __align); }
-
-    _LIBCPP_INLINE_VISIBILITY
-    bool is_equal(memory_resource const & __other) const _NOEXCEPT
-        { return do_is_equal(__other); }
-
-// 8.5.3, memory.resource.priv
-private:
-    virtual void* do_allocate(size_t, size_t) = 0;
-    virtual void do_deallocate(void*, size_t, size_t) = 0;
-    virtual bool do_is_equal(memory_resource const &) const _NOEXCEPT = 0;
-};
-
-// 8.5.4, memory.resource.eq
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("operator==(memory_resource, memory_resource)") inline _LIBCPP_INLINE_VISIBILITY
-bool operator==(memory_resource const & __lhs,
-                memory_resource const & __rhs) _NOEXCEPT
-{
-    return &__lhs == &__rhs || __lhs.is_equal(__rhs);
-}
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("operator!=(memory_resource, memory_resource)") inline _LIBCPP_INLINE_VISIBILITY
-bool operator!=(memory_resource const & __lhs,
-                memory_resource const & __rhs) _NOEXCEPT
-{
-    return !(__lhs == __rhs);
-}
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("new_delete_resource()") _LIBCPP_EXPORTED_FROM_ABI
-memory_resource * new_delete_resource() _NOEXCEPT;
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("null_memory_resource()") _LIBCPP_EXPORTED_FROM_ABI
-memory_resource * null_memory_resource() _NOEXCEPT;
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("get_default_resource()") _LIBCPP_EXPORTED_FROM_ABI
-memory_resource * get_default_resource() _NOEXCEPT;
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("set_default_resource()") _LIBCPP_EXPORTED_FROM_ABI
-memory_resource * set_default_resource(memory_resource * __new_res) _NOEXCEPT;
-
-// 8.6, memory.polymorphic.allocator.class
-
-// 8.6.1, memory.polymorphic.allocator.overview
-template <class _ValueType>
-class _LIBCPP_DEPCREATED_MEMORY_RESOURCE("polymorphic_allocator") _LIBCPP_TEMPLATE_VIS polymorphic_allocator
-{
-public:
-    typedef _ValueType value_type;
-
-    // 8.6.2, memory.polymorphic.allocator.ctor
-    _LIBCPP_INLINE_VISIBILITY
-    polymorphic_allocator() _NOEXCEPT
-      : __res_(_VSTD_LFTS_PMR::get_default_resource())
-    {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    polymorphic_allocator(memory_resource * __r) _NOEXCEPT
-      : __res_(__r)
-    {}
-
-    _LIBCPP_HIDE_FROM_ABI polymorphic_allocator(polymorphic_allocator const &) = default;
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY
-    polymorphic_allocator(polymorphic_allocator<_Tp> const & __other) _NOEXCEPT
-      : __res_(__other.resource())
-    {}
-
-    polymorphic_allocator &
-    operator=(polymorphic_allocator const &) = delete;
-
-    // 8.6.3, memory.polymorphic.allocator.mem
-    _LIBCPP_INLINE_VISIBILITY
-    _ValueType* allocate(size_t __n) {
-        if (__n > __max_size())
-            __throw_bad_array_new_length();
-        return static_cast<_ValueType*>(
-            __res_->allocate(__n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType))
-        );
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT {
-        _LIBCPP_ASSERT_UNCATEGORIZED(__n <= __max_size(),
-                                     "deallocate called for size which exceeds max_size()");
-        __res_->deallocate(__p, __n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType));
-    }
-
-    template <class _Tp, class ..._Ts>
-    _LIBCPP_INLINE_VISIBILITY
-    void construct(_Tp* __p, _Ts &&... __args)
-    {
-        _VSTD_LFTS::__lfts_user_alloc_construct(
-            __p, *this, _VSTD::forward<_Ts>(__args)...
-          );
-    }
-
-    template <class _T1, class _T2, class ..._Args1, class ..._Args2>
-    _LIBCPP_INLINE_VISIBILITY
-    void construct(pair<_T1, _T2>* __p, piecewise_construct_t,
-                   tuple<_Args1...> __x, tuple<_Args2...> __y)
-    {
-        ::new ((void*)__p) pair<_T1, _T2>(piecewise_construct
-          , __transform_tuple(
-              typename __lfts_uses_alloc_ctor<
-                  _T1, polymorphic_allocator&, _Args1...
-              >::type()
-            , _VSTD::move(__x)
-            , typename __make_tuple_indices<sizeof...(_Args1)>::type{}
-          )
-          , __transform_tuple(
-              typename __lfts_uses_alloc_ctor<
-                  _T2, polymorphic_allocator&, _Args2...
-              >::type()
-            , _VSTD::move(__y)
-            , typename __make_tuple_indices<sizeof...(_Args2)>::type{}
-          )
-        );
-    }
-
-    template <class _T1, class _T2>
-    _LIBCPP_INLINE_VISIBILITY
-    void construct(pair<_T1, _T2>* __p) {
-        construct(__p, piecewise_construct, tuple<>(), tuple<>());
-    }
-
-    template <class _T1, class _T2, class _Up, class _Vp>
-    _LIBCPP_INLINE_VISIBILITY
-    void construct(pair<_T1, _T2> * __p, _Up && __u, _Vp && __v) {
-        construct(__p, piecewise_construct
-          , _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__u))
-          , _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__v)));
-    }
-
-    template <class _T1, class _T2, class _U1, class _U2>
-    _LIBCPP_INLINE_VISIBILITY
-    void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> const & __pr) {
-        construct(__p, piecewise_construct
-            , _VSTD::forward_as_tuple(__pr.first)
-            , _VSTD::forward_as_tuple(__pr.second));
-    }
-
-    template <class _T1, class _T2, class _U1, class _U2>
-    _LIBCPP_INLINE_VISIBILITY
-    void construct(pair<_T1, _T2> * __p, pair<_U1, _U2> && __pr){
-        construct(__p, piecewise_construct
-            , _VSTD::forward_as_tuple(_VSTD::forward<_U1>(__pr.first))
-            , _VSTD::forward_as_tuple(_VSTD::forward<_U2>(__pr.second)));
-    }
-
-    template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY
-    void destroy(_Tp * __p) _NOEXCEPT
-        { __p->~_Tp(); }
-
-    _LIBCPP_INLINE_VISIBILITY
-    polymorphic_allocator
-    select_on_container_copy_construction() const _NOEXCEPT
-        { return polymorphic_allocator(); }
-
-    _LIBCPP_INLINE_VISIBILITY
-    memory_resource * resource() const _NOEXCEPT
-        { return __res_; }
-
-private:
-    template <class ..._Args, size_t ..._Idx>
-    _LIBCPP_INLINE_VISIBILITY
-    tuple<_Args&&...>
-    __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t,
-                      __tuple_indices<_Idx...>) const
-    {
-        return _VSTD::forward_as_tuple(_VSTD::get<_Idx>(_VSTD::move(__t))...);
-    }
-
-    template <class ..._Args, size_t ..._Idx>
-    _LIBCPP_INLINE_VISIBILITY
-    tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>
-    __transform_tuple(integral_constant<int, 1>, tuple<_Args...> && __t,
-                      __tuple_indices<_Idx...>)
-    {
-        using _Tup = tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>;
-        return _Tup(allocator_arg, *this,
-                    _VSTD::get<_Idx>(_VSTD::move(__t))...);
-    }
-
-    template <class ..._Args, size_t ..._Idx>
-    _LIBCPP_INLINE_VISIBILITY
-    tuple<_Args&&..., polymorphic_allocator&>
-    __transform_tuple(integral_constant<int, 2>, tuple<_Args...> && __t,
-                      __tuple_indices<_Idx...>)
-    {
-        using _Tup = tuple<_Args&&..., polymorphic_allocator&>;
-        return _Tup(_VSTD::get<_Idx>(_VSTD::move(__t))..., *this);
-    }
-
-    _LIBCPP_INLINE_VISIBILITY
-    size_t __max_size() const _NOEXCEPT
-        { return numeric_limits<size_t>::max() / sizeof(value_type); }
-
-    memory_resource * __res_;
-};
-
-// 8.6.4, memory.polymorphic.allocator.eq
-
-template <class _Tp, class _Up>
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("operator==(const polymorphic_allocator&, const polymorphic_allocator&)")
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator==(polymorphic_allocator<_Tp> const & __lhs,
-                polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
-{
-    return *__lhs.resource() == *__rhs.resource();
-}
-
-template <class _Tp, class _Up>
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("operator!=(const polymorphic_allocator&, const polymorphic_allocator&)")
-inline _LIBCPP_INLINE_VISIBILITY
-bool operator!=(polymorphic_allocator<_Tp> const & __lhs,
-                polymorphic_allocator<_Up> const & __rhs) _NOEXCEPT
-{
-    return !(__lhs == __rhs);
-}
-
 // 8.7, memory.resource.adaptor
 
 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 // 8.7.1, memory.resource.adaptor.overview
 template <class _CharAlloc>
 class _LIBCPP_TEMPLATE_VIS __resource_adaptor_imp
-  : public memory_resource
+  : public std::pmr::memory_resource
 {
     using _CTraits = allocator_traits<_CharAlloc>;
     static_assert(is_same<typename _CTraits::value_type, char>::value
                && is_same<typename _CTraits::pointer, char*>::value
                && is_same<typename _CTraits::void_pointer, void*>::value, "");
 
     static const size_t _MaxAlign = _LIBCPP_ALIGNOF(max_align_t);
 

 };
 
 template <class _Alloc>
 using resource_adaptor = __resource_adaptor_imp<
     typename allocator_traits<_Alloc>::template rebind_alloc<char>
   >;
 _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-#endif // _LIBCPP_CXX03_LANG
+#endif // _LIBCPP_STD_VER >= 20
 
-_LIBCPP_END_NAMESPACE_LFTS_PMR
+} // namespace std::experimental::fundamentals_v3::pmr
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <atomic>
 #  include <climits>
 #  include <concepts>
 #  include <cstdlib>

libcxx/include/experimental/propagate_const

 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 const _Up& get_underlying(const propagate_const<_Up>& __pu) _NOEXCEPT;
 
 template <class _Up>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR
 _Up& get_underlying(propagate_const<_Up>& __pu) _NOEXCEPT;
 
 template <class _Tp>
-class propagate_const
+class _LIBCPP_DEPRECATED_LFTS_IS_NOW_CXX20("propagate_const") propagate_const
 {
 public:
   typedef remove_reference_t<decltype(*std::declval<_Tp&>())> element_type;
 
   static_assert(!is_array<_Tp>::value,
       "Instantiation of propagate_const with an array type is ill-formed.");
   static_assert(!is_reference<_Tp>::value,
       "Instantiation of propagate_const with a reference type is ill-formed.");
_LIBCPP_CONSTEXPR _Tp& get_underlying(propagate_const<_Tp>& __pt) _NOEXCEPT
   return __pt.__t_;
 }
 
 _LIBCPP_END_NAMESPACE_LFTS_V2
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>
-struct hash<experimental::fundamentals_v2::propagate_const<_Tp>>
+struct hash<experimental::propagate_const<_Tp>>
 {
   typedef size_t result_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> argument_type;
+  typedef experimental::propagate_const<_Tp> argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1) const
+  _LIBCPP_HIDE_FROM_ABI size_t operator()(const experimental::propagate_const<_Tp>& __pc1) const
   {
     return std::hash<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1));
   }
 };
 
 template <class _Tp>
-struct equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
+struct equal_to<experimental::propagate_const<_Tp>>
 {
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+  typedef experimental::propagate_const<_Tp> first_argument_type;
+  typedef experimental::propagate_const<_Tp> second_argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
-      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::propagate_const<_Tp>& __pc1,
+      const experimental::propagate_const<_Tp>& __pc2) const
   {
     return std::equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
   }
 };
 
 template <class _Tp>
-struct not_equal_to<experimental::fundamentals_v2::propagate_const<_Tp>>
+struct not_equal_to<experimental::propagate_const<_Tp>>
 {
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+  typedef experimental::propagate_const<_Tp> first_argument_type;
+  typedef experimental::propagate_const<_Tp> second_argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
-      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::propagate_const<_Tp>& __pc1,
+      const experimental::propagate_const<_Tp>& __pc2) const
   {
     return std::not_equal_to<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
   }
 };
 
 template <class _Tp>
-struct less<experimental::fundamentals_v2::propagate_const<_Tp>>
+struct less<experimental::propagate_const<_Tp>>
 {
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+  typedef experimental::propagate_const<_Tp> first_argument_type;
+  typedef experimental::propagate_const<_Tp> second_argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
-      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::propagate_const<_Tp>& __pc1,
+      const experimental::propagate_const<_Tp>& __pc2) const
   {
     return std::less<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
   }
 };
 
 template <class _Tp>
-struct greater<experimental::fundamentals_v2::propagate_const<_Tp>>
+struct greater<experimental::propagate_const<_Tp>>
 {
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+  typedef experimental::propagate_const<_Tp> first_argument_type;
+  typedef experimental::propagate_const<_Tp> second_argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
-      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::propagate_const<_Tp>& __pc1,
+      const experimental::propagate_const<_Tp>& __pc2) const
   {
     return std::greater<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
   }
 };
 
 template <class _Tp>
-struct less_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
+struct less_equal<experimental::propagate_const<_Tp>>
 {
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+  typedef experimental::propagate_const<_Tp> first_argument_type;
+  typedef experimental::propagate_const<_Tp> second_argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
-      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::propagate_const<_Tp>& __pc1,
+      const experimental::propagate_const<_Tp>& __pc2) const
   {
     return std::less_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
   }
 };
 
 template <class _Tp>
-struct greater_equal<experimental::fundamentals_v2::propagate_const<_Tp>>
+struct greater_equal<experimental::propagate_const<_Tp>>
 {
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> first_argument_type;
-  typedef experimental::fundamentals_v2::propagate_const<_Tp> second_argument_type;
+  typedef experimental::propagate_const<_Tp> first_argument_type;
+  typedef experimental::propagate_const<_Tp> second_argument_type;
 
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::fundamentals_v2::propagate_const<_Tp>& __pc1,
-      const experimental::fundamentals_v2::propagate_const<_Tp>& __pc2) const
+  _LIBCPP_HIDE_FROM_ABI bool operator()(const experimental::propagate_const<_Tp>& __pc1,
+      const experimental::propagate_const<_Tp>& __pc2) const
   {
     return std::greater_equal<_Tp>()(_VSTD_LFTS_V2::get_underlying(__pc1), _VSTD_LFTS_V2::get_underlying(__pc2));
   }
 };
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP_STD_VER >= 14
 
 _LIBCPP_POP_MACROS
 
 #if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #  include <type_traits>
 #endif
 
 #endif // _LIBCPP_EXPERIMENTAL_PROPAGATE_CONST

libcxx/include/experimental/regex

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_REGEX
-#define _LIBCPP_EXPERIMENTAL_REGEX
-
-/*
-    experimental/regex synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class BidirectionalIterator>
-  using match_results =
-    std::match_results<BidirectionalIterator,
-                       polymorphic_allocator<sub_match<BidirectionalIterator>>>;
-
-  typedef match_results<const char*> cmatch;
-  typedef match_results<const wchar_t*> wcmatch;
-  typedef match_results<string::const_iterator> smatch;
-  typedef match_results<wstring::const_iterator> wsmatch;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <experimental/string>
-#include <regex>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _BiDirIter>
-using match_results =
-    _VSTD::match_results<_BiDirIter,
-        polymorphic_allocator<_VSTD::sub_match<_BiDirIter>>>;
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("cmatch") typedef match_results<const char*> cmatch;
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("smatch") typedef match_results<_VSTD_LFTS_PMR::string::const_iterator> smatch;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("wcmatch") typedef match_results<const wchar_t*> wcmatch;
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("wsmatch") typedef match_results<_VSTD_LFTS_PMR::wstring::const_iterator> wsmatch;
-#endif
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_REGEX */

libcxx/include/experimental/set

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_SET
-#define _LIBCPP_EXPERIMENTAL_SET
-
-/*
-    experimental/set synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class Key, class T, class Compare = less<Key>>
-  using set = std::set<Key, T, Compare,
-                       polymorphic_allocator<pair<const Key,T>>>;
-
-  template <class Key, class T, class Compare = less<Key>>
-  using multiset = std::multiset<Key, T, Compare,
-                                 polymorphic_allocator<pair<const Key,T>>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <set>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Value, class  _Compare = less<_Value>>
-using set = _VSTD::set<_Value, _Compare,
-                        polymorphic_allocator<_Value>>;
-
-template <class _Value, class  _Compare = less<_Value>>
-using multiset = _VSTD::multiset<_Value, _Compare,
-                        polymorphic_allocator<_Value>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_SET */

libcxx/include/experimental/string

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_STRING
-#define _LIBCPP_EXPERIMENTAL_STRING
-
-/*
-    experimental/string synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  // basic_string using polymorphic allocator in namespace pmr
-  template <class charT, class traits = char_traits<charT>>
-   using basic_string =
-     std::basic_string<charT, traits, polymorphic_allocator<charT>>;
-
-  // basic_string typedef names using polymorphic allocator in namespace
-  // std::experimental::pmr
-  typedef basic_string<char> string;
-  typedef basic_string<char16_t> u16string;
-  typedef basic_string<char32_t> u32string;
-  typedef basic_string<wchar_t> wstring;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <string>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-
-template <class _CharT, class _Traits = char_traits<_CharT>>
-using basic_string =
-    _VSTD::basic_string<_CharT, _Traits, polymorphic_allocator<_CharT>>;
-
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("string") typedef basic_string<char> string;
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("u16string") typedef basic_string<char16_t> u16string;
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("u32string") typedef basic_string<char32_t> u32string;
-#ifndef _LIBCPP_HAS_NO_WIDE_CHARACTERS
-_LIBCPP_DEPCREATED_MEMORY_RESOURCE("wstring") typedef basic_string<wchar_t> wstring;
-#endif
-
-_LIBCPP_SUPPRESS_DEPRECATED_POP
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_STRING */

libcxx/include/experimental/type_traits

 
 template <class _Tp>
 using invokation_type_t = typename invokation_type<_Tp>::type;
 
 template <class _Tp>
 using raw_invocation_type_t = typename raw_invocation_type<_Tp>::type;
 */
 
-// 3.3.4, Detection idiom
-template <class...> using void_t = void;
-
-struct nonesuch : private __nat { // make nonesuch "not an aggregate"
+struct _LIBCPP_DEPRECATED_LFTS_IS_NOW_CXX20("nonesuch") nonesuch : private __nat { // make nonesuch "not an aggregate"
   ~nonesuch() = delete;
   nonesuch      (nonesuch const&) = delete;
   void operator=(nonesuch const&) = delete;
   };
 
 template <class _Default, class _AlwaysVoid, template <class...> class _Op, class... _Args>
 struct _DETECTOR {
    using value_t = false_type;
    using type = _Default;
    };
 
 template <class _Default, template <class...> class _Op, class... _Args>
 struct _DETECTOR<_Default, void_t<_Op<_Args...>>, _Op, _Args...> {
    using value_t = true_type;
    using type = _Op<_Args...>;
    };
 
 
 template <template<class...> class _Op, class... _Args>
   using is_detected = typename _DETECTOR<nonesuch, void, _Op, _Args...>::value_t;
 template <template<class...> class _Op, class... _Args>
   using detected_t = typename _DETECTOR<nonesuch, void, _Op, _Args...>::type;
 template <template<class...> class _Op, class... _Args>
-  _LIBCPP_CONSTEXPR bool is_detected_v = is_detected<_Op, _Args...>::value;
+  _LIBCPP_DEPRECATED_LFTS_IS_NOW_CXX20("is_detected_v") _LIBCPP_CONSTEXPR bool is_detected_v = is_detected<_Op, _Args...>::value;
 
 template <class _Default, template<class...> class _Op, class... _Args>
   using detected_or = _DETECTOR<_Default, void, _Op, _Args...>;
 template <class _Default, template<class...> class _Op, class... _Args>
   using detected_or_t = typename detected_or<_Default, _Op, _Args...>::type;
 
 template <class _Expected, template<class...> class _Op, class... _Args>
   using is_detected_exact = is_same<_Expected, detected_t<_Op, _Args...>>;
 template <class _Expected, template<class...> class _Op, class... _Args>
-  _LIBCPP_CONSTEXPR bool is_detected_exact_v = is_detected_exact<_Expected, _Op, _Args...>::value;
+  _LIBCPP_DEPRECATED_LFTS_IS_NOW_CXX20("is_detected_exact_v") _LIBCPP_CONSTEXPR bool is_detected_exact_v = is_detected_exact<_Expected, _Op, _Args...>::value;
 
 template <class _To, template<class...> class _Op, class... _Args>
   using is_detected_convertible = is_convertible<detected_t<_Op, _Args...>, _To>;
 template <class _To, template<class...> class _Op, class... _Args>
-  _LIBCPP_CONSTEXPR bool is_detected_convertible_v = is_detected_convertible<_To, _Op, _Args...>::value;
+  _LIBCPP_DEPRECATED_LFTS_IS_NOW_CXX20("is_detected_convertible_v") _LIBCPP_CONSTEXPR bool is_detected_convertible_v = is_detected_convertible<_To, _Op, _Args...>::value;
 
 
 _LIBCPP_END_NAMESPACE_LFTS
 
 #endif /* _LIBCPP_STD_VER >= 14 */
 
 #endif /* _LIBCPP_EXPERIMENTAL_TYPE_TRAITS */

libcxx/include/experimental/unordered_map

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_UNORDERED_MAP
-#define _LIBCPP_EXPERIMENTAL_UNORDERED_MAP
-
-/*
-    experimental/unordered_map synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class Key, class T,
-            class Hash = hash<Key>,
-            class Pred = equal_to<Key>>
-  using unordered_map =
-    std::unordered_map<Key, T, Hash, Pred,
-                       polymorphic_allocator<pair<const Key,T>>>;
-
-  template <class Key, class T,
-            class Hash = hash<Key>,
-            class Pred = equal_to<Key>>
-  using unordered_multimap =
-    std::unordered_multimap<Key, T, Hash, Pred,
-                            polymorphic_allocator<pair<const Key,T>>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <unordered_map>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Key, class _Value,
-          class _Hash = hash<_Key>, class _Pred = equal_to<_Key>>
-using unordered_map = _VSTD::unordered_map<_Key, _Value, _Hash, _Pred,
-                        polymorphic_allocator<pair<const _Key, _Value>>>;
-
-template <class _Key, class _Value,
-          class _Hash = hash<_Key>, class _Pred = equal_to<_Key>>
-using unordered_multimap = _VSTD::unordered_multimap<_Key, _Value, _Hash, _Pred,
-                        polymorphic_allocator<pair<const _Key, _Value>>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
-#  include <algorithm>
-#  include <array>
-#  include <bit>
-#  include <functional>
-#  include <vector>
-#endif
-
-#endif /* _LIBCPP_EXPERIMENTAL_UNORDERED_MAP */

libcxx/include/experimental/unordered_set

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_UNORDERED_SET
-#define _LIBCPP_EXPERIMENTAL_UNORDERED_SET
-
-/*
-    experimental/unordered_set synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class T, class Hash = hash<T>, class Pred = equal_to<T>>
-  using unordered_set = std::unordered_set<T, Hash, Pred,
-                       polymorphic_allocator<T>>;
-
-  template <class T, class Hash = hash<T>, class Pred = equal_to<T>>
-  using unordered_multiset = std::unordered_multiset<T, Hash, Pred,
-                       polymorphic_allocator<T>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <unordered_set>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _Value,
-          class _Hash = hash<_Value>, class _Pred = equal_to<_Value>>
-using unordered_set = _VSTD::unordered_set<_Value, _Hash, _Pred,
-                        polymorphic_allocator<_Value>>;
-
-template <class _Value,
-          class _Hash = hash<_Value>, class _Pred = equal_to<_Value>>
-using unordered_multiset = _VSTD::unordered_multiset<_Value, _Hash, _Pred,
-                        polymorphic_allocator<_Value>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_UNORDERED_SET */

libcxx/include/experimental/utility

 #include <utility>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
-  struct _LIBCPP_TEMPLATE_VIS erased_type { };
+struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_LFTS_IS_NOW_CXX20("erased_type") erased_type { };
 
 _LIBCPP_END_NAMESPACE_LFTS
 
 #endif /* _LIBCPP_EXPERIMENTAL_UTILITY */

libcxx/include/experimental/vector

-// -*- C++ -*-
-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXPERIMENTAL_VECTOR
-#define _LIBCPP_EXPERIMENTAL_VECTOR
-
-/*
-    experimental/vector synopsis
-
-// C++1z
-namespace std {
-namespace experimental {
-inline namespace fundamentals_v1 {
-namespace pmr {
-
-  template <class T>
-  using vector = std::vector<T, polymorphic_allocator<T>>;
-
-} // namespace pmr
-} // namespace fundamentals_v1
-} // namespace experimental
-} // namespace std
-
- */
-
-#include <__assert> // all public C++ headers provide the assertion handler
-#include <experimental/__config>
-#include <experimental/memory_resource>
-#include <vector>
-
-#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
-#  pragma GCC system_header
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-#ifndef _LIBCPP_CXX03_LANG
-
-template <class _ValueT>
-using vector = _VSTD::vector<_ValueT, polymorphic_allocator<_ValueT>>;
-
-#endif // _LIBCPP_CXX03_LANG
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR
-
-#endif /* _LIBCPP_EXPERIMENTAL_VECTOR */

libcxx/src/experimental/memory_resource.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
-//
-//===----------------------------------------------------------------------===//
-
-#include <experimental/memory_resource>
-
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
-
-#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
-#  include <atomic>
-#elif !defined(_LIBCPP_HAS_NO_THREADS)
-#  include <mutex>
-#  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
-#    pragma comment(lib, "pthread")
-#  endif
-#endif
-
-_LIBCPP_BEGIN_NAMESPACE_LFTS_PMR
-
-// memory_resource
-
-//memory_resource::~memory_resource() {}
-
-// new_delete_resource()
-
-class _LIBCPP_EXPORTED_FROM_ABI __new_delete_memory_resource_imp
-    : public memory_resource
-{
-    void *do_allocate(size_t size, size_t align) override {
-#ifdef _LIBCPP_HAS_NO_ALIGNED_ALLOCATION
-        if (__is_overaligned_for_new(align))
-            __throw_bad_alloc();
-#endif
-        return _VSTD::__libcpp_allocate(size, align);
-    }
-
-    void do_deallocate(void *p, size_t n, size_t align) override {
-      _VSTD::__libcpp_deallocate(p, n, align);
-    }
-
-    bool do_is_equal(memory_resource const & other) const noexcept override
-        { return &other == this; }
-
-public:
-    ~__new_delete_memory_resource_imp() override = default;
-};
-
-// null_memory_resource()
-
-class _LIBCPP_EXPORTED_FROM_ABI __null_memory_resource_imp
-    : public memory_resource
-{
-public:
-    ~__null_memory_resource_imp() = default;
-
-protected:
-    virtual void* do_allocate(size_t, size_t) {
-        __throw_bad_alloc();
-    }
-    virtual void do_deallocate(void *, size_t, size_t) {}
-    virtual bool do_is_equal(memory_resource const & __other) const noexcept
-    { return &__other == this; }
-};
-
-namespace {
-
-union ResourceInitHelper {
-  struct {
-    __new_delete_memory_resource_imp new_delete_res;
-    __null_memory_resource_imp       null_res;
-  } resources;
-  char dummy;
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 ResourceInitHelper() : resources() {}
-  ~ResourceInitHelper() {}
-};
-
-// Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
-// attribute with a value that's reserved for the implementation (we're the implementation).
-#include "memory_resource_init_helper.h"
-
-} // end namespace
-
-
-memory_resource * new_delete_resource() noexcept {
-    return &res_init.resources.new_delete_res;
-}
-
-memory_resource * null_memory_resource() noexcept {
-    return &res_init.resources.null_res;
-}
-
-// default_memory_resource()
-
-static memory_resource *
-__default_memory_resource(bool set = false, memory_resource * new_res = nullptr) noexcept
-{
-#ifndef _LIBCPP_HAS_NO_ATOMIC_HEADER
-    static constinit atomic<memory_resource*> __res{&res_init.resources.new_delete_res};
-    if (set) {
-        new_res = new_res ? new_res : new_delete_resource();
-        // TODO: Can a weaker ordering be used?
-        return _VSTD::atomic_exchange_explicit(
-            &__res, new_res, memory_order_acq_rel);
-    }
-    else {
-        return _VSTD::atomic_load_explicit(
-            &__res, memory_order_acquire);
-    }
-#elif !defined(_LIBCPP_HAS_NO_THREADS)
-    static constinit memory_resource *res = &res_init.resources.new_delete_res;
-    static mutex res_lock;
-    if (set) {
-        new_res = new_res ? new_res : new_delete_resource();
-        lock_guard<mutex> guard(res_lock);
-        memory_resource * old_res = res;
-        res = new_res;
-        return old_res;
-    } else {
-        lock_guard<mutex> guard(res_lock);
-        return res;
-    }
-#else
-    static constinit memory_resource *res = &res_init.resources.new_delete_res;
-    if (set) {
-        new_res = new_res ? new_res : new_delete_resource();
-        memory_resource * old_res = res;
-        res = new_res;
-        return old_res;
-    } else {
-        return res;
-    }
-#endif
-}
-
-memory_resource * get_default_resource() noexcept
-{
-    return __default_memory_resource();
-}
-
-memory_resource * set_default_resource(memory_resource * __new_res) noexcept
-{
-    return __default_memory_resource(true, __new_res);
-}
-
-_LIBCPP_END_NAMESPACE_LFTS_PMR

libcxx/src/experimental/memory_resource_init_helper.h

-#pragma GCC system_header
-static constinit ResourceInitHelper res_init _LIBCPP_INIT_PRIORITY_MAX;