[libc++] Implement P0339R6 (polymorphic_allocator<> as a vocabulary type)

[ldionne]

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/allocate_vocabulary.pass.cpp

1 ↗

(On Diff #474348)

You're going to hate this, but we have one test file per public API function. Let's be consistent.

51 ↗

(On Diff #474348)

Not attached to line: Please add an explicit test that polymorphic_allocator<> is the same as polymorphic_allocator<byte>.

56 ↗

(On Diff #474348)

Typo

58 ↗

(On Diff #474348)

You're only testing with std::pmr::polymorphic_allocator<>, but in reality this paper added new methods for all specializations of polymorphic_allocator. For example, I'd expect to have a test that we can call allocate_bytes and deallocate_bytes on a polymorphic_allocator<Foo>, and even allocate_object<int>() on a polymorphic_allocator<Foo>.

[LRFLEW]

The implementation of polymorphic_allocator::allocate_object here doesn't follow the changes in LWG 3237 and LWG 3310. SIZE_MAX should be replaced with numeric_limits<size_t>::max() (perhaps using a templated version of __max_size()), and the error condition should throw bad_array_new_length instead of length_error.

Also, on the topic of LWG 3304, it looks like polymorphic_allocator::allocate is supposed to be marked as [[nodiscard]] in C++20. Would it make sense for this patch to also include that change as well?

Lastly, I noticed that the existing code is using #if _LIBCPP_STD_VER > 14, but the code added here is using #if _LIBCPP_STD_VER >= 20. Would it make more sense to use #if _LIBCPP_STD_VER > 17 instead?

[philnik]

In D137739#3956055, @LRFLEW wrote:

The implementation of polymorphic_allocator::allocate_object here doesn't follow the changes in LWG 3237 and LWG 3310. SIZE_MAX should be replaced with numeric_limits<size_t>::max() (perhaps using a templated version of __max_size()), and the error condition should throw bad_array_new_length instead of length_error.

Thanks for the info! I'll apply them in this patch, since they are almost trivial. It looks like we accidentally marked LWG3237 as done already.

Also, on the topic of LWG 3304, it looks like polymorphic_allocator::allocate is supposed to be marked as [[nodiscard]] in C++20. Would it make sense for this patch to also include that change as well?

See D137597 for that.

Lastly, I noticed that the existing code is using #if _LIBCPP_STD_VER > 14, but the code added here is using #if _LIBCPP_STD_VER >= 20. Would it make more sense to use #if _LIBCPP_STD_VER > 17 instead?

We decided to use _LIBCPP_STD_VER >= x for new code.

[philnik]

Address comments

[ldionne]

LGTM with green CI and comments applied. Thanks @LRFLEW for the comments, those were good observations.

libcxx/include/__memory_resource/polymorphic_allocator.h

113

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/allocate_bytes.pass.cpp

1 ↗

(On Diff #478555)

Let's name this allocate_deallocate_bytes.pass.cpp. Same for allocate_object.pass.cpp.

61 ↗

(On Diff #478555)

return 0;

Everywhere.

[philnik]

• Rebased
• Address comments

[philnik]

Try to fix CI

[philnik]

Try to fix CI

[philnik]

Next try

[philnik]

Next try

[ldionne]

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/default_type.compile.pass.cpp

1

This is XPASSing on macos backdeployment because this would only fail at runtime. Mark this one as UNSUPPORTED on the backdeployment targets instead of XFAIL.

[philnik]

Try to fix CI

[philnik]

Try to fix CI

[philnik]

Next try

[philnik]

Next try

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_jthread``                             *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_latch``                               ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_list_remove_return_type``             ``201806L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_math_constants``                      ``201907L``
     ------------------------------------------------- -----------------
-    ``__cpp_lib_polymorphic_allocator``               *unimplemented*
+    ``__cpp_lib_polymorphic_allocator``               ``201902L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_ranges``                              ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_remove_cvref``                        ``201711L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_semaphore``                           ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_shared_ptr_arrays``                   ``201707L``

libcxx/docs/ReleaseNotes.rst

 - P2273R3 - Making ``std::unique_ptr`` constexpr
 - P0591R4 - Utility functions to implement uses-allocator construction
 - P2291R3 - Add Constexpr Modifiers to Functions ``to_chars`` and
   ``from_chars`` for Integral Types in ``<charconv>`` Header
 - P0220R1 - Adopt Library Fundamentals V1 TS Components for C++17
 - P0482R6 - char8_t: A type for UTF-8 characters and strings
 - P2438R2 - ``std::string::substr() &&``
 - P0600R1 - ``nodiscard`` in the library
+- P0339R6 - ``polymorphic_allocator<>`` as a vocabulary type
 
 Improvements and New Features
 -----------------------------
 - Declarations of ``std::c8rtomb()`` and ``std::mbrtoc8()`` from P0482R6 are
   now provided when implementations in the global namespace are provided by
   the C library.
 - Implemented ``<memory_resource>`` header from C++17
 

libcxx/docs/Status/Cxx20Issues.csv

 "`3141 <https://wg21.link/LWG3141>`__","``CopyConstructible``\  doesn't preserve source values","Prague","|Nothing to do|",""
 "`3150 <https://wg21.link/LWG3150>`__","``UniformRandomBitGenerator``\  should validate ``min``\  and ``max``\ ","Prague","|Complete|","13.0","|ranges|"
 "`3175 <https://wg21.link/LWG3175>`__","The ``CommonReference``\  requirement of concept ``SwappableWith``\  is not satisfied in the example","Prague","|Complete|","13.0"
 "`3194 <https://wg21.link/LWG3194>`__","``ConvertibleTo``\  prose does not match code","Prague","|Complete|","13.0"
 "`3200 <https://wg21.link/LWG3200>`__","``midpoint``\  should not constrain ``T``\  is complete","Prague","|Nothing To Do|",""
 "`3201 <https://wg21.link/LWG3201>`__","``lerp``\  should be marked as ``noexcept``\ ","Prague","|Complete|",""
 "`3226 <https://wg21.link/LWG3226>`__","``zoned_time``\  constructor from ``string_view``\  should accept ``zoned_time<Duration2, TimeZonePtr2>``\ ","Prague","","","|chrono|"
 "`3233 <https://wg21.link/LWG3233>`__","Broken requirements for ``shared_ptr``\  converting constructors","Prague","",""
-"`3237 <https://wg21.link/LWG3237>`__","LWG 3038 and 3190 have inconsistent PRs","Prague","|Complete|","14.0"
+"`3237 <https://wg21.link/LWG3237>`__","LWG 3038 and 3190 have inconsistent PRs","Prague","|Complete|","16.0"
 "`3238 <https://wg21.link/LWG3238>`__","Insufficiently-defined behavior of ``std::function``\  deduction guides","Prague","",""
 "`3242 <https://wg21.link/LWG3242>`__","``std::format``\ : missing rules for ``arg-id``\  in ``width``\  and ``precision``\ ","Prague","|Complete|","Clang 14","|format|"
 "`3243 <https://wg21.link/LWG3243>`__","``std::format``\  and negative zeroes","Prague","|Complete|","14.0","|format|"
 "`3247 <https://wg21.link/LWG3247>`__","``ranges::iter_move``\  should perform ADL-only lookup of ``iter_move``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3248 <https://wg21.link/LWG3248>`__","``std::format``\  ``#b``\ , ``#B``\ , ``#o``\ , ``#x``\ , and ``#X``\   presentation types misformat negative numbers","Prague","|Complete|","14.0","|format|"
 "`3250 <https://wg21.link/LWG3250>`__","``std::format``\ : ``#``\  (alternate form) for NaN and inf","Prague","|Complete|","14.0","|format|"
 "`3251 <https://wg21.link/LWG3251>`__","Are ``std::format``\  alignment specifiers applied to string arguments?","Prague","|Complete|","14.0","|format|"
 "`3252 <https://wg21.link/LWG3252>`__","Parse locale's aware modifiers for commands are not consistent with POSIX spec","Prague","","","|chrono|"

 "`3292 <https://wg21.link/LWG3292>`__","``iota_view``\  is under-constrained","Prague","|Complete|","15.0","|ranges|"
 "`3294 <https://wg21.link/LWG3294>`__","``zoned_time``\  deduction guides misinterprets ``string``\ /``char*``\ ","Prague","","","|chrono|"
 "`3296 <https://wg21.link/LWG3296>`__","Inconsistent default argument for ``basic_regex<>::assign``\ ","Prague","|Complete|",""
 "`3299 <https://wg21.link/LWG3299>`__","Pointers don't need customized iterator behavior","Prague","|Complete|","15.0","|ranges|"
 "`3300 <https://wg21.link/LWG3300>`__","Non-array ``ssize``\  overload is underconstrained","Prague","|Nothing To Do|",""
 "`3301 <https://wg21.link/LWG3301>`__","``transform_view::iterator``\  has incorrect ``iterator_category``\ ","Prague","|Complete|","15.0","|ranges|"
 "`3302 <https://wg21.link/LWG3302>`__","Range adaptor objects ``keys``\  and ``values``\  are unspecified","Prague","","","|ranges|"
 "`3303 <https://wg21.link/LWG3303>`__","Bad ""``constexpr``\ "" marker for ``destroy/destroy_n``\ ","Prague","",""
-"`3304 <https://wg21.link/LWG3304>`__","Allocate functions of ``std::polymorphic_allocator``\  should require ``[[nodiscard]]``\ ","Prague","",""
+"`3304 <https://wg21.link/LWG3304>`__","Allocate functions of ``std::polymorphic_allocator``\  should require ``[[nodiscard]]``\ ","Prague","|Complete|","16.0"
 "`3307 <https://wg21.link/LWG3307>`__","``std::allocator<void>().allocate(n)``\ ","Prague","",""
-"`3310 <https://wg21.link/LWG3310>`__","Replace ``SIZE_MAX``\  with ``numeric_limits<size_t>::max()``\ ","Prague","",""
+"`3310 <https://wg21.link/LWG3310>`__","Replace ``SIZE_MAX``\  with ``numeric_limits<size_t>::max()``\ ","Prague","|Complete|","16.0"
 "`3313 <https://wg21.link/LWG3313>`__","``join_view::iterator::operator--``\  is incorrectly constrained","Prague","|Complete|","14.0","|ranges|"
 "`3314 <https://wg21.link/LWG3314>`__","Is stream insertion behavior locale dependent when ``Period::type``\  is ``micro``\ ?","Prague","|Complete|","16.0","|chrono|"
 "`3315 <https://wg21.link/LWG3315>`__","Correct Allocator Default Behavior","Prague","",""
 "`3316 <https://wg21.link/LWG3316>`__","Correctly define epoch for ``utc_clock``\  / ``utc_timepoint``\ ","Prague","","","|chrono|"
 "`3317 <https://wg21.link/LWG3317>`__","Incorrect ``operator<<``\  for floating-point durations","Prague","","","|chrono|"
 "`3318 <https://wg21.link/LWG3318>`__","Clarify whether clocks can represent time before their epoch","Prague","","","|chrono|"
 "`3319 <https://wg21.link/LWG3319>`__","Properly reference specification of IANA time zone database","Prague","","","|chrono|"
 "`3320 <https://wg21.link/LWG3320>`__","``span::cbegin/cend``\  methods produce different results than ``std::[ranges::]cbegin/cend``\ ","Prague","|Complete|",""

libcxx/docs/Status/Cxx20Papers.csv

 "`P1165R1 <https://wg21.link/P1165R1>`__","LWG","Make stateful allocator propagation more consistent for ``operator+(basic_string)``\ ","San Diego","|Complete|","15.0"
 "`P1209R0 <https://wg21.link/P1209R0>`__","LWG","Adopt Consistent Container Erasure from Library Fundamentals 2 for C++20","San Diego","|Complete|","8.0"
 "`P1210R0 <https://wg21.link/P1210R0>`__","LWG","Completing the Rebase of Library Fundamentals, Version 3, Working Draft","San Diego","* *",""
 "`P1236R1 <https://wg21.link/P1236R1>`__","CWG","Alternative Wording for P0907R4 Signed Integers are Two's Complement","San Diego","* *",""
 "`P1248R1 <https://wg21.link/P1248R1>`__","LWG","Remove CommonReference requirement from StrictWeakOrdering (a.k.a Fixing Relations)","San Diego","|Complete|","13.0"
 "`P1285R0 <https://wg21.link/P1285R0>`__","LWG","Improving Completeness Requirements for Type Traits","San Diego","* *",""
 "`P1353R0 <https://wg21.link/P1353R0>`__","CWG","Missing feature test macros","San Diego","* *",""
 "","","","","",""
-"`P0339R6 <https://wg21.link/P0339R6>`__","LWG","polymorphic_allocator<> as a vocabulary type","Kona","",""
+"`P0339R6 <https://wg21.link/P0339R6>`__","LWG","polymorphic_allocator<> as a vocabulary type","Kona","|Complete|","16.0"
 "`P0340R3 <https://wg21.link/P0340R3>`__","LWG","Making std::underlying_type SFINAE-friendly","Kona","|Complete|","9.0"
 "`P0738R2 <https://wg21.link/P0738R2>`__","LWG","I Stream, You Stream, We All Stream for istream_iterator","Kona","",""
 "`P0811R3 <https://wg21.link/P0811R3>`__","LWG","Well-behaved interpolation for numbers and pointers","Kona","|Complete|","9.0"
 "`P0920R2 <https://wg21.link/P0920R2>`__","LWG","Precalculated hash values in lookup","Kona","Reverted by `P1661 <https://wg21.link/P1661>`__",""
 "`P1001R2 <https://wg21.link/P1001R2>`__","LWG","Target Vectorization Policies from Parallelism V2 TS to C++20","Kona","",""
 "`P1024R3 <https://wg21.link/P1024R3>`__","LWG","Usability Enhancements for std::span","Kona","|Complete|","9.0"
 "`P1164R1 <https://wg21.link/P1164R1>`__","LWG","Make create_directory() Intuitive","Kona","|Complete|","12.0"
 "`P1227R2 <https://wg21.link/P1227R2>`__","LWG","Signed ssize() functions, unsigned size() functions","Kona","|Complete|","9.0"

libcxx/include/__memory_resource/polymorphic_allocator.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___MEMORY_RESOURCE_POLYMORPHIC_ALLOCATOR_H
 #define _LIBCPP___MEMORY_RESOURCE_POLYMORPHIC_ALLOCATOR_H
 
 #include <__assert>
 #include <__config>
 #include <__memory_resource/memory_resource.h>
+#include <__utility/transaction.h>
 #include <cstddef>
 #include <limits>
 #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>
 
 #if _LIBCPP_STD_VER > 14
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 namespace pmr {
 
 // [mem.poly.allocator.class]
 
-template <class _ValueType>
+template <class _ValueType
+#  if _LIBCPP_STD_VER >= 20
+          = byte
+#  endif
+          >
 class _LIBCPP_TEMPLATE_VIS polymorphic_allocator {
+
 public:
   using value_type = _ValueType;
 
   // [mem.poly.allocator.ctor]
 
   _LIBCPP_HIDE_FROM_ABI polymorphic_allocator() noexcept : __res_(std::pmr::get_default_resource()) {}
 
   _LIBCPP_HIDE_FROM_ABI polymorphic_allocator(memory_resource* __r) noexcept : __res_(__r) {}
_LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_HIDE_FROM_ABI _ValueType* allocate(size_t __n) {
     return static_cast<_ValueType*>(__res_->allocate(__n * sizeof(_ValueType), alignof(_ValueType)));
   }
 
   _LIBCPP_HIDE_FROM_ABI void deallocate(_ValueType* __p, size_t __n) {
     _LIBCPP_ASSERT(__n <= __max_size(), "deallocate called for size which exceeds max_size()");
     __res_->deallocate(__p, __n * sizeof(_ValueType), alignof(_ValueType));
   }
 
+#  if _LIBCPP_STD_VER >= 20
+
+  [[nodiscard]] [[using __gnu__: __alloc_size__(2), __alloc_align__(3)]] void*
+  allocate_bytes(size_t __nbytes, size_t __alignment = alignof(max_align_t)) {
+    return __res_->allocate(__nbytes, __alignment);
+  }
+
+  void deallocate_bytes(void* __ptr, size_t __nbytes, size_t __alignment = alignof(max_align_t)) {
+    __res_->deallocate(__ptr, __nbytes, __alignment);
+  }
+
+  template <class _Type>
+  [[nodiscard]] _Type* allocate_object(size_t __n = 1) {
+    if (numeric_limits<size_t>::max() / sizeof(_Type) < __n)
+      std::__throw_bad_array_new_length();
+    return static_cast<_Type*>(allocate_bytes(__n * sizeof(_Type), alignof(_Type)));
+  }
+
+  template <class _Type>
+  void deallocate_object(_Type* __ptr, size_t __n = 1) {
+    deallocate_bytes(__ptr, __n * sizeof(_Type), alignof(_Type));
+  }
+
+  template <class _Type, class... _CtorArgs>
+  [[nodiscard]] _Type* new_object(_CtorArgs&&... __ctor_args) {
+    _Type* __ptr = allocate_object<_Type>();
+    __transaction __guard([&] { deallocate_object(__ptr); });
+    construct(__ptr, std::forward<_CtorArgs>(__ctor_args)...);
+    __guard.__complete();
+    return __ptr;
+  }
+
+  template <class _Type>
+  void delete_object(_Type* __ptr) {
+    destroy(__ptr);
+    deallocate_object(__ptr);
+  }
+
+#  endif // _LIBCPP_STD_VER >= 20
+
   template <class _Tp, class... _Ts>
   _LIBCPP_HIDE_FROM_ABI void construct(_Tp* __p, _Ts&&... __args) {
     std::__user_alloc_construct_impl(
         typename __uses_alloc_ctor<_Tp, polymorphic_allocator&, _Ts...>::type(),
         __p,
         *this,
         std::forward<_Ts>(__args)...);
   }

libcxx/include/__type_traits/is_nothrow_constructible.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___TYPE_TRAITS_IS_NOTHROW_CONSTRUCTIBLE_H
 #define _LIBCPP___TYPE_TRAITS_IS_NOTHROW_CONSTRUCTIBLE_H
 
 #include <__config>
 #include <__type_traits/integral_constant.h>
+#include <__type_traits/is_constructible.h>
+#include <__type_traits/is_reference.h>
+#include <__utility/declval.h>
+#include <cstddef>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if __has_builtin(__is_nothrow_constructible)

libcxx/include/__utility/exchange.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___UTILITY_EXCHANGE_H
 #define _LIBCPP___UTILITY_EXCHANGE_H
 
 #include <__config>
+#include <__type_traits/is_nothrow_assignable.h>
+#include <__type_traits/is_nothrow_move_constructible.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #if _LIBCPP_STD_VER > 11

libcxx/include/__utility/move.h

 // -*- 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___UTILITY_MOVE_H
 #define _LIBCPP___UTILITY_MOVE_H
 
 #include <__config>
-#include <type_traits>
+#include <__type_traits/conditional.h>
+#include <__type_traits/is_copy_constructible.h>
+#include <__type_traits/is_nothrow_move_constructible.h>
+#include <__type_traits/remove_reference.h>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _Tp>

libcxx/include/__utility/transaction.h

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef _LIBCPP___UTILITY_TRANSACTION_H
 #define _LIBCPP___UTILITY_TRANSACTION_H
 
 #include <__config>
+#include <__type_traits/is_nothrow_move_constructible.h>
 #include <__utility/exchange.h>
 #include <__utility/move.h>
-#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // __transaction is a helper class for writing code with the strong exception guarantee.

libcxx/include/experimental/iterator

 _LIBCPP_HIDE_FROM_ABI ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>
 make_ostream_joiner(basic_ostream<_CharT, _Traits>& __os, _Delim && __d)
 { return ostream_joiner<typename decay<_Delim>::type, _CharT, _Traits>(__os, _VSTD::forward<_Delim>(__d)); }
 
 _LIBCPP_END_NAMESPACE_LFTS
 
 #endif // _LIBCPP_STD_VER > 11
 
+#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
+#  include <type_traits>
+#endif
+
 #endif // _LIBCPP_EXPERIMENTAL_ITERATOR

libcxx/include/version

 # if !defined(_LIBCPP_HAS_NO_THREADS)
 // #   define __cpp_lib_jthread                            201911L
 # endif
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_latch)
 #   define __cpp_lib_latch                              201907L
 # endif
 # define __cpp_lib_list_remove_return_type              201806L
 # define __cpp_lib_math_constants                       201907L
-// # define __cpp_lib_polymorphic_allocator                201902L
+# define __cpp_lib_polymorphic_allocator                201902L
 # define __cpp_lib_ranges                               201811L
 # define __cpp_lib_remove_cvref                         201711L
 # if !defined(_LIBCPP_HAS_NO_THREADS) && !defined(_LIBCPP_AVAILABILITY_DISABLE_FTM___cpp_lib_semaphore)
 #   define __cpp_lib_semaphore                          201907L
 # endif
 # undef  __cpp_lib_shared_ptr_arrays
 # define __cpp_lib_shared_ptr_arrays                    201707L
 # define __cpp_lib_shift                                201806L

libcxx/test/libcxx/transitive_includes/cxx2b.csv

 experimental/functional cstddef
 experimental/functional functional
 experimental/functional type_traits
 experimental/functional unordered_map
 experimental/functional vector
 experimental/iterator cstddef
 experimental/iterator iosfwd
 experimental/iterator iterator
-experimental/iterator type_traits
 experimental/list experimental/memory_resource
 experimental/list list
 experimental/map experimental/memory_resource
 experimental/map map
 experimental/memory_resource cstddef
 experimental/memory_resource cstdlib
 experimental/memory_resource experimental/utility
 experimental/memory_resource limits

libcxx/test/libcxx/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/allocate_vocabulary.attributes.verify.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// check that clang warns on non-power-of-two alignment
+
+#include <memory_resource>
+
+void func() {
+  std::pmr::polymorphic_allocator<> allocator;
+  (void)allocator.allocate_bytes(0, 3); // expected-warning {{requested alignment is not a power of 2}}
+
+}

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

 
 # ifndef __cpp_lib_memory_resource
 #   error "__cpp_lib_memory_resource should be defined in c++20"
 # endif
 # if __cpp_lib_memory_resource != 201603L
 #   error "__cpp_lib_memory_resource should have the value 201603L in c++20"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_polymorphic_allocator
-#     error "__cpp_lib_polymorphic_allocator should be defined in c++20"
-#   endif
-#   if __cpp_lib_polymorphic_allocator != 201902L
-#     error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_polymorphic_allocator
-#     error "__cpp_lib_polymorphic_allocator should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_polymorphic_allocator
+#   error "__cpp_lib_polymorphic_allocator should be defined in c++20"
+# endif
+# if __cpp_lib_polymorphic_allocator != 201902L
+#   error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++20"
+# endif
 
 #elif TEST_STD_VER > 20
 
 # ifndef __cpp_lib_memory_resource
 #   error "__cpp_lib_memory_resource should be defined in c++2b"
 # endif
 # if __cpp_lib_memory_resource != 201603L
 #   error "__cpp_lib_memory_resource should have the value 201603L in c++2b"
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_polymorphic_allocator
-#     error "__cpp_lib_polymorphic_allocator should be defined in c++2b"
-#   endif
-#   if __cpp_lib_polymorphic_allocator != 201902L
-#     error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_polymorphic_allocator
-#     error "__cpp_lib_polymorphic_allocator should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_polymorphic_allocator
+#   error "__cpp_lib_polymorphic_allocator should be defined in c++2b"
+# endif
+# if __cpp_lib_polymorphic_allocator != 201902L
+#   error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++2b"
+# endif
 
 #endif // TEST_STD_VER > 20
 

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

 #     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++20"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_polymorphic_allocator
-#     error "__cpp_lib_polymorphic_allocator should be defined in c++20"
-#   endif
-#   if __cpp_lib_polymorphic_allocator != 201902L
-#     error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++20"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_polymorphic_allocator
-#     error "__cpp_lib_polymorphic_allocator should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_polymorphic_allocator
+#   error "__cpp_lib_polymorphic_allocator should be defined in c++20"
+# endif
+# if __cpp_lib_polymorphic_allocator != 201902L
+#   error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++20"
+# endif
 
 # ifndef __cpp_lib_quoted_string_io
 #   error "__cpp_lib_quoted_string_io should be defined in c++20"
 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++20"
 # endif
 

 #     error "__cpp_lib_parallel_algorithm should have the value 201603L in c++2b"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
-# if !defined(_LIBCPP_VERSION)
-#   ifndef __cpp_lib_polymorphic_allocator
-#     error "__cpp_lib_polymorphic_allocator should be defined in c++2b"
-#   endif
-#   if __cpp_lib_polymorphic_allocator != 201902L
-#     error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++2b"
-#   endif
-# else // _LIBCPP_VERSION
-#   ifdef __cpp_lib_polymorphic_allocator
-#     error "__cpp_lib_polymorphic_allocator should not be defined because it is unimplemented in libc++!"
-#   endif
-# endif
+# ifndef __cpp_lib_polymorphic_allocator
+#   error "__cpp_lib_polymorphic_allocator should be defined in c++2b"
+# endif
+# if __cpp_lib_polymorphic_allocator != 201902L
+#   error "__cpp_lib_polymorphic_allocator should have the value 201902L in c++2b"
+# endif
 
 # ifndef __cpp_lib_quoted_string_io
 #   error "__cpp_lib_quoted_string_io should be defined in c++2b"
 # endif
 # if __cpp_lib_quoted_string_io != 201304L
 #   error "__cpp_lib_quoted_string_io should have the value 201304L in c++2b"
 # endif
 

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/allocate_deallocate_bytes.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{11.0|12.0}}
+
+// test_memory_resource requires RTTI for dynamic_cast
+// UNSUPPORTED: no-rtti
+
+// <memory_resource>
+
+// polymorphic_allocator::allocate_bytes()
+// polymorphic_allocator::deallocate_bytes()
+
+#include <algorithm>
+#include <cassert>
+#include <concepts>
+#include <memory_resource>
+
+#include "tracking_mem_res.h"
+
+template <class T>
+void test() {
+  size_t last_size      = 0;
+  size_t last_alignment = 0;
+  TrackingMemRes resource(&last_size, &last_alignment);
+
+  std::pmr::polymorphic_allocator<T> allocator(&resource);
+
+  {
+    std::same_as<void*> decltype(auto) allocation = allocator.allocate_bytes(13);
+    auto ptr                                      = static_cast<char*>(allocation);
+    std::fill(ptr, ptr + 13, '0');
+    assert(last_size == 13);
+    assert(last_alignment == alignof(max_align_t));
+    allocator.deallocate_bytes(allocation, 13);
+    assert(last_size == 13);
+    assert(last_alignment == alignof(max_align_t));
+  }
+  {
+    void* allocation = allocator.allocate_bytes(13, 64);
+    auto ptr         = static_cast<char*>(allocation);
+    std::fill(ptr, ptr + 13, '0');
+    assert(last_size == 13);
+    assert(last_alignment == 64);
+    allocator.deallocate_bytes(allocation, 13, 64);
+    assert(last_size == 13);
+    assert(last_alignment == 64);
+  }
+}
+
+struct S {};
+
+int main(int, char**) {
+  test<std::byte>();
+  test<S>();
+
+  return 0;
+}

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/allocate_deallocate_object.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{11.0|12.0}}
+
+// test_memory_resource requires RTTI for dynamic_cast
+// UNSUPPORTED: no-rtti
+
+// <memory_resource>
+
+// polymorphic_allocator::allocate_object()
+// polymorphic_allocator::deallocate_object()
+
+#include <algorithm>
+#include <cassert>
+#include <concepts>
+#include <memory_resource>
+
+#include "tracking_mem_res.h"
+
+template <class T>
+void test() {
+  size_t last_size      = 0;
+  size_t last_alignment = 0;
+  TrackingMemRes resource(&last_size, &last_alignment);
+
+  std::pmr::polymorphic_allocator<T> allocator(&resource);
+
+  {
+    std::same_as<int*> decltype(auto) allocation = allocator.template allocate_object<int>();
+    std::fill(allocation, allocation + 1, 3);
+    assert(last_size == sizeof(int));
+    assert(last_alignment == alignof(int));
+    allocator.deallocate_object(allocation);
+    assert(last_size == sizeof(int));
+    assert(last_alignment == alignof(int));
+  }
+  {
+    int* allocation = allocator.template allocate_object<int>(3);
+    std::fill(allocation, allocation + 3, 3);
+    assert(last_size == sizeof(int) * 3);
+    assert(last_alignment == alignof(int));
+    allocator.deallocate_object(allocation, 3);
+    assert(last_size == sizeof(int) * 3);
+    assert(last_alignment == alignof(int));
+  }
+}
+
+struct S {};
+
+int main(int, char**) {
+  test<std::byte>();
+  test<S>();
+
+  return 0;
+}

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/allocate_deallocate_vocabulary.nodiscard.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
+//
+//===----------------------------------------------------------------------===//
+
+// check that functions are marked [[nodiscard]]
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+
+// test_memory_resource requires RTTI for dynamic_cast
+// UNSUPPORTED: no-rtti
+
+// <memory_resource>
+
+// polymorphic_allocator::allocate_bytes()
+// polymorphic_allocator::allocate_object()
+// polymorphic_allocator::new_object()
+
+#include <memory_resource>
+
+void func() {
+  std::pmr::polymorphic_allocator<> allocator;
+  allocator.allocate_bytes(1); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  allocator.allocate_object<int>(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+  allocator.new_object<int>(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}}
+}

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/default_type.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{11.0|12.0}}
+
+// test_memory_resource requires RTTI for dynamic_cast
+// UNSUPPORTED: no-rtti
+
+#include <memory_resource>
+#include <type_traits>
+
+static_assert(std::is_same_v<std::pmr::polymorphic_allocator<>, std::pmr::polymorphic_allocator<std::byte>>);

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/new_delete_object.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13|14|15}}
+// XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx{{11.0|12.0}}
+
+// test_memory_resource requires RTTI for dynamic_cast
+// UNSUPPORTED: no-rtti
+
+// <memory_resource>
+
+// polymorphic_allocator::new_object()
+// polymorphic_allocator::delete_object()
+
+#include <algorithm>
+#include <cassert>
+#include <concepts>
+#include <memory_resource>
+
+#include "tracking_mem_res.h"
+
+template <class T>
+void test() {
+  size_t last_size      = 0;
+  size_t last_alignment = 0;
+  TrackingMemRes resource(&last_size, &last_alignment);
+
+  std::pmr::polymorphic_allocator<T> allocator(&resource);
+
+  {
+    std::same_as<int*> decltype(auto) allocation = allocator.template new_object<int>();
+    std::fill(allocation, allocation + 1, 4);
+    assert(last_size == sizeof(int));
+    assert(last_alignment == alignof(int));
+    allocator.delete_object(allocation);
+  }
+  {
+    std::same_as<int*> decltype(auto) allocation = allocator.template new_object<int>(3);
+    assert(*allocation == 3);
+    std::fill(allocation, allocation + 1, 4);
+    assert(last_size == sizeof(int));
+    assert(last_alignment == alignof(int));
+    allocator.delete_object(allocation);
+  }
+  {
+    struct TrackConstruction {
+      bool* is_constructed_;
+      TrackConstruction(bool* is_constructed) : is_constructed_(is_constructed) { *is_constructed = true; }
+      ~TrackConstruction() { *is_constructed_ = false; }
+    };
+
+    bool is_constructed = false;
+
+    std::same_as<TrackConstruction*> decltype(auto) allocation =
+        allocator.template new_object<TrackConstruction>(&is_constructed);
+    assert(is_constructed);
+    assert(last_size == sizeof(TrackConstruction));
+    assert(last_alignment == alignof(TrackConstruction));
+    allocator.delete_object(allocation);
+    assert(!is_constructed);
+  }
+}
+
+struct S {};
+
+int main(int, char**) {
+  test<std::byte>();
+  test<S>();
+
+  return 0;
+}

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/tracking_mem_res.h

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef TRACKING_MEM_RES_H
+#define TRACKING_MEM_RES_H
+
+#include <memory_resource>
+
+class TrackingMemRes : public std::pmr::memory_resource {
+public:
+  TrackingMemRes(size_t* last_size, size_t* last_alginment) : last_size_(last_size), last_alginment_(last_alginment) {}
+
+private:
+  size_t* last_size_;
+  size_t* last_alginment_;
+  void* do_allocate(size_t size, size_t alignment) override {
+    *last_size_      = size;
+    *last_alginment_ = alignment;
+
+    return std::pmr::new_delete_resource()->allocate(size, alignment);
+  }
+
+  void do_deallocate(void* ptr, size_t size, size_t alignment) override {
+    *last_size_      = size;
+    *last_alginment_ = alignment;
+    std::pmr::new_delete_resource()->deallocate(ptr, size, alignment);
+  }
+
+  bool do_is_equal(const memory_resource& ptr) const noexcept override { return &ptr == this; }
+};
+
+#endif // TRACKING_MEM_RES_H

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = [ add_version_header(x) for x in [
     "name": "__cpp_lib_parallel_algorithm",
     "values": { "c++17": 201603 },
     "headers": ["algorithm", "numeric"],
     "unimplemented": True,
   }, {
     "name": "__cpp_lib_polymorphic_allocator",
     "values": { "c++20": 201902 },
     "headers": ["memory_resource"],
-    "unimplemented": True,
   }, {
     "name": "__cpp_lib_quoted_string_io",
     "values": { "c++14": 201304 },
     "headers": ["iomanip"],
   }, {
     "name": "__cpp_lib_ranges",
     "values": { "c++20": 201811 },
     "headers": ["algorithm", "functional", "iterator", "memory", "ranges"],