[libc++][P0784] Marked allocator_traits constexpr.

[ldionne]

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp

58

This works, but I would be happier if we instead passed the address of an object, and checked that the right address had been passed in A<T>::deallocate. WDYT?

[mpark]

Updated the synopsis of tests.

[mpark]

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.pass.cpp

58

Updated to pass an object in instead.

[mpark]

• Rebased.
• Fixed tests
• Addressed @ldionne's comment about passing objects.

[mpark]

Rebased.

[ldionne]

libcxx/test/support/test_macros.h

147

Is that an artifact of rebases? It looks like it's handled above.

[ldionne]

This is superseded by D68364. Thanks a lot for your work on this @mpark, I based my patch on top of yours. I tried taking all the comments from this review and incorporating them into D68364.

libcxx/include/memory

#ifndef _LIBCPP_CXX03_LANG
     template <class _Tp> using rebind_traits = allocator_traits<rebind_alloc<_Tp> >;
 #else  // _LIBCPP_CXX03_LANG
     template <class _Tp> struct rebind_alloc
         {typedef typename __allocator_traits_rebind<allocator_type, _Tp>::type other;};
     template <class _Tp> struct rebind_traits
         {typedef allocator_traits<typename rebind_alloc<_Tp>::other> other;};
 #endif  // _LIBCPP_CXX03_LANG
 
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static pointer allocate(allocator_type& __a, size_type __n)
         {return __a.allocate(__n);}
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static pointer allocate(allocator_type& __a, size_type __n, const_void_pointer __hint)
         {return __allocate(__a, __n, __hint,
             __has_allocate_hint<allocator_type, size_type, const_void_pointer>());}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static void deallocate(allocator_type& __a, pointer __p, size_type __n) _NOEXCEPT
         {__a.deallocate(__p, __n);}
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class _Tp, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args)
             {__construct(__has_construct<allocator_type, _Tp*, _Args...>(),
                          __a, __p, _VSTD::forward<_Args>(__args)...);}
 #else  // _LIBCPP_HAS_NO_VARIADICS
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         static void construct(allocator_type&, _Tp* __p)
             {
template <class _Tp, class _A0, class _A1, class _A2>
         static void construct(allocator_type&, _Tp* __p, const _A0& __a0,
                               const _A1& __a1, const _A2& __a2)
             {
                 ::new ((void*)__p) _Tp(__a0, __a1, __a2);
             }
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
     template <class _Tp>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         static void destroy(allocator_type& __a, _Tp* __p)
             {__destroy(__has_destroy<allocator_type, _Tp*>(), __a, __p);}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static size_type max_size(const allocator_type& __a) _NOEXCEPT
         {return __max_size(__has_max_size<const allocator_type>(), __a);}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static allocator_type
         select_on_container_copy_construction(const allocator_type& __a)
             {return __select_on_container_copy_construction(
                 __has_select_on_container_copy_construction<const allocator_type>(),
                 __a);}
 
     template <class _Ptr>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         static
         void
         __construct_forward_with_exception_guarantees(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __begin2)
         {
             static_assert(__is_cpp17_move_insertable<allocator_type>::value,
               "The specified type does not meet the requirements of Cpp17MoveInsertible");
             for (; __begin1 != __end1; ++__begin1, (void) ++__begin2)
               construct(__a, _VSTD::__to_raw_pointer(__begin2),
 #ifdef _LIBCPP_NO_EXCEPTIONS
                         _VSTD::move(*__begin1)
 #else
                         _VSTD::move_if_noexcept(*__begin1)
 #endif
                         );
         }
 
     template <class _Tp>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         static
         typename enable_if
         <
             (__is_default_allocator<allocator_type>::value
                 || !__has_construct<allocator_type, _Tp*, _Tp>::value) &&
              is_trivially_move_constructible<_Tp>::value,
             void
         >::type
         __construct_forward_with_exception_guarantees(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __begin2)
         {
             ptrdiff_t _Np = __end1 - __begin1;
             if (_Np > 0)
             {
                 _VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Tp));
                 __begin2 += _Np;
             }
         }
 
     template <class _Iter, class _Ptr>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         static
         void
         __construct_range_forward(allocator_type& __a, _Iter __begin1, _Iter __end1, _Ptr& __begin2)
         {
             for (; __begin1 != __end1; ++__begin1, (void) ++__begin2)
                 construct(__a, _VSTD::__to_raw_pointer(__begin2), *__begin1);
         }
 
     template <class _SourceTp, class _DestTp,
               class _RawSourceTp = typename remove_const<_SourceTp>::type,
               class _RawDestTp = typename remove_const<_DestTp>::type>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         static
         typename enable_if
         <
             is_trivially_move_constructible<_DestTp>::value &&
             is_same<_RawSourceTp, _RawDestTp>::value &&
             (__is_default_allocator<allocator_type>::value ||
              !__has_construct<allocator_type, _DestTp*, _SourceTp&>::value),
             void
         >::type
         __construct_range_forward(allocator_type&, _SourceTp* __begin1, _SourceTp* __end1, _DestTp*& __begin2)
         {
             ptrdiff_t _Np = __end1 - __begin1;
             if (_Np > 0)
             {
                 _VSTD::memcpy(const_cast<_RawDestTp*>(__begin2), __begin1, _Np * sizeof(_DestTp));
                 __begin2 += _Np;
             }
         }
 
     template <class _Ptr>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         static
         void
         __construct_backward_with_exception_guarantees(allocator_type& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2)
         {
             static_assert(__is_cpp17_move_insertable<allocator_type>::value,
               "The specified type does not meet the requirements of Cpp17MoveInsertable");
             while (__end1 != __begin1)
             {
               construct(__a, _VSTD::__to_raw_pointer(__end2 - 1),
 #ifdef _LIBCPP_NO_EXCEPTIONS
                         _VSTD::move(*--__end1)
 #else
                         _VSTD::move_if_noexcept(*--__end1)
 #endif
                         );
               --__end2;
             }
         }
 
     template <class _Tp>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         static
         typename enable_if
         <
             (__is_default_allocator<allocator_type>::value
                 || !__has_construct<allocator_type, _Tp*, _Tp>::value) &&
              is_trivially_move_constructible<_Tp>::value,
             void
         >::type
         __construct_backward_with_exception_guarantees(allocator_type&, _Tp* __begin1, _Tp* __end1, _Tp*& __end2)
         {
             ptrdiff_t _Np = __end1 - __begin1;
             __end2 -= _Np;
             if (_Np > 0)
                 _VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp));
         }
 
 private:
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static pointer __allocate(allocator_type& __a, size_type __n,
         const_void_pointer __hint, true_type)
         _LIBCPP_SUPPRESS_DEPRECATED_PUSH
         {return __a.allocate(__n, __hint);}
         _LIBCPP_SUPPRESS_DEPRECATED_POP
-    _LIBCPP_INLINE_VISIBILITY
+
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static pointer __allocate(allocator_type& __a, size_type __n,
         const_void_pointer, false_type)
         {return __a.allocate(__n);}
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class _Tp, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args)
             _LIBCPP_SUPPRESS_DEPRECATED_PUSH
             {__a.construct(__p, _VSTD::forward<_Args>(__args)...);}
             _LIBCPP_SUPPRESS_DEPRECATED_POP
 
     template <class _Tp, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args)
             {
                 ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
             }
 #else  // _LIBCPP_HAS_NO_VARIADICS
     template <class _Tp, class _A0>
         _LIBCPP_INLINE_VISIBILITY
         static void __construct(true_type, allocator_type& __a, _Tp* __p,
                                 const _A0& __a0)
             {__a.construct(__p, __a0);}
     template <class _Tp, class _A0>
         _LIBCPP_INLINE_VISIBILITY
         static void __construct(false_type, allocator_type&, _Tp* __p,
                                 const _A0& __a0)
             {
                 ::new ((void*)__p) _Tp(__a0);
             }
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
     template <class _Tp>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         static void __destroy(true_type, allocator_type& __a, _Tp* __p)
             _LIBCPP_SUPPRESS_DEPRECATED_PUSH
             {__a.destroy(__p);}
             _LIBCPP_SUPPRESS_DEPRECATED_POP
     template <class _Tp>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
         static void __destroy(false_type, allocator_type&, _Tp* __p)
             {
                 __p->~_Tp();
             }
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static size_type __max_size(true_type, const allocator_type& __a) _NOEXCEPT
             _LIBCPP_SUPPRESS_DEPRECATED_PUSH
             {return __a.max_size();}
             _LIBCPP_SUPPRESS_DEPRECATED_POP
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static size_type __max_size(false_type, const allocator_type&) _NOEXCEPT
             {return numeric_limits<size_type>::max() / sizeof(value_type);}
 
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static allocator_type
         __select_on_container_copy_construction(true_type, const allocator_type& __a)
             {return __a.select_on_container_copy_construction();}
-    _LIBCPP_INLINE_VISIBILITY
+    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     static allocator_type
         __select_on_container_copy_construction(false_type, const allocator_type& __a)
             {return __a;}
 };
 
 template <class _Traits, class _Tp>
 struct __rebind_alloc_helper
 {
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
     const_pointer address(const_reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
 #endif
 
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_CONSTEXPR_DYNAMIC_ALLOC
     _Tp* allocate(size_t __n)
         {
-        // TODO(mpark): Replace with `allocator_traits<allocator>::max_size(*this)`.
-        if (__n > (size_t(~0) / sizeof(_Tp)))
+        if (__n > allocator_traits<allocator>::max_size(*this))
             __throw_length_error("allocator<T>::allocate(size_t n)"
                                  " 'n' exceeds maximum supported size");
         return static_cast<_Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
         }
 
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17
     _Tp* allocate(size_t __n, const void*) { return allocate(__n); }
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
     const_pointer address(const_reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
 #endif
 
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
     _LIBCPP_CONSTEXPR_AFTER_CXX17_WITH_CONSTEXPR_DYNAMIC_ALLOC
     const _Tp* allocate(size_t __n)
     {
-        // TODO(mpark): Replace with `allocator_traits<allocator>::max_size(*this)`.
-        if (__n > (size_t(~0) / sizeof(_Tp)))
+        if (__n > allocator_traits<allocator>::max_size(*this))
             __throw_length_error("allocator<const T>::allocate(size_t n)"
                                  " 'n' exceeds maximum supported size");
         return static_cast<const _Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
     }
 
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
     _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17
     const _Tp* allocate(size_t __n, const void*) { return allocate(__n); }

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/allocate.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class Alloc>
 // struct allocator_traits
 // {
-//     static pointer allocate(allocator_type& a, size_type n);
+//     static constexpr pointer allocate(allocator_type& a, size_type n);
 //     ...
 // };
 
 #include <memory>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 #include "incomplete_type_helper.h"
 
 template <class T>
 struct A
 {
     typedef T value_type;
 
-    value_type* allocate(std::size_t n)
+    TEST_CONSTEXPR_CXX20 A() {}
+
+    TEST_CONSTEXPR_CXX20 value_type* allocate(std::size_t n)
     {
         assert(n == 10);
-        return reinterpret_cast<value_type*>(static_cast<std::uintptr_t>(0xDEADBEEF));
+        return &storage;
     }
+
+    value_type storage;
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool
+test()
 {
   {
     A<int> a;
-    assert(std::allocator_traits<A<int> >::allocate(a, 10) == reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
+    assert(std::allocator_traits<A<int> >::allocate(a, 10) == &a.storage);
   }
   {
     typedef IncompleteHolder* VT;
     typedef A<VT> Alloc;
     Alloc a;
-    assert(std::allocator_traits<Alloc >::allocate(a, 10) == reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
-  }
+    assert(std::allocator_traits<Alloc >::allocate(a, 10) == &a.storage);
+  }
+
+  return true;
 
+int main(int, char**)
+{
+  test();
+
+#if TEST_STD_VER > 17
+  static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/construct.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class Alloc>
 // struct allocator_traits
 // {
 //     template <class Ptr, class... Args>
-//         static void construct(allocator_type& a, Ptr p, Args&&... args);
+//         static constexpr void construct(allocator_type& a, Ptr p, Args&&... args);
 //     ...
 // };
 
 #include <memory>
 #include <new>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "incomplete_type_helper.h"
 
 template <class T>
 struct A
 {
     typedef T value_type;
 
 };
 
-int b_construct = 0;
-
 template <class T>
 struct B
 {
     typedef T value_type;
 
+    TEST_CONSTEXPR_CXX20 B(int& count) : count(count) {}
+
 #if TEST_STD_VER >= 11
     template <class U, class ...Args>
-    void construct(U* p, Args&& ...args)
+    TEST_CONSTEXPR_DYNAMIC_ALLOC void construct(U* p, Args&& ...args)
     {
-        ++b_construct;
+        ++count;
+#if TEST_STD_VER > 17
+        std::construct_at(p, std::forward<Args>(args)...);
+#else
         ::new ((void*)p) U(std::forward<Args>(args)...);
+#endif
     }
 #endif
+
+    int& count;
 };
 
 struct A0
 {
-    static int count;
-    A0() {++count;}
+    TEST_CONSTEXPR_CXX20 A0(int* count) {++*count;}
 };
 
-int A0::count = 0;
-
 struct A1
 {
-    static int count;
-    A1(char c)
+    TEST_CONSTEXPR_CXX20 A1(int* count, char c)
     {
         assert(c == 'c');
-        ++count;
+        ++*count;
     }
 };
 
-int A1::count = 0;
-
 struct A2
 {
-    static int count;
-    A2(char c, int i)
+    TEST_CONSTEXPR_CXX20 A2(int* count, char c, int i)
     {
         assert(c == 'd');
         assert(i == 5);
-        ++count;
+        ++*count;
     }
 };
 
-int A2::count = 0;
-
-int main(int, char**)
+TEST_CONSTEXPR_DYNAMIC_ALLOC bool
+test()
 {
     {
-        A0::count = 0;
-        A<int> a;
-        std::aligned_storage<sizeof(A0)>::type a0;
-        assert(A0::count == 0);
-        std::allocator_traits<A<int> >::construct(a, (A0*)&a0);
-        assert(A0::count == 1);
-    }
-    {
-        A1::count = 0;
-        A<int> a;
-        std::aligned_storage<sizeof(A1)>::type a1;
-        assert(A1::count == 0);
-        std::allocator_traits<A<int> >::construct(a, (A1*)&a1, 'c');
-        assert(A1::count == 1);
-    }
-    {
-        A2::count = 0;
-        A<int> a;
-        std::aligned_storage<sizeof(A2)>::type a2;
-        assert(A2::count == 0);
-        std::allocator_traits<A<int> >::construct(a, (A2*)&a2, 'd', 5);
-        assert(A2::count == 1);
+        int A0_count = 0;
+        A<A0> a;
+        std::allocator<A0> alloc;
+        A0* a0 = alloc.allocate(1);
+        assert(A0_count == 0);
+        std::allocator_traits<A<A0> >::construct(a, a0, &A0_count);
+        assert(A0_count == 1);
+        alloc.deallocate(a0, 1);
+    }
+    {
+        int A1_count = 0;
+        A<A1> a;
+        std::allocator<A1> alloc;
+        A1* a1 = alloc.allocate(1);
+        assert(A1_count == 0);
+        std::allocator_traits<A<A1> >::construct(a, a1, &A1_count, 'c');
+        assert(A1_count == 1);
+        alloc.deallocate(a1, 1);
+    }
+    {
+        int A2_count = 0;
+        A<A2> a;
+        std::allocator<A2> alloc;
+        A2* a2 = alloc.allocate(1);
+        assert(A2_count == 0);
+        std::allocator_traits<A<A2> >::construct(a, a2, &A2_count, 'd', 5);
+        assert(A2_count == 1);
+        alloc.deallocate(a2, 1);
     }
     {
       typedef IncompleteHolder* VT;
       typedef A<VT> Alloc;
       Alloc a;
-      std::aligned_storage<sizeof(VT)>::type store;
-      std::allocator_traits<Alloc>::construct(a, (VT*)&store, nullptr);
+      std::allocator<VT> alloc;
+      VT* vt = alloc.allocate(1);
+      std::allocator_traits<Alloc>::construct(a, vt, nullptr);
+      alloc.deallocate(vt, 1);
     }
+
 #if TEST_STD_VER >= 11
     {
-        A0::count = 0;
-        b_construct = 0;
-        B<int> b;
-        std::aligned_storage<sizeof(A0)>::type a0;
-        assert(A0::count == 0);
+        int A0_count = 0;
+        int b_construct = 0;
+        B<A0> b(b_construct);
+        std::allocator<A0> alloc;
+        A0* a0 = alloc.allocate(1);
+        assert(A0_count == 0);
         assert(b_construct == 0);
-        std::allocator_traits<B<int> >::construct(b, (A0*)&a0);
-        assert(A0::count == 1);
+        std::allocator_traits<B<A0> >::construct(b, a0, &A0_count);
+        assert(A0_count == 1);
         assert(b_construct == 1);
+        alloc.deallocate(a0, 1);
     }
     {
-        A1::count = 0;
-        b_construct = 0;
-        B<int> b;
-        std::aligned_storage<sizeof(A1)>::type a1;
-        assert(A1::count == 0);
+        int A1_count = 0;
+        int b_construct = 0;
+        B<A1> b(b_construct);
+        std::allocator<A1> alloc;
+        A1* a1 = alloc.allocate(1);
+        assert(A1_count == 0);
         assert(b_construct == 0);
-        std::allocator_traits<B<int> >::construct(b, (A1*)&a1, 'c');
-        assert(A1::count == 1);
+        std::allocator_traits<B<A1> >::construct(b, a1, &A1_count, 'c');
+        assert(A1_count == 1);
         assert(b_construct == 1);
+        alloc.deallocate(a1, 1);
     }
     {
-        A2::count = 0;
-        b_construct = 0;
-        B<int> b;
-        std::aligned_storage<sizeof(A2)>::type a2;
-        assert(A2::count == 0);
+        int A2_count = 0;
+        int b_construct = 0;
+        B<A2> b(b_construct);
+        std::allocator<A2> alloc;
+        A2* a2 = alloc.allocate(1);
+        assert(A2_count == 0);
         assert(b_construct == 0);
-        std::allocator_traits<B<int> >::construct(b, (A2*)&a2, 'd', 5);
-        assert(A2::count == 1);
+        std::allocator_traits<B<A2> >::construct(b, a2, &A2_count, 'd', 5);
+        assert(A2_count == 1);
         assert(b_construct == 1);
+        alloc.deallocate(a2, 1);
     }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+    test();
+
+#if TEST_STD_VER > 17 && defined(__cpp_constexpr_dynamic_alloc)
+    static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/deallocate.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class Alloc>
 // struct allocator_traits
 // {
-//     static void deallocate(allocator_type& a, pointer p, size_type n);
+//     static constexpr void deallocate(allocator_type& a, pointer p, size_type n);
 //     ...
 // };
 
 #include <memory>
 #include <cstdint>
 #include <cassert>
 
 #include "test_macros.h"
 #include "incomplete_type_helper.h"
 
-int called = 0;
-
 template <class T>
 struct A
 {
     typedef T value_type;
 
-    void deallocate(value_type* p, std::size_t n)
+    TEST_CONSTEXPR_CXX20 A(int& called) : called(called) {}
+
+    TEST_CONSTEXPR_CXX20 void deallocate(value_type* p, std::size_t n)
     {
-        assert(p == reinterpret_cast<value_type*>(static_cast<std::uintptr_t>(0xDEADBEEF)));
+        assert(p == &storage);
         assert(n == 10);
         ++called;
     }
+
+    int& called;
+
+    value_type storage;
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool
+test()
 {
   {
-    A<int> a;
-    std::allocator_traits<A<int> >::deallocate(a, reinterpret_cast<int*>(static_cast<std::uintptr_t>(0xDEADBEEF)), 10);
+    int called = 0;
+    A<int> a(called);
+    std::allocator_traits<A<int> >::deallocate(a, &a.storage, 10);
     assert(called == 1);
   }
-  called = 0;
   {
+    int called = 0;
     typedef IncompleteHolder* VT;
     typedef A<VT> Alloc;
-    Alloc a;
-    std::allocator_traits<Alloc >::deallocate(a, reinterpret_cast<VT*>(static_cast<std::uintptr_t>(0xDEADBEEF)), 10);
+    Alloc a(called);
+    std::allocator_traits<Alloc >::deallocate(a, &a.storage, 10);
     assert(called == 1);
   }
 
+  return true;
+}
+
+int main(int, char**)
+{
+    test();
+
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/max_size.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class Alloc>
 // struct allocator_traits
 // {
-//     static size_type max_size(const allocator_type& a) noexcept;
+//     static constexpr size_type max_size(const allocator_type& a) noexcept;
 //     ...
 // };
 
 #include <limits>
 #include <memory>
 #include <new>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "incomplete_type_helper.h"
 
 template <class T>
 struct A
 {
     typedef T value_type;
 
 };
 
 template <class T>
 struct B
 {
     typedef T value_type;
 
-    size_t max_size() const
+    TEST_CONSTEXPR_CXX20 size_t max_size() const
     {
         return 100;
     }
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool
+test()
 {
     {
         B<int> b;
         assert(std::allocator_traits<B<int> >::max_size(b) == 100);
     }
     {
         const B<int> b = {};
         assert(std::allocator_traits<B<int> >::max_size(b) == 100);
#if TEST_STD_VER >= 11
                std::numeric_limits<std::size_t>::max() / sizeof(int));
     }
     {
         std::allocator<int> a;
         static_assert(noexcept(std::allocator_traits<std::allocator<int>>::max_size(a)) == true, "");
     }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+    test();
+
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/std/utilities/memory/allocator.traits/allocator.traits.members/select_on_container_copy_construction.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
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // template <class Alloc>
 // struct allocator_traits
 // {
-//     static allocator_type
+//     static constexpr allocator_type
 //         select_on_container_copy_construction(const allocator_type& a);
 //     ...
 // };
 
 #include <memory>
 #include <new>
 #include <type_traits>
 #include <cassert>
 
 #include "test_macros.h"
 #include "incomplete_type_helper.h"
 
 template <class T>
 struct A
 {
     typedef T value_type;
     int id;
-    explicit A(int i = 0) : id(i) {}
+    TEST_CONSTEXPR_CXX20 explicit A(int i = 0) : id(i) {}
 
 };
 
 template <class T>
 struct B
 {
     typedef T value_type;
 
     int id;
-    explicit B(int i = 0) : id(i) {}
+    TEST_CONSTEXPR_CXX20 explicit B(int i = 0) : id(i) {}
 
-    B select_on_container_copy_construction() const
+    TEST_CONSTEXPR_CXX20 B select_on_container_copy_construction() const
     {
         return B(100);
     }
 };
 
-int main(int, char**)
+TEST_CONSTEXPR_CXX20 bool
+test()
 {
     {
         A<int> a;
         assert(std::allocator_traits<A<int> >::select_on_container_copy_construction(a).id == 0);
     }
     {
         const A<int> a(0);
         assert(std::allocator_traits<A<int> >::select_on_container_copy_construction(a).id == 0);
#if TEST_STD_VER >= 11
         assert(std::allocator_traits<B<int> >::select_on_container_copy_construction(b).id == 100);
     }
     {
         const B<int> b(0);
         assert(std::allocator_traits<B<int> >::select_on_container_copy_construction(b).id == 100);
     }
 #endif
 
+  return true;
+}
+
+int main(int, char**)
+{
+    test();
+
+#if TEST_STD_VER > 17
+    static_assert(test());
+#endif
+
   return 0;
 }

libcxx/test/support/test_macros.h

 #if defined(TEST_COMPILER_CLANG)
 # define TEST_ALIGNOF(...) _Alignof(__VA_ARGS__)
 #else
 # define TEST_ALIGNOF(...) __alignof(__VA_ARGS__)
 #endif
 #define TEST_ALIGNAS(...) __attribute__((__aligned__(__VA_ARGS__)))
 #define TEST_CONSTEXPR
 #define TEST_CONSTEXPR_CXX14
+#define TEST_CONSTEXPR_DYNAMIC_ALLOC
 #define TEST_CONSTEXPR_CXX20
 #define TEST_NOEXCEPT throw()
 #define TEST_NOEXCEPT_FALSE
 #define TEST_NOEXCEPT_COND(...)
 #define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
 #endif
 
 // Sniff out to see if the underlying C library has C11 features