Implement uses-allocator (P0591R4)

[ldionne]

Summary

Add uses_allocator_construction_args overloads, make_obj_using_allocator and uninitialized_construct_using_allocator.

[zoecarver]

The paper also requests the deletion of several construct methods. I did not add this to the patch because it broke a lot of tests (and other things). I thought it would be worth asking if we should keep them for compatibility reasons.

[zoecarver]

Check off in status

[zoecarver]

Fix trailing white space.

[zoecarver]

• Completely re-write this patch.
• Add tests
• Fix tuple issues

[zoecarver]

Because of the length of the name uses_allocator_construction_args, some of the styles are... different. Feel free to suggest changes.

include/memory

5710

Spacing

include/tuple

1377 ↗

(On Diff #197159)

I can submit a separate patch for this.

test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp

10

Add synopsis comment

[zoecarver]

• Finishes implementing the paper (remove scoped_allocator::construct)
• Updates and adds tests

I think P0475R1 can also be marked complete because the code it refers to has been removed.

[zoecarver]

• finally finish implementing the paper
• remove construct methods from polymorphic_allocator

[zoecarver]

include/experimental/memory_resource

203

Please note: this is not tested (and probably needs further changes). Because of 41760 (which I am starting to think is my fault and not an actual bug), I was unable to run many of the polymorphic_allocator tests and therefore could not ensure that this was correctly implemented.

include/tuple

1377 ↗

(On Diff #197159)

Given that a fix for this goes against the standard, I am not sure what to do here. First, I am going to look into this more and make sure it is necessary.

As a note, the change here is not my suggested fix. Please see D61293 for that.

[• Quuxplusone]

include/memory

5751

What is -> auto doing here and on line 5755?

5798

So if I pass in a pair<string, int> or pair<string&&, int>, you'll move out of p.first, but if I pass in pair<string&, int>, you'll make a copy of p.first, is that right? I guess that seems reasonable, but it's a surprising/smelly use of std::forward IMVHO.

include/scoped_allocator

513

This function body is indented an extra level. Not your patch's fault, but I wonder if your patch should fix it.

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp

49

What's the rationale for all these test changes? I strongly suspect that they are a bad idea: if the original tests fail after your patch, I think there must be something wrong with your patch.

[zoecarver]

include/memory

5751

Will fix.

5798

You are right; I should probably use std::move here. For reference here is what the standard says.

include/scoped_allocator

513

Yep, good catch. I can fix that.

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp

49

These are all simply adding const or changing the reference type (I am not saying that necessarily makes them okay though). Because of how uses_allocator_construction_args is defined in the standard, make_tuple is passed an rvalue piecewise_construct (that is why the first part of this changed). I think the others are similar.

I will take a closer look at this and see which test is correct.

[• Quuxplusone]

include/memory

5798

Thanks for pointing to the relevant Standard wording! I was too lazy to go look for it myself. :) The wording uses std::move(pr).first, which is equivalent to std::forward<_T1>(pr.first) but doesn't set off my red-flag detectors — I would greatly prefer _VSTD::move(__p).first here.

(Notice that _VSTD::move(__p).first is different from _VSTD::move(__p.first) when __p is a pair of lvalue references. Which is good; it's what we want.)

[zoecarver]

• disable experimental tests
• update other tests

I removed the temporary "fix" I added to make_from_tuple because it was causing other failures and I wanted to discuss it before implementing something. The issue has to do with the move vs forward thread below. Using std::move(pair).first changes rvalues into lvalues and vice versa whereas forward consistently makes everything an rvalue (in the previous implementation, obviously not always). This clearly creates issues and is the reason that the tests are failing.

[zoecarver]

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

122

I really don't like disabling tests, but I think that these tests are incorrect (at least for c++20). Uses-allocator construction requires that types (or pair types) implement a uses-allocator typedef that is the same as the allocator they are being passed. This means that when these tests are passed the wrong allocator type, they choose the incorrect (well... actually it is correct) overload (the first one). If I am mistaken about this, let me know, and I will change the uses-allocator implementation.

[zoecarver]

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

122

I think 2975 might fix this actually.

[zoecarver]

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

122

This is an experimental library! The patch should not touch it.

[• Quuxplusone]

include/memory

5820

Nit: I believe this needs a _VSTD:: to prevent ADL in some complicated case involving std::pair<int, std::vector<Incomplete>*> that I don't 100% remember. (Something like it's going to try to look for friends of Incomplete because Incomplete is an associated entity of that pair type.) It would be interesting to write a unit test for this.
Rule of thumb, every function call needs a _VSTD:: to prevent ADL for _some_ reason or other. :)

[zoecarver]

As I have worked through fixing all the issues around this patch, I think I have come to the two root problems. First, using forward_as_tuple makes it so that the tuple cannot be copied (rightfully so) and are therefore useless in make_from_tuple. Here is an example. This should probably be fixed with an LWG issue (either to change what tuples can be copied or update make_from_tuple). Second, and more important, the expression forward_as_tuple(move(p).second) is unable to preserve rvalueness of a type. Here is an example. I think the paper either needs to be updated or an issue needs to be presented to fix this (I am happy to write that issue). What are your thoughts @mclow.lists, @EricWF, and @Quuxplusone?

[zoecarver]

include/memory

5798

I am not sure that is necessarily true. Sometimes one works, and the other doesn't. I think it should be pointed out that the author of the paper used forward in their implementation (probably for that reason).

[zoecarver]

include/memory

5820

Do you mean __uses_allocator_construction_args_impl or is_pair?

[mclow.lists]

Please make sure that you implement LWG 3185 as part of this patch

[zoecarver]

In D58879#1546317, @mclow.lists wrote:

Please make sure that you implement LWG 3185 as part of this patch

Will do. Thanks.

[MaskRay]

include/memory

5840

Should make_obj_using_allocator be qualified?
https://github.com/cplusplus/draft/issues/3111
https://github.com/gcc-mirror/gcc/commit/0c3543005cee13158806fe2909de9920522d2f9e

[ldionne]

[Github PR transition cleanup]

This was done in D131898.

include/experimental/memory_resource

public:
 
     _LIBCPP_INLINE_VISIBILITY
     void deallocate(_ValueType * __p, size_t __n) _NOEXCEPT {
         _LIBCPP_ASSERT(__n <= __max_size(),
                        "deallocate called for size which exceeds max_size()");
         __res_->deallocate(__p, __n * sizeof(_ValueType), _LIBCPP_ALIGNOF(_ValueType));
     }
 
+#if _LIBCPP_STD_VER > 17
+    template <class _Tp, class... _Args>
+    _LIBCPP_INLINE_VISIBILITY
+    void construct(_Tp* __p, _Args&&... __args)
+    {
+        uninitialized_construct_using_allocator(__p, *this,
+                                                _VSTD::forward<_Args>(__args)...);
+    }
+#else
     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)...
           );
     }
#else
 
     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)));
     }
+#endif // _LIBCPP_STD_VER > 17
 
     template <class _Tp>
     _LIBCPP_INLINE_VISIBILITY
     void destroy(_Tp * __p) _NOEXCEPT
         { __p->~_Tp(); }
 
     _LIBCPP_INLINE_VISIBILITY
     polymorphic_allocator

include/memory

template<class T>
     atomic_compare_exchange_weak_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
                                           shared_ptr<T> w, memory_order success,
                                           memory_order failure);
 template<class T>
     bool
     atomic_compare_exchange_strong_explicit(shared_ptr<T>* p, shared_ptr<T>* v,
                                             shared_ptr<T> w, memory_order success,
                                             memory_order failure);
+
+template <class T, class Alloc, class... Args>
+    auto uses_allocator_construction_args(const Alloc& alloc, Args&&... args);
+template <class T, class Alloc, class Tuple1, class Tuple2>
+    auto uses_allocator_construction_args(const Alloc& alloc, piecewise_construct_t, Tuple1&& x, Tuple2&& y);
+template <class T>
+    auto uses_allocator_construction_args(const Alloc& alloc);
+template <class T, class Alloc, class U, class V>
+    auto uses_allocator_construction_args(const Alloc& alloc, U&& u, V&& v);
+template <class T, class Alloc, class U, class V>
+    auto uses_allocator_construction_args(const Alloc& alloc, const pair<U,V>& pr);
+template <class T, class Alloc, class U, class V>
+    auto uses_allocator_construction_args(const Alloc& alloc, pair<U,V>&& pr);
+template <class T, class Alloc, class... Args>
+    T make_obj_using_allocator(const Alloc& alloc, Args&&... args);
+template <class T, class Alloc, class... Args>
+    T* uninitialized_construct_using_allocator(T* p, const Alloc& alloc, Args&&... args);
+
 // Hash support
 template <class T> struct hash;
 template <class T, class D> struct hash<unique_ptr<T, D> >;
 template <class T> struct hash<shared_ptr<T> >;
 
 template <class T, class Alloc>
   inline constexpr bool uses_allocator_v = uses_allocator<T, Alloc>::value;
 

 
 template<typename _Alloc>
 struct __is_allocator<_Alloc,
        typename __void_t<typename _Alloc::value_type>::type,
        typename __void_t<decltype(_VSTD::declval<_Alloc&>().allocate(size_t(0)))>::type
      >
    : true_type {};
 
+#if _LIBCPP_STD_VER > 17
+
+template <class _Tp> struct __is_pair : false_type { };
+
+template <class _T1, class _T2>
+struct __is_pair<pair<_T1, _T2>> : true_type { };
+
+template<class _Tp, class _Alloc>
+struct __pair_uses_allocator : _VSTD::uses_allocator<_Tp, _Alloc> {};
+
+template<class _T1, class _T2, class _Alloc>
+struct __pair_uses_allocator<_VSTD::pair<_T1, _T2>, _Alloc>
+    : _VSTD::integral_constant<bool,
+                               __pair_uses_allocator<_T1, _Alloc>::value ||
+                               __pair_uses_allocator<_T2, _Alloc>::value> {};
+
+template<class _Tp, class _Alloc, class... _Args>
+auto uses_allocator_construction_args(const _Alloc& __alloc, _Args&&... __args); // this needs to be forward declared for some __uses_allocator_construction_args_impl overloads
+
+template<class _Tp, class _Un1, class _Un2, class _Alloc, class... _Args>
+auto
+__uses_allocator_construction_args_impl(_Un1,        // is pair
+                                        false_type,  // uses allocator
+                                        _Un2,        // is constructible
+                                        const _Alloc&, _Args&&... __args)
+{
+    return _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)...);
+}
+
+template<class _Tp, class _Alloc, class... _Args>
+auto
+__uses_allocator_construction_args_impl(false_type, // is pair
+                                        true_type,  // uses allocator
+                                        true_type,  // is constructible
+                                        const _Alloc& __alloc, _Args&&... __args)
+{
+    return _VSTD::forward_as_tuple(allocator_arg, __alloc, _VSTD::forward<_Args>(__args)...);
+}
+
+template<class _Tp, class _Alloc, class... _Args>
+auto
+ __uses_allocator_construction_args_impl(false_type, // is pair
+                                         true_type,  // uses allocator
+                                         false_type, // is constructible
+                                         const _Alloc& __alloc, _Args&&... __args)
+{
+    return _VSTD::forward_as_tuple(_VSTD::forward<_Args>(__args)..., __alloc);
+}
+
+template<class _Tp, class _Alloc, class _T1, class _T2>
+auto
+__uses_allocator_construction_args_impl(true_type,  // is pair
+                                        true_type,  // uses allocator
+                                        false_type, // is constructible
+                                        const _Alloc& __alloc,
+                                        piecewise_construct_t,
+                                        _T1&& __a, _T2&& __b)
+{
+    using _First = typename _Tp::first_type;
+    using _Second = typename _Tp::second_type;
+
+    return _VSTD::make_tuple(_VSTD::piecewise_construct,
+                             _VSTD::apply([&__alloc](auto&&... __args_a) {
+                                return uses_allocator_construction_args<_First>(__alloc,
+                                                                                _VSTD::forward<decltype(__args_a)>(__args_a)...);
+                             }, _VSTD::forward<_T1>(__a)),
+                             _VSTD::apply([&__alloc](auto&&... __args_b) {
+                                return uses_allocator_construction_args<_Second>(__alloc,
+                                                                                 _VSTD::forward<decltype(__args_b)>(__args_b)...);
+                             }, _VSTD::forward<_T2>(__b)));
+}
+
+template<class _Tp, class _Alloc, class _Un>
+auto
+__uses_allocator_construction_args_impl(true_type,  // is pair
+                                        true_type,  // uses allocator
+                                        _Un,        // is constructible
+                                        const _Alloc& __alloc)
+{
+    return uses_allocator_construction_args<_Tp>(__alloc,
+                                                 piecewise_construct,
+                                                 _VSTD::tuple<>{},
+                                                 _VSTD::tuple<>{});
+}
+
+template<class _Tp, class _Alloc, class _T1, class _T2, class _Un>
+auto
+__uses_allocator_construction_args_impl(true_type,  // is pair
+                                        true_type,  // uses allocator
+                                        _Un,        // is constructible
+                                        const _Alloc& __alloc,
+                                        const _VSTD::pair<_T1, _T2>& __p)
+{
+    return uses_allocator_construction_args<_Tp>(__alloc,
+                                                 piecewise_construct,
+                                                 _VSTD::forward_as_tuple(__p.first),
+                                                 _VSTD::forward_as_tuple(__p.second));
+}
+
+template<class _Tp, class _Alloc, class _T1, class _T2, class _Un>
+auto
+__uses_allocator_construction_args_impl(true_type,  // is pair
+                                        true_type,  // uses allocator
+                                        _Un,        // is constructible
+                                        const _Alloc& __alloc,
+                                        _VSTD::pair<_T1, _T2>&& __p)
+{
+    return uses_allocator_construction_args<_Tp>(__alloc,
+                                                 piecewise_construct,
+                                                 _VSTD::forward_as_tuple(_VSTD::forward<_T1>(__p.first)),
+                                                 _VSTD::forward_as_tuple(_VSTD::forward<_T2>(__p.second)));
+}
+
+template<class _Tp, class _Alloc, class _T1, class _T2, class _Un>
+auto
+__uses_allocator_construction_args_impl(true_type,  // is pair
+                                        true_type,  // uses allocator
+                                        _Un,        // is constructible
+                                        const _Alloc& __alloc,
+                                        _T1&& __a, _T2&& __b)
+{
+    return uses_allocator_construction_args<_Tp>(__alloc,
+                                                 piecewise_construct,
+                                                 _VSTD::forward_as_tuple(_VSTD::forward<_T1>(__a)),
+                                                 _VSTD::forward_as_tuple(_VSTD::forward<_T2>(__b)));
+}
+
+template<class _Tp, class _Alloc, class... _Args>
+auto
+uses_allocator_construction_args(const _Alloc& __alloc, _Args&&... __args)
+{
+    return __uses_allocator_construction_args_impl<_Tp>(
+        __is_pair<_Tp>{}, // TODO: vstd::is_pair
+        __pair_uses_allocator<_Tp, _Alloc>{},
+        _VSTD::is_constructible<_Tp, allocator_arg_t, _Alloc, _Args...>{},
+        __alloc,
+        _VSTD::forward<_Args>(__args)...);
+}
+
+template<class _Tp, class _Alloc, class... _Args>
+_Tp
+make_obj_using_allocator(const _Alloc& __alloc, _Args&&... __args)
+{
+    return make_from_tuple<_Tp>(uses_allocator_construction_args<_Tp>(__alloc,
+                                                                      _VSTD::forward<_Args>(__args)...));
+}
+
+template<class _Tp, class _Alloc, class... _Args>
+_Tp*
+uninitialized_construct_using_allocator(_Tp* __p, const _Alloc& __alloc, _Args&&... __args)
+{
+    return ::new(static_cast<void*>(__p)) _Tp(make_obj_using_allocator<_Tp>(__alloc,
+                                                                            _VSTD::forward<_Args>(__args)...));
+}
+
+#endif // _LIBCPP_STD_VER > 17
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif  // _LIBCPP_MEMORY

include/scoped_allocator

void deallocate(pointer __p, size_type __n) _NOEXCEPT
         {allocator_traits<outer_allocator_type>::
             deallocate(outer_allocator(), __p, __n);}
 
     _LIBCPP_INLINE_VISIBILITY
     size_type max_size() const
         {return allocator_traits<outer_allocator_type>::max_size(outer_allocator());}
 
     template <class _Tp, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
-        void construct(_Tp* __p, _Args&& ...__args)
-            {__construct(__uses_alloc_ctor<_Tp, inner_allocator_type&, _Args...>(),
-                         __p, _VSTD::forward<_Args>(__args)...);}
+    {
+#if _LIBCPP_STD_VER > 17
+        using _OM = __outermost<outer_allocator_type>;
+        _VSTD::apply([__p, this](auto&&... __alloc_args) {
+            allocator_traits<typename _OM::type>::construct(
+                _OM()(*this), __p,
+                _VSTD::forward<decltype(__alloc_args)>(__alloc_args)...);
+        }, _VSTD::uses_allocator_construction_args<_Tp>(inner_allocator(),
+                                                        _VSTD::forward<_Args>(__args)...));
+#else
+        __construct(__uses_alloc_ctor<_Tp, inner_allocator_type&, _Args...>(),
+                     __p, _VSTD::forward<_Args>(__args)...);
+#endif // _LIBCPP_STD_VER > 17
+    }
 
+#if _LIBCPP_STD_VER <= 17
     template <class _T1, class _T2, class... _Args1, class... _Args2>
     void construct(pair<_T1, _T2>* __p, piecewise_construct_t,
                        tuple<_Args1...> __x, tuple<_Args2...> __y)
     {
         typedef __outermost<outer_allocator_type> _OM;
         allocator_traits<typename _OM::type>::construct(
             _OM()(outer_allocator()), __p, piecewise_construct
           , __transform_tuple(
#if _LIBCPP_STD_VER <= 17
     }
 
     template <class _T1, class _T2, class _Up, class _Vp>
     void construct(pair<_T1, _T2>* __p, pair<_Up, _Vp>&& __x) {
         construct(__p, piecewise_construct,
                   _VSTD::forward_as_tuple(_VSTD::forward<_Up>(__x.first)),
                   _VSTD::forward_as_tuple(_VSTD::forward<_Vp>(__x.second)));
     }
+#endif // _LIBCPP_STD_VER <= 17
 
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         void destroy(_Tp* __p)
             {
                 typedef __outermost<outer_allocator_type> _OM;
                 allocator_traits<typename _OM::type>::
                                          destroy(_OM()(outer_allocator()), __p);

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp

void test_pmr_not_uses_allocator(std::pair<TT, UU> const& p)
     }
 }
 
 template <class Tp>
 struct Print;
 
 int main(int, char**)
 {
+#if _LIBCPP_STD_VER <= 17
     using ERT = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
+#endif // _LIBCPP_STD_VER <= 17
     using PMA = ex::polymorphic_allocator<char>;
     {
         int x = 42;
         int y = 42;
         const std::pair<int, int&> p(x, y);
+#if _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<ERT>(p);
         test_pmr_not_uses_allocator<PMR>(p);
+#endif // _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<PMA>(p);
     }
     {
         int x = 42;
         int y = 42;
         const std::pair<int&, int&&> p(x, std::move(y));
+#if _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<ERT>(p);
         test_pmr_not_uses_allocator<PMR>(p);
+#endif // _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<PMA>(p);
     }
 
   return 0;
 }

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp

void test_pmr_not_uses_allocator(std::pair<TT, UU>&& p)
         using T = UsesAllocatorV3<Alloc, 1>;
         using U = NotUsesAllocator<Alloc, 1>;
         assert((doTest<T, U>(UA_None, UA_None, std::move(p))));
     }
 }
 
 int main(int, char**)
 {
+#if _LIBCPP_STD_VER <= 17
     using ERT = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
+#endif // _LIBCPP_STD_VER <= 17
     using PMA = ex::polymorphic_allocator<char>;
     {
         int x = 42;
         int y = 42;
         std::pair<int&, int&&> p(x, std::move(y));
+#if _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<ERT>(std::move(p));
         test_pmr_not_uses_allocator<PMR>(std::move(p));
+#endif // _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<PMA>(std::move(p));
     }
     {
         int x = 42;
         int y = 42;
         std::pair<int&&, int&> p(std::move(x), y);
+#if _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<ERT>(std::move(p));
         test_pmr_not_uses_allocator<PMR>(std::move(p));
+#endif // _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<PMA>(std::move(p));
     }
 
   return 0;
 }

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp

void test_pmr_not_uses_allocator(TT&& t, UU&& u)
         using U = NotUsesAllocator<Alloc, 1>;
         assert((doTest<T, U>(UA_None, UA_None,
                              std::forward<TT>(t), std::forward<UU>(u))));
     }
 }
 
 int main(int, char**)
 {
+#if _LIBCPP_STD_VER <= 17
     using ERT = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
+#endif // _LIBCPP_STD_VER <= 17
     using PMA = ex::polymorphic_allocator<char>;
     {
         int x = 42;
         int y = 42;
+#if _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<ERT>(x, std::move(y));
         test_pmr_not_uses_allocator<PMR>(x, std::move(y));
+#endif // _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<PMA>(x, std::move(y));
     }
     {
         int x = 42;
         const int y = 42;
+#if _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<ERT>(std::move(x), y);
         test_pmr_not_uses_allocator<PMR>(std::move(x), y);
+#endif // _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<PMA>(std::move(x), y);
     }
 
   return 0;
 }

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp

void test_pmr_not_uses_allocator(std::tuple<TTypes...> ttuple, std::tuple<UTypes...> utuple)
         using U = NotUsesAllocator<Alloc, sizeof...(UTypes)>;
         assert((doTest<T, U>(UA_None, UA_None,
                              std::move(ttuple), std::move(utuple))));
     }
 }
 
 int main(int, char**)
 {
+#if _LIBCPP_STD_VER <= 17
     using ERT = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
+#endif // _LIBCPP_STD_VER <= 17
     using PMA = ex::polymorphic_allocator<char>;
     {
         std::tuple<> t1;
+#if _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<ERT>(t1, t1);
         test_pmr_not_uses_allocator<PMR>(t1, t1);
+#endif // _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<PMA>(t1, t1);
     }
     {
         std::tuple<int> t1(42);
         std::tuple<> t2;
+#if _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<ERT>(t1, t2);
         test_pmr_uses_allocator<ERT>(t2, t1);
         test_pmr_not_uses_allocator<PMR>(t1, t2);
         test_pmr_not_uses_allocator<PMR>(t2, t1);
+#endif // _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<PMA>(t1, t2);
         test_pmr_uses_allocator<PMA>(t2, t1);
     }
     {
         std::tuple<int> t1(42);
         int x = 55;
         double dx = 42.42;
         std::tuple<int&, double&&> t2(x, std::move(dx));
+#if _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<ERT>(           t1, std::move(t2));
         test_pmr_uses_allocator<ERT>(std::move(t2),            t1);
         test_pmr_not_uses_allocator<PMR>(           t1, std::move(t2));
         test_pmr_not_uses_allocator<PMR>(std::move(t2),            t1);
+#endif // _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<PMA>(           t1, std::move(t2));
         test_pmr_uses_allocator<PMA>(std::move(t2),            t1);
     }
     {
         void* xptr = nullptr;
         long y = 4242;
         std::tuple<int, long const&, void*&> t1(42, y, xptr);
         int x = 55;
         double dx = 42.42;
         const char* s = "hello World";
         std::tuple<int&, double&&, const char*> t2(x, std::move(dx), s);
+#if _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<ERT>(           t1, std::move(t2));
         test_pmr_uses_allocator<ERT>(std::move(t2),            t1);
         test_pmr_not_uses_allocator<PMR>(           t1, std::move(t2));
         test_pmr_not_uses_allocator<PMR>(std::move(t2),            t1);
+#endif // _LIBCPP_STD_VER <= 17
         test_pmr_uses_allocator<PMA>(           t1, std::move(t2));
         test_pmr_uses_allocator<PMA>(std::move(t2),            t1);
     }
 
   return 0;
 }

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp

 #include "test_macros.h"
 
 namespace ex = std::experimental::pmr;
 
 template <class T>
 struct EvilAlloc {
     explicit EvilAlloc() : inner_(ex::null_memory_resource()) {}
 
-    EvilAlloc(ex::polymorphic_allocator<T> & a) : inner_(a) {}
-    EvilAlloc(ex::polymorphic_allocator<T> && a) : inner_(a) {}
-    EvilAlloc(ex::polymorphic_allocator<T> const & a) = delete;
-    EvilAlloc(ex::polymorphic_allocator<T> const && a) = delete;
+    EvilAlloc(ex::polymorphic_allocator<T> const& a) : inner_(a) {}
+    EvilAlloc(ex::polymorphic_allocator<T> const&& a) : inner_(a) {}
 
     using value_type = T;
     template <class U> EvilAlloc(EvilAlloc<U> const & rhs) : inner_(rhs.inner_) {}
 
     ex::polymorphic_allocator<T> inner_;
 };
 
 struct WidgetV0 {

test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp

void test_non_pmr_uses_alloc(AllocObj const& A, Args&&... args)
         assert(doTestUsesAllocV0<T>(std::forward<Args>(args)...));
         assert((doTestUsesAllocV1<T>(A, std::forward<Args>(args)...)));
         assert((doTestUsesAllocV2<T>(A, std::forward<Args>(args)...)));
     }
 }
 
 int main(int, char**)
 {
+#if _LIBCPP_STD_VER <= 17
     using ET = std::experimental::erased_type;
     using PMR = ex::memory_resource*;
-    using PMA = ex::polymorphic_allocator<void>;
     using STDA = std::allocator<char>;
     using TESTA = test_allocator<char>;
+#endif // _LIBCPP_STD_VER <= 17
+    using PMA = ex::polymorphic_allocator<void>;
 
     int value = 42;
     const int cvalue = 43;
     {
+#if _LIBCPP_STD_VER <= 17
         test_pmr_uses_alloc<ET>();
         test_pmr_not_uses_alloc<PMR>();
-        test_pmr_uses_alloc<PMA>();
         test_pmr_uses_alloc<ET>(value);
         test_pmr_not_uses_alloc<PMR>(value);
-        test_pmr_uses_alloc<PMA>(value);
         test_pmr_uses_alloc<ET>(cvalue);
         test_pmr_not_uses_alloc<PMR>(cvalue);
-        test_pmr_uses_alloc<PMA>(cvalue);
         test_pmr_uses_alloc<ET>(cvalue, std::move(value));
         test_pmr_not_uses_alloc<PMR>(cvalue, std::move(value));
+#endif // _LIBCPP_STD_VER <= 17
+        test_pmr_uses_alloc<PMA>();
+        test_pmr_uses_alloc<PMA>(cvalue);
+        test_pmr_uses_alloc<PMA>(value);
         test_pmr_uses_alloc<PMA>(cvalue, std::move(value));
     }
+#if _LIBCPP_STD_VER <= 17
     {
         STDA std_alloc;
         TESTA test_alloc(42);
         test_non_pmr_uses_alloc<STDA>(std_alloc);
         test_non_pmr_uses_alloc<TESTA>(test_alloc);
         test_non_pmr_uses_alloc<STDA>(std_alloc, value);
         test_non_pmr_uses_alloc<TESTA>(test_alloc, value);
         test_non_pmr_uses_alloc<STDA>(std_alloc, cvalue);
         test_non_pmr_uses_alloc<TESTA>(test_alloc, cvalue);
         test_non_pmr_uses_alloc<STDA>(std_alloc, cvalue, std::move(value));
         test_non_pmr_uses_alloc<TESTA>(test_alloc, cvalue, std::move(value));
     }
+#endif // _LIBCPP_STD_VER <= 17
 
   return 0;
 }

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp

AllocController P;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr);
         assert(checkConstruct<>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<>(ptr->second, UA_AllocLast, CA));
-        assert((P.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SA&>&&,
-                                 std::tuple<SA&>&&
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SA const&>&&,
+                                 std::tuple<SA const&>&&
               >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
 
     }
     P.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc, 0>;
         using U = NotUsesAllocator<VoidAlloc, 0>;
         using Pair = std::pair<T, U>;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr);
         assert(checkConstruct<>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<>(ptr->second, UA_None));
-        assert((P.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SA&>&&,
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SA const&>&&,
                                  std::tuple<>&&
                    >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
AllocController PInner;
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr);
         assert(checkConstruct<>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<>(ptr->second, UA_AllocLast));
-        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SAInner&>&&,
-                                 std::tuple<SAInner&>&&
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SAInner const&>&&,
+                                 std::tuple<SAInner const&>&&
               >(O, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
     PInner.reset();
     POuter.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc2, 0>;
         using U = NotUsesAllocator<VoidAlloc2, 0>;
         using Pair = std::pair<T, U>;
         using Outer = CountingAllocator<Pair, 1>;
         using Inner = CountingAllocator<Pair, 2>;
         using SA = std::scoped_allocator_adaptor<Outer, Inner>;
         using SAInner = std::scoped_allocator_adaptor<Inner>;
         static_assert(!std::uses_allocator<T, Outer>::value, "");
         static_assert(std::uses_allocator<T, Inner>::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr);
         assert(checkConstruct<>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<>(ptr->second, UA_None));
-        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SAInner&>&&,
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SAInner const&>&&,
                                  std::tuple<>&&
               >(O, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
 
   return 0;
 }

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp

AllocController P;
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         const PairIn in(x, std::move(y));
         A.construct(ptr, in);
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_AllocLast, CA));
-        assert((P.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SA&, int&>&&,
-                                 std::tuple<int const&, SA&>&&
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SA const&, int&>&&,
+                                 std::tuple<int const&, SA const&>&&
               >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
 
     }
     P.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc, 1>;
         using U = NotUsesAllocator<VoidAlloc, 1>;
         using Pair = std::pair<T, U>;
         using PairIn = std::pair<int, int const&>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         const PairIn in(x, y);
         A.construct(ptr, in);
         assert(checkConstruct<int const&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
-        assert((P.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SA&, int const&>&&,
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SA const&, int const&>&&,
                                  std::tuple<int const&>&&
                    >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
AllocController PInner;
         assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         const PairIn in(x, std::move(y));
         A.construct(ptr, in);
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&>(ptr->second, UA_AllocLast));
-        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SAInner&, int&>&&,
-                                 std::tuple<int const&, SAInner&>&&
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SAInner const&, int&>&&,
+                                 std::tuple<int const&, SAInner const&>&&
               >(O, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
     PInner.reset();
     POuter.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc2, 1>;
POuter.reset();
         assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         const PairIn in(x, y);
         A.construct(ptr, in);
         assert(checkConstruct<int const&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
-        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SAInner&, int const&>&&,
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SAInner const&, int const&>&&,
                                  std::tuple<int const&>&&
               >(O, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
 
   return 0;
 }

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp

AllocController P;
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr, std::piecewise_construct,
                     std::forward_as_tuple(x),
                     std::forward_as_tuple(std::move(y)));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast, CA));
-        assert((P.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SA&, int&>&&,
-                                 std::tuple<int const&&, SA&>&&
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SA const&, int&>&&,
+                                 std::tuple<int const&&, SA const&>&&
               >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
 
     }
     P.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc, 1>;
         using U = NotUsesAllocator<VoidAlloc, 1>;
         using Pair = std::pair<T, U>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr, std::piecewise_construct,
                     std::forward_as_tuple(std::move(x)),
                     std::forward_as_tuple(y));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
-        assert((P.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SA&, int&&>&&,
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SA const&, int&&>&&,
                                  std::tuple<int const&>&&
                    >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
AllocController PInner;
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr, std::piecewise_construct,
                     std::forward_as_tuple(x),
                     std::forward_as_tuple(std::move(y)));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int &&>(ptr->second, UA_AllocLast));
-        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SAInner&, int&>&&,
-                                 std::tuple<int &&, SAInner&>&&
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SAInner const&, int&>&&,
+                                 std::tuple<int &&, SAInner const&>&&
               >(O, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
     PInner.reset();
     POuter.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc2, 1>;
POuter.reset();
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr, std::piecewise_construct,
                     std::forward_as_tuple(std::move(x)),
                     std::forward_as_tuple(std::move(y)));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&&>(ptr->second, UA_None));
-        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SAInner&, int&&>&&,
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SAInner const&, int&&>&&,
                                  std::tuple<int const&&>&&
               >(O, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
 
   return 0;
 }

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp

AllocController P;
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         PairIn in(x, std::move(y));
         A.construct(ptr, std::move(in));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast, CA));
-        assert((P.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SA&, int&>&&,
-                                 std::tuple<int const&&, SA&>&&
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SA const&, int&>&&,
+                                 std::tuple<int const&&, SA const&>&&
               >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
 
     }
     P.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc, 1>;
         using U = NotUsesAllocator<VoidAlloc, 1>;
         using Pair = std::pair<T, U>;
         using PairIn = std::pair<int, int const&>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         PairIn in(x, y);
         A.construct(ptr, std::move(in));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
-        assert((P.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SA&, int&&>&&,
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SA const&, int&&>&&,
                                  std::tuple<int const&>&&
                    >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
AllocController PInner;
         assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         PairIn in(x, std::move(y));
         A.construct(ptr, std::move(in));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast));
-        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SAInner&, int&>&&,
-                                 std::tuple<int const&&, SAInner&>&&
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SAInner const&, int&>&&,
+                                 std::tuple<int const&&, SAInner const&>&&
               >(O, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
     PInner.reset();
     POuter.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc2, 1>;
POuter.reset();
         assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         PairIn in(x, y);
         A.construct(ptr, std::move(in));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
-        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SAInner&, int&&>&&,
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SAInner const&, int&&>&&,
                                  std::tuple<int const&>&&
               >(O, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
 
   return 0;
 }

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp

AllocController P;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr, x, std::move(y));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&&>(ptr->second, UA_AllocLast, CA));
-        assert((P.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SA&, int&>&&,
-                                 std::tuple<int const&&, SA&>&&
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SA const&, int&>&&,
+                                 std::tuple<int const&&, SA const&>&&
               >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
 
     }
     P.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc, 1>;
         using U = NotUsesAllocator<VoidAlloc, 1>;
         using Pair = std::pair<T, U>;
         int x = 42;
         const int y = 101;
         using Alloc = CountingAllocator<Pair>;
         using SA = std::scoped_allocator_adaptor<Alloc>;
         static_assert(std::uses_allocator<T, CountingAllocator<T> >::value, "");
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Alloc CA(P);
         SA A(CA);
         A.construct(ptr, std::move(x), y);
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, CA));
         assert(checkConstruct<int const&>(ptr->second, UA_None));
-        assert((P.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SA&, int&&>&&,
+        assert((P.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SA const&, int&&>&&,
                                  std::tuple<int const&>&&
                    >(CA, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 
 void test_with_inner_alloc()
AllocController PInner;
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr, x, std::move(y));
         assert(checkConstruct<int&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int &&>(ptr->second, UA_AllocLast));
-        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SAInner&, int&>&&,
-                                 std::tuple<int &&, SAInner&>&&
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SAInner const&, int&>&&,
+                                 std::tuple<int &&, SAInner const&>&&
               >(O, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
     PInner.reset();
     POuter.reset();
     {
         using T = UsesAllocatorV3<VoidAlloc2, 1>;
POuter.reset();
         Pair * ptr = (Pair*)std::malloc(sizeof(Pair));
         assert(ptr != nullptr);
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         A.construct(ptr, std::move(x), std::move(y));
         assert(checkConstruct<int&&>(ptr->first, UA_AllocArg, I));
         assert(checkConstruct<int const&&>(ptr->second, UA_None));
-        assert((POuter.checkConstruct<std::piecewise_construct_t const&,
-                                 std::tuple<std::allocator_arg_t, SAInner&, int&&>&&,
+        assert((POuter.checkConstruct<std::piecewise_construct_t&&,
+                                 std::tuple<std::allocator_arg_t const&, SAInner const&, int&&>&&,
                                  std::tuple<int const&&>&&
               >(O, ptr)));
         A.destroy(ptr);
         std::free(ptr);
     }
 }
 int main(int, char**) {
     test_no_inner_alloc();
     test_with_inner_alloc();
 
   return 0;
 }

test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp

AllocController PInner;
         Outer O(POuter);
         Inner I(PInner);
         SA A(O, I);
         int x = 42;
         int const& cx = x;
         A.construct(ptr, x, cx, std::move(x));
         assert((checkConstruct<int&, int const&, int&&>(*ptr, UA_AllocArg, I)));
         assert((POuter.checkConstruct<std::allocator_arg_t const&,
-                   SA::inner_allocator_type&, int&, int const&, int&&>(O, ptr)));
+                   SA::inner_allocator_type const&, int&, int const&, int&&>(O, ptr)));
         A.destroy(ptr);
         ::operator delete((void*)ptr);
     }
     PInner.reset();
     POuter.reset();
 }
 
 // Otherwise, if uses_allocator_v<T, inner_allocator_type> is true and
AllocController PInner;
         Inner I(PInner);
         SA A(O, I);
         int x = 42;
         int const& cx = x;
         A.construct(ptr, x, cx, std::move(x));
         assert((checkConstruct<int&, int const&, int&&>(*ptr, UA_AllocLast, I)));
         assert((POuter.checkConstruct<
                    int&, int const&, int&&,
-                   SA::inner_allocator_type&>(O, ptr)));
+                   SA::inner_allocator_type const&>(O, ptr)));
         A.destroy(ptr);
         ::operator delete((void*)ptr);
     }
     PInner.reset();
     POuter.reset();
 }
 
 int main(int, char**) {
     test_bullet_one();
     test_bullet_two();
     test_bullet_three();
 
   return 0;
 }

test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.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 T, class Alloc, class... Args>
+//     auto uses_allocator_construction_args(const Alloc& alloc, Args&&... args);
+// template <class T, class Alloc, class Tuple1, class Tuple2>
+//     auto uses_allocator_construction_args(const Alloc& alloc, piecewise_construct_t, Tuple1&& x, Tuple2&& y);
+// template <class T>
+//     auto uses_allocator_construction_args(const Alloc& alloc);
+// template <class T, class Alloc, class U, class V>
+//     auto uses_allocator_construction_args(const Alloc& alloc, U&& u, V&& v);
+// template <class T, class Alloc, class U, class V>
+//     auto uses_allocator_construction_args(const Alloc& alloc, const pair<U,V>& pr);
+// template <class T, class Alloc, class U, class V>
+//     auto uses_allocator_construction_args(const Alloc& alloc, pair<U,V>&& pr);
+// template <class T, class Alloc, class... Args>
+//     T make_obj_using_allocator(const Alloc& alloc, Args&&... args);
+// template <class T, class Alloc, class... Args>
+//     T* uninitialized_construct_using_allocator(T* p, const Alloc& alloc, Args&&... args);
+
+#include <memory>
+#include <utility>
+#include <cassert>
+#include <iostream>
+
+#include "test_macros.h"
+#include "type_id.h"
+
+// Uses alloc types
+
+struct A
+{
+    int a;
+    float b;
+
+    A(int a, float b) : a(a), b(b) { }
+};
+
+struct B : A
+{
+    using allocator_type = std::allocator<B>;
+    B(std::allocator_arg_t, std::allocator<B>, int a, int b) : A(a, b) { }
+};
+
+struct C : A
+{
+    using allocator_type = std::allocator<C>;
+    C(int a, int b, std::allocator<C>) : A(a, b) { }
+};
+
+struct D
+{
+    using allocator_type = std::allocator<D>;
+};
+
+struct E
+{
+    using allocator_type = std::allocator<E>;
+
+    int i;
+
+    E(std::allocator_arg_t, std::allocator<B>, int i) : i(i) { }
+};
+
+struct F
+{
+    using allocator_type = std::allocator<F>;
+
+    int i;
+
+    F(std::allocator_arg_t, std::allocator<B>, int&& i) : i(i) { }
+};
+
+// Move / Copy only types
+
+struct MoveOnly
+{
+    MoveOnly(MoveOnly const&) { assert(false); }
+    MoveOnly(MoveOnly&&) { }
+
+    MoveOnly() { }
+};
+
+struct CopyOnly
+{
+    CopyOnly(CopyOnly const&) { }
+    CopyOnly(CopyOnly&&) { assert(false); }
+
+    CopyOnly() { }
+};
+
+struct AcceptBoth
+{
+    using allocator_type = std::allocator<AcceptBoth>;
+
+    AcceptBoth(std::allocator_arg_t, std::allocator<AcceptBoth>, CopyOnly const&) { }
+    AcceptBoth(std::allocator_arg_t, std::allocator<AcceptBoth>, MoveOnly&&)      { }
+
+    AcceptBoth(std::allocator_arg_t, std::allocator<AcceptBoth>, CopyOnly const&, CopyOnly const&) { }
+    AcceptBoth(std::allocator_arg_t, std::allocator<AcceptBoth>, MoveOnly&&,      MoveOnly&&)      { }
+};
+
+struct AcceptBothC
+{
+    using allocator_type = std::allocator<AcceptBothC>;
+
+    AcceptBothC(CopyOnly const&, std::allocator<AcceptBothC>) { }
+    AcceptBothC(MoveOnly&&,      std::allocator<AcceptBothC>) { }
+};
+
+// Util function
+
+template<class T, class U>
+void assert_same_typeid()
+{
+    auto a = &makeTypeID<T>();
+    auto b = &makeTypeID<U>();
+    assert(COMPARE_TYPEID(a, b) && "Comparison of types using typeid failed!");
+}
+
+// Tests
+
+template <class T, class... Args>
+T test_uses_alloc(Args&&... args)
+{
+    auto args_tuple = std::uses_allocator_construction_args<T>(std::forward<Args>(args)...);
+    const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+    static_assert(arg_count == sizeof...(Args) - 1);
+
+    return std::make_from_tuple<T>(args_tuple);
+}
+
+void general_tests()
+{
+    using pair_t = std::pair<int, int>;
+
+    // non pair contruction
+    std::allocator<A> alloc;
+    auto a = std::make_obj_using_allocator<A>(alloc, 10, 5.0);
+
+    ASSERT_SAME_TYPE(decltype(a), A);
+    assert(a.a == 10);
+    assert(a.b == 5.0);
+
+    auto* b = std::uninitialized_construct_using_allocator(&a, alloc, 20, 10.0);
+
+    assert(a.a == 20);
+    assert(a.b == 10.0);
+
+    ASSERT_SAME_TYPE(decltype(b), A*);
+    assert(b->a == 20);
+    assert(b->b == 10.0);
+
+    assert(&a == b);
+
+    // pair construction
+    std::allocator<pair_t> p_alloc;
+    pair_t p { 10, 5 };
+
+    test_uses_alloc<pair_t>(p_alloc);
+    auto res = test_uses_alloc<pair_t>(p_alloc, 10, 5);
+    auto res1 = test_uses_alloc<pair_t>(p_alloc, p);
+    assert(res.first == res1.first &&
+           res.second == res1.second &&
+           res.first == 10 &&
+           res.second == 5);
+
+    auto res2 = test_uses_alloc<A>(std::allocator<A>(), 10, 10.0);
+    assert(res2.a == res2.b && res2.a == 10);
+}
+
+void test_no_allocator()
+{
+    auto args_tuple = std::uses_allocator_construction_args<A>(std::allocator<void>{}, 10, 5.0);
+    const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+    static_assert(arg_count == 2);
+
+    assert(std::get<0>(args_tuple) == 10);
+    assert(std::get<1>(args_tuple) == 5.0);
+
+    auto a = std::make_from_tuple<A>(args_tuple);
+    assert(a.a == 10);
+    assert(a.b == 5.0);
+}
+
+void test_no_pair()
+{
+    { // make sure we are calling the correct overload
+        static_assert(!std::uses_allocator<A, std::allocator<A>>::value);
+        static_assert(!std::is_constructible<A, std::allocator_arg_t, std::allocator<A>, int, int>::value);
+        static_assert( std::is_constructible<A, int, int>::value);
+        static_assert( std::uses_allocator<B, std::allocator<B>>::value);
+        static_assert( std::is_constructible<B, std::allocator_arg_t, std::allocator<B>, int, int>::value);
+        static_assert( std::uses_allocator<C, std::allocator<C>>::value);
+        static_assert( std::is_constructible<C, int, int, std::allocator<C>>::value); // TODO: should this be checked?
+    }
+    {
+        auto args_tuple = std::uses_allocator_construction_args<B>(std::allocator<B>{}, 10, 5.0);
+        const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+        static_assert(arg_count == 4);
+
+        assert(std::get<2>(args_tuple) == 10);
+        assert(std::get<3>(args_tuple) == 5.0);
+
+        auto b = std::make_from_tuple<B>(args_tuple);
+        assert(b.a == 10);
+        assert(b.b == 5.0);
+    }
+    {
+        auto args_tuple = std::uses_allocator_construction_args<C>(std::allocator<C>{}, 10, 5.0);
+        const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+        static_assert(arg_count == 3);
+
+        assert(std::get<0>(args_tuple) == 10);
+        assert(std::get<1>(args_tuple) == 5.0);
+
+        auto c = std::make_from_tuple<C>(args_tuple);
+        assert(c.a == 10);
+        assert(c.b == 5.0);
+    }
+}
+
+void test_pair()
+{
+    using pair_t = std::pair<B, B>;
+
+    {
+        auto args_tuple = std::uses_allocator_construction_args<pair_t>(std::allocator<B>{},
+                                                                        std::piecewise_construct,
+                                                                        std::make_tuple(10, 5),
+                                                                        std::make_tuple(4, 2));
+        const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+        const auto arg_count1 = std::tuple_size<std::remove_reference_t<decltype(std::get<1>(args_tuple))>>::value;
+        const auto arg_count2 = std::tuple_size<std::remove_reference_t<decltype(std::get<2>(args_tuple))>>::value;
+        static_assert(arg_count == 3);
+        static_assert(arg_count1 == 4);
+        static_assert(arg_count2 == 4);
+
+        assert_same_typeid<decltype(std::get<0>(args_tuple)), std::piecewise_construct_t&>();
+        assert_same_typeid<decltype(std::get<0>(std::get<1>(args_tuple))), std::allocator_arg_t const&>();
+        assert_same_typeid<decltype(std::get<1>(std::get<1>(args_tuple))), std::allocator<B> const&>();
+        assert_same_typeid<decltype(std::get<0>(std::get<2>(args_tuple))), std::allocator_arg_t const&>();
+        assert_same_typeid<decltype(std::get<1>(std::get<2>(args_tuple))), std::allocator<B> const&>();
+
+        assert(std::get<2>(std::get<1>(args_tuple)) == 10);
+        assert(std::get<3>(std::get<1>(args_tuple)) == 5);
+        assert(std::get<2>(std::get<2>(args_tuple)) == 4);
+        assert(std::get<3>(std::get<2>(args_tuple)) == 2);
+
+        auto p = std::make_from_tuple<pair_t>(args_tuple);
+        assert(p.first.a == 10);
+        assert(p.first.b == 5);
+        assert(p.second.a == 4);
+        assert(p.second.b == 2);
+    }
+    {
+        auto args_tuple = std::uses_allocator_construction_args<pair_t>(std::allocator<B>{});
+        const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+        const auto arg_count1 = std::tuple_size<std::remove_reference_t<decltype(std::get<1>(args_tuple))>>::value;
+        const auto arg_count2 = std::tuple_size<std::remove_reference_t<decltype(std::get<2>(args_tuple))>>::value;
+        static_assert(arg_count == 3);
+        static_assert(arg_count1 == 1);
+        static_assert(arg_count2 == 1);
+
+        assert_same_typeid<decltype(std::get<0>(args_tuple)), std::piecewise_construct_t&>();
+        assert_same_typeid<decltype(std::get<0>(std::get<1>(args_tuple))), std::allocator<B> const&>();
+        assert_same_typeid<decltype(std::get<0>(std::get<2>(args_tuple))), std::allocator<B> const&>();
+    }
+    {
+        using pair_e = std::pair<E, E>;
+        auto args_pair = std::make_pair(10, 5);
+        auto args_tuple = std::uses_allocator_construction_args<pair_e>(std::allocator<E>{},
+                                                                        args_pair);
+        const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+        const auto arg_count1 = std::tuple_size<std::remove_reference_t<decltype(std::get<1>(args_tuple))>>::value;
+        const auto arg_count2 = std::tuple_size<std::remove_reference_t<decltype(std::get<2>(args_tuple))>>::value;
+        static_assert(arg_count == 3);
+        static_assert(arg_count1 == 3);
+        static_assert(arg_count2 == 3);
+
+        assert_same_typeid<decltype(std::get<0>(args_tuple)), std::piecewise_construct_t&>();
+        assert_same_typeid<decltype(std::get<0>(std::get<1>(args_tuple))), std::allocator_arg_t const&>();
+        assert_same_typeid<decltype(std::get<1>(std::get<1>(args_tuple))), std::allocator<E> const&>();
+        assert_same_typeid<decltype(std::get<0>(std::get<2>(args_tuple))), std::allocator_arg_t const&>();
+        assert_same_typeid<decltype(std::get<1>(std::get<2>(args_tuple))), std::allocator<E> const&>();
+
+        assert(std::get<2>(std::get<1>(args_tuple)) == 10);
+        assert(std::get<2>(std::get<2>(args_tuple)) == 5);
+
+        auto p = std::make_from_tuple<pair_e>(args_tuple);
+        assert(p.first.i == 10);
+        assert(p.second.i == 5);
+    }
+    {
+        using pair_e = std::pair<E, E>;
+        auto args_pair = std::make_pair(10, 5);
+        auto args_tuple = std::uses_allocator_construction_args<pair_e>(std::allocator<E>{},
+                                                                        std::move(args_pair));
+        const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+        const auto arg_count1 = std::tuple_size<std::remove_reference_t<decltype(std::get<1>(args_tuple))>>::value;
+        const auto arg_count2 = std::tuple_size<std::remove_reference_t<decltype(std::get<2>(args_tuple))>>::value;
+        static_assert(arg_count == 3);
+        static_assert(arg_count1 == 3);
+        static_assert(arg_count2 == 3);
+
+        assert_same_typeid<decltype(std::get<0>(args_tuple)), std::piecewise_construct_t&>();
+        assert_same_typeid<decltype(std::get<0>(std::get<1>(args_tuple))), std::allocator_arg_t const&>();
+        assert_same_typeid<decltype(std::get<1>(std::get<1>(args_tuple))), std::allocator<E> const&>();
+        assert_same_typeid<decltype(std::get<0>(std::get<2>(args_tuple))), std::allocator_arg_t const&>();
+        assert_same_typeid<decltype(std::get<1>(std::get<2>(args_tuple))), std::allocator<E> const&>();
+
+        assert(std::get<2>(std::get<1>(args_tuple)) == 10);
+        assert(std::get<2>(std::get<2>(args_tuple)) == 5);
+
+        auto p = std::make_from_tuple<pair_e>(args_tuple);
+        assert(p.first.i == 10);
+        assert(p.second.i == 5);
+    }
+    {
+        using pair_e = std::pair<E, E>;
+        int x = 42;
+        int y = 101;
+        auto args_tuple = std::uses_allocator_construction_args<pair_e>(std::allocator<E>{},
+                                                                        std::move(x), std::move(y));
+        const auto arg_count = std::tuple_size<decltype(args_tuple)>::value;
+        const auto arg_count1 = std::tuple_size<std::remove_reference_t<decltype(std::get<1>(args_tuple))>>::value;
+        const auto arg_count2 = std::tuple_size<std::remove_reference_t<decltype(std::get<2>(args_tuple))>>::value;
+        static_assert(arg_count == 3);
+        static_assert(arg_count1 == 3);
+        static_assert(arg_count2 == 3);
+
+        assert_same_typeid<decltype(std::get<0>(args_tuple)), std::piecewise_construct_t&>();
+        assert_same_typeid<decltype(std::get<0>(std::get<1>(args_tuple))), std::allocator_arg_t const&>();
+        assert_same_typeid<decltype(std::get<1>(std::get<1>(args_tuple))), std::allocator<E> const&>();
+        assert_same_typeid<decltype(std::get<0>(std::get<2>(args_tuple))), std::allocator_arg_t const&>();
+        assert_same_typeid<decltype(std::get<1>(std::get<2>(args_tuple))), std::allocator<E> const&>();
+
+        assert(std::get<2>(std::get<1>(args_tuple)) == 42);
+        assert(std::get<2>(std::get<2>(args_tuple)) == 101);
+
+        auto p = std::make_from_tuple<pair_e>(args_tuple);
+        assert(p.first.i == 42);
+        assert(p.second.i == 101);
+    }
+}
+
+void test_make_obj()
+{
+    using pair_t = std::pair<B, B>;
+
+    {
+        pair_t p = std::make_obj_using_allocator<pair_t>(std::allocator<B>{},
+                                                         std::piecewise_construct,
+                                                         std::make_tuple(10, 5),
+                                                         std::make_tuple(4, 2));
+        assert(p.first.a == 10);
+        assert(p.first.b == 5);
+        assert(p.second.a == 4);
+        assert(p.second.b == 2);
+    }
+    {
+        using pair_e = std::pair<E, E>;
+        auto args_pair = std::make_pair(10, 5);
+        auto p = std::make_obj_using_allocator<pair_e>(std::allocator<E>{}, args_pair);
+
+        assert(p.first.i == 10);
+        assert(p.second.i == 5);
+    }
+    {
+        using pair_e = std::pair<E, E>;
+        auto args_pair = std::make_pair(10, 5);
+        auto p = std::make_obj_using_allocator<pair_e>(std::allocator<E>{},
+                                                       std::move(args_pair));
+
+        assert(p.first.i == 10);
+        assert(p.second.i == 5);
+    }
+    {
+        auto b = std::make_obj_using_allocator<B>(std::allocator<B>{}, 10, 5.0);
+
+        assert(b.a == 10);
+        assert(b.b == 5.0);
+    }
+    {
+        auto c = std::make_obj_using_allocator<C>(std::allocator<C>{}, 10, 5.0);
+
+        assert(c.a == 10);
+        assert(c.b == 5.0);
+    }
+}
+
+void test_forwarding()
+{
+    using pair_t = std::pair<AcceptBoth, AcceptBoth>;
+    auto copy_only = CopyOnly();
+    auto move_only = MoveOnly();
+
+    {
+        auto move_args = std::make_tuple(std::move(move_only), std::move(move_only));
+        auto copy_args = std::make_tuple(copy_only, copy_only);
+        std::uses_allocator_construction_args<pair_t>(std::allocator<AcceptBoth>{},
+                                                      std::piecewise_construct,
+                                                      std::move(move_args),
+                                                      std::move(move_args));
+        std::uses_allocator_construction_args<pair_t>(std::allocator<AcceptBoth>{},
+                                                      std::piecewise_construct,
+                                                      copy_args,
+                                                      copy_args);
+    }
+    {
+        auto args_pair = std::make_pair(copy_only, copy_only);
+        std::uses_allocator_construction_args<pair_t>(std::allocator<AcceptBoth>{}, args_pair);
+    }
+    {
+        auto args_pair = std::make_pair(std::move(move_only), std::move(move_only));
+        std::uses_allocator_construction_args<pair_t>(std::allocator<AcceptBoth>{},
+                                                      std::move(args_pair));
+    }
+    {
+        auto x = MoveOnly();
+        auto y = MoveOnly();
+        auto z = CopyOnly();
+        auto w = CopyOnly();
+        std::uses_allocator_construction_args<pair_t>(std::allocator<AcceptBoth>{},
+                                                      std::move(x), std::move(y));
+        std::uses_allocator_construction_args<pair_t>(std::allocator<AcceptBoth>{}, z, w);
+    }
+    {
+        std::uses_allocator_construction_args<AcceptBoth>(std::allocator<AcceptBoth>{}, copy_only);
+        std::uses_allocator_construction_args<AcceptBoth>(std::allocator<AcceptBoth>{}, std::move(move_only));
+    }
+    {
+        std::uses_allocator_construction_args<AcceptBothC>(std::allocator<AcceptBothC>{}, copy_only);
+        std::uses_allocator_construction_args<AcceptBothC>(std::allocator<AcceptBothC>{}, std::move(move_only));
+    }
+}
+
+int main(int, char**)
+{
+    general_tests();
+    test_no_allocator();
+    test_no_pair();
+    test_pair();
+    test_make_obj();
+    test_forwarding();
+
+    return 0;
+}