Index: include/experimental/memory_resource
===================================================================
--- include/experimental/memory_resource
+++ include/experimental/memory_resource
@@ -200,6 +200,15 @@
         __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)
@@ -261,6 +270,7 @@
             , _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
Index: include/memory
===================================================================
--- include/memory
+++ include/memory
@@ -626,6 +626,24 @@
     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> >;
@@ -5668,6 +5686,163 @@
      >
    : 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
Index: include/scoped_allocator
===================================================================
--- include/scoped_allocator
+++ include/scoped_allocator
@@ -496,11 +496,24 @@
         {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)...);}
+    _LIBCPP_INLINE_VISIBILITY
+    void construct(_Tp* __p, _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)
@@ -549,6 +562,7 @@
                   _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
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_const_lvalue_pair.pass.cpp
@@ -119,23 +119,29 @@
 
 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);
     }
 
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_rvalue.pass.cpp
@@ -115,23 +115,29 @@
 
 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));
     }
 
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_pair_values.pass.cpp
@@ -122,21 +122,27 @@
 
 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);
     }
 
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair.pass.cpp
@@ -112,22 +112,28 @@
 
 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);
     }
@@ -136,10 +142,12 @@
         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);
     }
@@ -151,10 +159,12 @@
         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);
     }
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_piecewise_pair_evil.pass.cpp
@@ -31,10 +31,8 @@
 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_) {}
Index: test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
===================================================================
--- test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
+++ test/std/experimental/memory/memory.polymorphic.allocator.class/memory.polymorphic.allocator.mem/construct_types.pass.cpp
@@ -188,28 +188,33 @@
 
 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);
@@ -222,6 +227,7 @@
         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;
 }
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair.pass.cpp
@@ -44,9 +44,9 @@
         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);
@@ -67,8 +67,8 @@
         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);
@@ -100,9 +100,9 @@
         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);
@@ -127,8 +127,8 @@
         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);
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_const_lvalue_pair.pass.cpp
@@ -48,9 +48,9 @@
         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);
@@ -75,8 +75,8 @@
         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);
@@ -112,9 +112,9 @@
         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);
@@ -143,8 +143,8 @@
         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);
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_piecewise.pass.cpp
@@ -49,9 +49,9 @@
                     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);
@@ -76,8 +76,8 @@
                     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);
@@ -113,9 +113,9 @@
                     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);
@@ -144,8 +144,8 @@
                     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);
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_rvalue.pass.cpp
@@ -48,9 +48,9 @@
         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);
@@ -75,8 +75,8 @@
         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);
@@ -112,9 +112,9 @@
         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);
@@ -143,8 +143,8 @@
         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);
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_pair_values.pass.cpp
@@ -46,9 +46,9 @@
         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);
@@ -71,8 +71,8 @@
         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);
@@ -106,9 +106,9 @@
         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);
@@ -135,8 +135,8 @@
         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);
Index: test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
===================================================================
--- test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
+++ test/std/utilities/allocator.adaptor/allocator.adaptor.members/construct_type.pass.cpp
@@ -83,7 +83,7 @@
         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);
     }
@@ -117,7 +117,7 @@
         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);
     }
Index: test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp
===================================================================
--- /dev/null
+++ test/std/utilities/memory/allocator.uses/allocator.uses.construction/uses_allocator_construction_args.pass.cpp
@@ -0,0 +1,455 @@
+//===----------------------------------------------------------------------===//
+//
+// 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;
+}