[libc++][P0174] Deprecated/removed parts of default allocator.

[mpark]

Updated to use allocator_traits<>::max_size().

[mpark]

Fixed the static_cast result out of allocator<const T>.

[mpark]

Added a new test allocate.depr_in_cxx17.fail.cpp.

[mpark]

Fixed the allocate.depr_in_cxx17.fail.cpp test.

[mpark]

• Replaced use of allocator_traits::max_size with implementation of max_size(). This will be replaced to allocator_traits::max_size once allocator::max_size and allocator_traits::max_size are both marked constexpr.
• Removed deprecated attributes from C++03 codepaths.
• Moved/added more tests.

[mpark]

Refined the tests.

[ldionne]

libcxx/include/memory

118–125

Woooh, thanks for the cleanup.

1373

What! I didn't know you could surround literally any piece of code with these pragmas! It does make sense though, since it's a preprocessor thing. Clang will really take the pragma into account when parsing just that part of the declaration?

1405

If the return type of __a.construct(...) somehow hijacks operator,, this won't work. But I don't care, don't change it.

An Allocator's construct method is supposed to return void -- if someone's that clever, they deserve to be taught better.

1890–1891

I'm OK with this TODO since I saw you fixed it in a subsequent patch.

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.depr_in_cxx17.fail.cpp

15–16

Wait, you shouldn't get rid of this test pre-C++17. You should mark it as REQUIRES: c++03, ..., c++14. Or did I miss something and you did not actually remove this test?

[mpark]

libcxx/include/memory

1373

I believe so!

1405

+1

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.depr_in_cxx17.fail.cpp

15–16

This test has been moved to libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.cxx2a.pass.cpp, following the pattern for auto_ptr which have auto_ptr.cxx1z.pass.cpp and auto_ptr.depr_in_cxx11.fail.cpp.

[mpark]

libcxx/include/memory

1373

Never mind, You were right. I can't do this 😅

[mpark]

Fixed build error.

[ldionne]

libcxx/test/libcxx/depr/depr.default.allocator/allocator_types.depr_in_cxx17.fail.cpp

35

I'll admit I'm not the biggest fan of those escape hatches. Let's leave it here to avoid a discussion, but in the future we may want to have a discussion about whether we want to be less forgiving about those.

[ldionne]

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/allocate.depr_in_cxx17.fail.cpp

17

Just as a statement of how tricky it is to get things right the first time in libc++ (cause we're talking about it elsewhere), this broke the GCC-trunk C++17 bot on Ubuntu, and only that one. Finding it required firing my docker image with a similar configuration to the bot and running another test that we'd expect to fail, but was instead skipped. That hinted me that this test should be unsupported too, and I found the typo.

[dblaikie]

libcxx/include/memory

717

https://bugs.llvm.org/show_bug.cgi?id=50299 might be of interest

[ldionne]

libcxx/include/memory

717

Thanks for the heads up, indeed we need to fix this. I'm doing that now.

Thanks @jwakely for the report BTW.

libcxx/include/memory

typedef Alloc::propagate_on_container_copy_assignment
           | false_type                   propagate_on_container_copy_assignment;
     typedef Alloc::propagate_on_container_move_assignment
           | false_type                   propagate_on_container_move_assignment;
     typedef Alloc::propagate_on_container_swap
           | false_type                   propagate_on_container_swap;
     typedef Alloc::is_always_equal
           | is_empty                     is_always_equal;
 
-    template <class T> using rebind_alloc  = Alloc::rebind<U>::other | Alloc<T, Args...>;
+    template <class T> using rebind_alloc  = Alloc::rebind<T>::other | Alloc<T, Args...>;
     template <class T> using rebind_traits = allocator_traits<rebind_alloc<T>>;
 
     static pointer allocate(allocator_type& a, size_type n);                          // [[nodiscard]] in C++20
     static pointer allocate(allocator_type& a, size_type n, const_void_pointer hint); // [[nodiscard]] in C++20
 
     static void deallocate(allocator_type& a, pointer p, size_type n) noexcept;
 
     template <class T, class... Args>
         static void construct(allocator_type& a, T* p, Args&&... args);
 
     template <class T>
         static void destroy(allocator_type& a, T* p);
 
     static size_type max_size(const allocator_type& a); // noexcept in C++14
 
     static allocator_type
         select_on_container_copy_construction(const allocator_type& a);
 };
 
 template <>
-class allocator<void>
+class allocator<void> // deprecated in C++17, removed in C++20
 {
 public:
     typedef void*                                 pointer;
     typedef const void*                           const_pointer;
     typedef void                                  value_type;
 
     template <class _Up> struct rebind {typedef allocator<_Up> other;};
 };
 
 template <class T>
 class allocator
 {
 public:
-    typedef size_t                                size_type;
-    typedef ptrdiff_t                             difference_type;
-    typedef T*                                    pointer;
-    typedef const T*                              const_pointer;
-    typedef typename add_lvalue_reference<T>::type       reference;
-    typedef typename add_lvalue_reference<const T>::type const_reference;
-    typedef T                                     value_type;
+    typedef size_t    size_type;                         // deprecated in C++17, removed in C++20
+    typedef ptrdiff_t difference_type;                   // deprecated in C++17, removed in C++20
+    typedef T*        pointer;                           // deprecated in C++17, removed in C++20
+    typedef const T*  const_pointer;                     // deprecated in C++17, removed in C++20
+    typedef typename add_lvalue_reference<T>::type
+                      reference;                         // deprecated in C++17, removed in C++20
+    typedef typename add_lvalue_reference<const T>::type
+                      const_reference;                   // deprecated in C++17, removed in C++20
+
+    typedef T         value_type;
 
-    template <class U> struct rebind {typedef allocator<U> other;};
+    template <class U> struct rebind {typedef allocator<U> other;}; // deprecated in C++17, removed in C++20
+
+    typedef true_type propagate_on_container_move_assignment;
+    typedef true_type is_always_equal;
 
     constexpr allocator() noexcept;                      // constexpr in C++20
     constexpr allocator(const allocator&) noexcept;      // constexpr in C++20
     template <class U>
       constexpr allocator(const allocator<U>&) noexcept; // constexpr in C++20
     ~allocator();
-    pointer address(reference x) const noexcept;
-    const_pointer address(const_reference x) const noexcept;
-    pointer allocate(size_type, allocator<void>::const_pointer hint = 0);
-    void deallocate(pointer p, size_type n) noexcept;
-    size_type max_size() const noexcept;
+    pointer address(reference x) const noexcept;             // deprecated in C++17, removed in C++20
+    const_pointer address(const_reference x) const noexcept; // deprecated in C++17, removed in C++20
+    T* allocate(size_t n, const void* hint);          // deprecated in C++17, removed in C++20
+    T* allocate(size_t n);
+    void deallocate(T* p, size_t n) noexcept;
+    size_type max_size() const noexcept;              // deprecated in C++17, removed in C++20
     template<class U, class... Args>
-        void construct(U* p, Args&&... args);
+        void construct(U* p, Args&&... args);         // deprecated in C++17, removed in C++20
     template <class U>
-        void destroy(U* p);
+        void destroy(U* p);                           // deprecated in C++17, removed in C++20
 };
 
 template <class T, class U>
 bool operator==(const allocator<T>&, const allocator<U>&) noexcept;
 
 template <class T, class U>
 bool operator!=(const allocator<T>&, const allocator<U>&) noexcept;
 
#else
     return *__value;
 #endif
 }
 
 // addressof moved to <type_traits>
 
 template <class _Tp> class allocator;
 
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
 template <>
-class _LIBCPP_TEMPLATE_VIS allocator<void>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 allocator<void>
 {
 public:
     typedef void*             pointer;
     typedef const void*       const_pointer;
     typedef void              value_type;
 
     template <class _Up> struct rebind {typedef allocator<_Up> other;};
 };
 
 template <>
-class _LIBCPP_TEMPLATE_VIS allocator<const void>
+class _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX17 allocator<const void>
 {
 public:
     typedef const void*       pointer;
     typedef const void*       const_pointer;
     typedef const void        value_type;
 
     template <class _Up> struct rebind {typedef allocator<_Up> other;};
 };
+#endif
 
 // pointer_traits
 
 template <class _Tp, class = void>
 struct __has_element_type : false_type {};
 
 template <class _Tp>
 struct __has_element_type<_Tp,

 };
 
 template <class _Ptr>
 struct __pointer_traits_difference_type<_Ptr, true>
 {
     typedef _LIBCPP_NODEBUG_TYPE typename _Ptr::difference_type type;
 };
 
+template <class _Tp, class _Up, class = void>
+struct __has_rebind : false_type {};
+
 template <class _Tp, class _Up>
-struct __has_rebind
-{
-private:
-    struct __two {char __lx; char __lxx;};
-    template <class _Xp> static __two __test(...);
-    template <class _Xp> static char __test(typename _Xp::template rebind<_Up>* = 0);
-public:
-    static const bool value = sizeof(__test<_Tp>(0)) == 1;
-};
+struct __has_rebind<_Tp, _Up,
+    typename __void_t<typename _Tp::template rebind<_Up> >::type> : true_type {};
 
 template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
 struct __pointer_traits_rebind
 {
 #ifndef _LIBCPP_CXX03_LANG
     typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up> type;
 #else
     typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up>::other type;

 };
 
 template <class _Tp, class _Up, bool = __has_rebind<_Tp, _Up>::value>
 struct __has_rebind_other
 {
 private:
     struct __two {char __lx; char __lxx;};
     template <class _Xp> static __two __test(...);
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
     template <class _Xp> static char __test(typename _Xp::template rebind<_Up>::other* = 0);
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
 public:
     static const bool value = sizeof(__test<_Tp>(0)) == 1;
 };
 
 template <class _Tp, class _Up>
 struct __has_rebind_other<_Tp, _Up, false>
 {
     static const bool value = false;
 };
 
 template <class _Tp, class _Up, bool = __has_rebind_other<_Tp, _Up>::value>
 struct __allocator_traits_rebind
 {
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
     typedef _LIBCPP_NODEBUG_TYPE typename _Tp::template rebind<_Up>::other type;
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
 };
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
 template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, true>
 {
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
     typedef _LIBCPP_NODEBUG_TYPE typename _Alloc<_Tp, _Args...>::template rebind<_Up>::other type;
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
 };
 
 template <template <class, class...> class _Alloc, class _Tp, class ..._Args, class _Up>
 struct __allocator_traits_rebind<_Alloc<_Tp, _Args...>, _Up, false>
 {
     typedef _LIBCPP_NODEBUG_TYPE _Alloc<_Up, _Args...> type;
 };
 

 {
     typedef _Alloc<_Up, _A0, _A1, _A2> type;
 };
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
 #ifndef _LIBCPP_CXX03_LANG
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 auto
 __has_allocate_hint_test(_Alloc&& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
     -> decltype((void)__a.allocate(__sz, __p), true_type());
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 auto
 __has_allocate_hint_test(const _Alloc& __a, _SizeType&& __sz, _ConstVoidPtr&& __p)
     -> false_type;
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 struct __has_allocate_hint
-    : integral_constant<bool,
-        is_same<
-            decltype(_VSTD::__has_allocate_hint_test(declval<_Alloc>(),
+    : decltype(_VSTD::__has_allocate_hint_test(declval<_Alloc>(),
                                                declval<_SizeType>(),
-                                          declval<_ConstVoidPtr>())),
-            true_type>::value>
+                                               declval<_ConstVoidPtr>()))
 {
 };
 
 #else  // _LIBCPP_CXX03_LANG
 
 template <class _Alloc, class _SizeType, class _ConstVoidPtr>
 struct __has_allocate_hint
     : true_type
 {
 };
 
 #endif  // _LIBCPP_CXX03_LANG
 
 #if !defined(_LIBCPP_CXX03_LANG)
 
-template <class _Alloc, class _Tp, class ..._Args>
-decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Tp*>(),
-                                           _VSTD::declval<_Args>()...),
-                                           true_type())
-__has_construct_test(_Alloc&& __a, _Tp* __p, _Args&& ...__args);
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+template <class _Alloc, class _Tp, class... _Args>
+auto
+__has_construct_test(_Alloc&& __a, _Tp* __p, _Args&&... __args)
+    -> decltype(__a.construct(__p, _VSTD::forward<_Args>(__args)...), true_type());
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
 template <class _Alloc, class _Pointer, class ..._Args>
-false_type
-__has_construct_test(const _Alloc& __a, _Pointer&& __p, _Args&& ...__args);
+auto
+__has_construct_test(const _Alloc& __a, _Pointer&& __p, _Args&& ...__args)
+    -> false_type;
 
 template <class _Alloc, class _Pointer, class ..._Args>
 struct __has_construct
-    : integral_constant<bool,
-        is_same<
-            decltype(_VSTD::__has_construct_test(declval<_Alloc>(),
+    : decltype(_VSTD::__has_construct_test(declval<_Alloc>(),
                                            declval<_Pointer>(),
-                                          declval<_Args>()...)),
-            true_type>::value>
+                                           declval<_Args>()...))
 {
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Alloc, class _Pointer>
 auto
 __has_destroy_test(_Alloc&& __a, _Pointer&& __p)
     -> decltype(__a.destroy(__p), true_type());
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
 template <class _Alloc, class _Pointer>
 auto
 __has_destroy_test(const _Alloc& __a, _Pointer&& __p)
     -> false_type;
 
 template <class _Alloc, class _Pointer>
 struct __has_destroy
-    : integral_constant<bool,
-        is_same<
-            decltype(_VSTD::__has_destroy_test(declval<_Alloc>(),
-                                        declval<_Pointer>())),
-            true_type>::value>
+    : decltype(_VSTD::__has_destroy_test(declval<_Alloc>(),
+                                         declval<_Pointer>()))
 {
 };
 
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Alloc>
 auto
 __has_max_size_test(_Alloc&& __a)
     -> decltype(__a.max_size(), true_type());
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 
 template <class _Alloc>
 auto
 __has_max_size_test(const volatile _Alloc& __a)
     -> false_type;
 
 template <class _Alloc>
 struct __has_max_size
-    : integral_constant<bool,
-        is_same<
-            decltype(_VSTD::__has_max_size_test(declval<_Alloc&>())),
-            true_type>::value>
+    : decltype(_VSTD::__has_max_size_test(declval<_Alloc&>()))
 {
 };
 
 template <class _Alloc>
 auto
 __has_select_on_container_copy_construction_test(_Alloc&& __a)
     -> decltype(__a.select_on_container_copy_construction(), true_type());
 
 template <class _Alloc>
 auto
 __has_select_on_container_copy_construction_test(const volatile _Alloc& __a)
     -> false_type;
 
 template <class _Alloc>
 struct __has_select_on_container_copy_construction
-    : integral_constant<bool,
-        is_same<
-            decltype(_VSTD::__has_select_on_container_copy_construction_test(declval<_Alloc&>())),
-            true_type>::value>
+    : decltype(_VSTD::__has_select_on_container_copy_construction_test(declval<_Alloc&>()))
 {
 };
 
 #else  // _LIBCPP_CXX03_LANG
 
 template <class _Alloc, class _Pointer, class _Tp, class = void>
 struct __has_construct : std::false_type {};
 
template <class _Tp>
                 _VSTD::memcpy(__end2, __begin1, _Np * sizeof(_Tp));
         }
 
 private:
 
     _LIBCPP_INLINE_VISIBILITY
     static pointer __allocate(allocator_type& __a, size_type __n,
         const_void_pointer __hint, true_type)
-        {return __a.allocate(__n, __hint);}
+        {
+            _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+            return __a.allocate(__n, __hint);
+            _LIBCPP_SUPPRESS_DEPRECATED_POP
+        }
     _LIBCPP_INLINE_VISIBILITY
     static pointer __allocate(allocator_type& __a, size_type __n,
         const_void_pointer, false_type)
         {return __a.allocate(__n);}
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class _Tp, class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args)
-            {__a.construct(__p, _VSTD::forward<_Args>(__args)...);}
+            {
+                _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+                __a.construct(__p, _VSTD::forward<_Args>(__args)...);
+                _LIBCPP_SUPPRESS_DEPRECATED_POP
+            }
+
     template <class _Tp, class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args)
             {
                 ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
             }
 #else  // _LIBCPP_HAS_NO_VARIADICS
     template <class _Tp, class _A0>
         _LIBCPP_INLINE_VISIBILITY
         static void __construct(true_type, allocator_type& __a, _Tp* __p,
                                 const _A0& __a0)
             {__a.construct(__p, __a0);}
     template <class _Tp, class _A0>
         _LIBCPP_INLINE_VISIBILITY
         static void __construct(false_type, allocator_type&, _Tp* __p,
                                 const _A0& __a0)
             {
                 ::new ((void*)__p) _Tp(__a0);
             }
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         static void __destroy(true_type, allocator_type& __a, _Tp* __p)
-            {__a.destroy(__p);}
+            {
+                _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+                __a.destroy(__p);
+                _LIBCPP_SUPPRESS_DEPRECATED_POP
+            }
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         static void __destroy(false_type, allocator_type&, _Tp* __p)
             {
                 __p->~_Tp();
             }
 
     _LIBCPP_INLINE_VISIBILITY
     static size_type __max_size(true_type, const allocator_type& __a) _NOEXCEPT
-            {return __a.max_size();}
+            {
+                _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+                return __a.max_size();
+                _LIBCPP_SUPPRESS_DEPRECATED_POP
+            }
+
     _LIBCPP_INLINE_VISIBILITY
     static size_type __max_size(false_type, const allocator_type&) _NOEXCEPT
             {return numeric_limits<size_type>::max() / sizeof(value_type);}
 
     _LIBCPP_INLINE_VISIBILITY
     static allocator_type
         __select_on_container_copy_construction(true_type, const allocator_type& __a)
             {return __a.select_on_container_copy_construction();}

 };
 
 // allocator
 
 template <class _Tp>
 class _LIBCPP_TEMPLATE_VIS allocator
 {
 public:
-    typedef size_t            size_type;
-    typedef ptrdiff_t         difference_type;
-    typedef _Tp*              pointer;
-    typedef const _Tp*        const_pointer;
-    typedef _Tp&              reference;
-    typedef const _Tp&        const_reference;
-    typedef _Tp               value_type;
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t     size_type;
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef ptrdiff_t  difference_type;
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp*       pointer;
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef _Tp&       reference;
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference;
+
+    template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;};
+#endif
+
+    typedef _Tp value_type;
 
     typedef true_type propagate_on_container_move_assignment;
     typedef true_type is_always_equal;
 
-    template <class _Up> struct rebind {typedef allocator<_Up> other;};
-
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator() _NOEXCEPT {}
 
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator(const allocator<_Up>&) _NOEXCEPT {}
 
-    _LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const _NOEXCEPT
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
+    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
+    pointer address(reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
-    _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
+    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
+    const_pointer address(const_reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY
-    pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
+#endif
+
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _Tp* allocate(size_t __n)
         {
-        if (__n > max_size())
+        // TODO(mpark): Replace with `allocator_traits<allocator>::max_size(*this)`.
+        if (__n > (size_t(~0) / sizeof(_Tp)))
             __throw_length_error("allocator<T>::allocate(size_t n)"
                                  " 'n' exceeds maximum supported size");
-        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
+        return static_cast<_Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
         }
-    _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT
+
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17
+    _Tp* allocate(size_t __n, const void*) { return allocate(__n); }
+#endif
+
+    _LIBCPP_INLINE_VISIBILITY void deallocate(_Tp* __p, size_t __n) _NOEXCEPT
         {_VSTD::__libcpp_deallocate((void*)__p, __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}
-    _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
+
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
+    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
         {return size_type(~0) / sizeof(_Tp);}
+
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     template <class _Up, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
         void
         construct(_Up* __p, _Args&&... __args)
         {
             ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
         }
 #else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
         _LIBCPP_INLINE_VISIBILITY
         void
# endif  // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
     template <class _A0, class _A1>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, const _A0& __a0, const _A1& __a1)
         {
             ::new((void*)__p) _Tp(__a0, __a1);
         }
 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
-    _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}
+    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}
+#endif
 };
 
 template <class _Tp>
 class _LIBCPP_TEMPLATE_VIS allocator<const _Tp>
 {
 public:
-    typedef size_t            size_type;
-    typedef ptrdiff_t         difference_type;
-    typedef const _Tp*        pointer;
-    typedef const _Tp*        const_pointer;
-    typedef const _Tp&        reference;
-    typedef const _Tp&        const_reference;
-    typedef const _Tp         value_type;
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t     size_type;
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef ptrdiff_t  difference_type;
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* pointer;
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp* const_pointer;
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& reference;
+    _LIBCPP_DEPRECATED_IN_CXX17 typedef const _Tp& const_reference;
+
+    template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;};
+#endif
+
+    typedef const _Tp value_type;
 
     typedef true_type propagate_on_container_move_assignment;
     typedef true_type is_always_equal;
 
-    template <class _Up> struct rebind {typedef allocator<_Up> other;};
-
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator() _NOEXCEPT {}
 
     template <class _Up>
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator(const allocator<_Up>&) _NOEXCEPT {}
 
-    _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
+    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
+    const_pointer address(const_reference __x) const _NOEXCEPT
         {return _VSTD::addressof(__x);}
-    _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
+#endif
+
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY const _Tp* allocate(size_t __n)
     {
-        if (__n > max_size())
+        // TODO(mpark): Replace with `allocator_traits<allocator>::max_size(*this)`.
+        if (__n > (size_t(~0) / sizeof(_Tp)))
             __throw_length_error("allocator<const T>::allocate(size_t n)"
                                  " 'n' exceeds maximum supported size");
-        return static_cast<pointer>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
+        return static_cast<const _Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
     }
-    _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type __n) _NOEXCEPT
+
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
+    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_DEPRECATED_IN_CXX17
+    const _Tp* allocate(size_t __n, const void*) { return allocate(__n); }
+#endif
+
+    _LIBCPP_INLINE_VISIBILITY void deallocate(const _Tp* __p, size_t __n)
         {_VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));}
-    _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
+
+#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
+    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT
         {return size_type(~0) / sizeof(_Tp);}
+
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     template <class _Up, class... _Args>
-        _LIBCPP_INLINE_VISIBILITY
+        _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
         void
         construct(_Up* __p, _Args&&... __args)
         {
             ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
         }
 #else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
         _LIBCPP_INLINE_VISIBILITY
         void
# endif  // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
     template <class _A0, class _A1>
         _LIBCPP_INLINE_VISIBILITY
         void
         construct(pointer __p, const _A0& __a0, const _A1& __a1)
         {
             ::new((void*) const_cast<_Tp *>(__p)) _Tp(__a0, __a1);
         }
 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
-    _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}
+    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY void destroy(pointer __p) {__p->~_Tp();}
+#endif
 };
 
 template <class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;}
 
 template <class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.cxx2a.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>
 
 // allocator:
 // pointer address(reference x) const;
 // const_pointer address(const_reference x) const;
 
+//  In C++20, parts of std::allocator<T> have been removed.
+//  However, for backwards compatibility, if _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+//  is defined before including <memory>, then removed members will be restored.
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+// MODULES_DEFINES: _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
 template <class T>
 void test_address()
 {

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/address.depr_in_cxx17.fail.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>
 
 // allocator:
 // pointer address(reference x) const;
 // const_pointer address(const_reference x) const;
 
-#include <memory>
-#include <cassert>
+// Deprecated in C++17
 
-#include "test_macros.h"
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// REQUIRES: verify-support
 
-template <class T>
-void test_address()
-{
-    T* tp = new T();
-    const T* ctp = tp;
-    const std::allocator<T> a;
-    assert(a.address(*tp) == tp);
-    assert(a.address(*ctp) == tp);
-    delete tp;
-}
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 
-struct A
-{
-    void operator&() const {}
-};
+#include <memory>
+#include "test_macros.h"
 
 int main(int, char**)
 {
-    test_address<int>();
-    test_address<A>();
+  int x = 0;
+  std::allocator<int> a;
+
+  int* p = a.address(x); // expected-error{{'address' is deprecated}}
+  (void)p;
 
   return 0;
 }

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/allocate.cxx2a.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
 // <memory>
 
 // allocator:
-// pointer allocate(size_type n, allocator<void>::const_pointer hint=0);
+// T* allocate(size_t n, const void* hint);
 
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+//  In C++20, parts of std::allocator<T> have been removed.
+//  However, for backwards compatibility, if _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+//  is defined before including <memory>, then removed members will be restored.
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+// MODULES_DEFINES: _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::allocator<int> a;
-    a.allocate(3);          // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
     a.allocate(3, nullptr); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
 
   return 0;
 }

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/allocate.cxx2a.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>
 
 // allocator:
-// pointer allocate(size_type n, allocator<void>::const_pointer hint=0);
+// T* allocate(size_t n, const void* hint);
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+// MODULES_DEFINES: _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
 
 #include <memory>
 #include <cassert>
 #include <cstddef>       // for std::max_align_t
 
 #include "test_macros.h"
 #include "count_new.h"
 

 void test_aligned() {
   typedef AlignedType<Align> T;
   T::constructed = 0;
   globalMemCounter.reset();
   std::allocator<T> a;
   const bool IsOverAlignedType = Align > MaxAligned;
   const bool ExpectAligned = IsOverAlignedType && UsingAlignedNew;
   {
-    assert(globalMemCounter.checkOutstandingNewEq(0));
-    assert(T::constructed == 0);
-    globalMemCounter.last_new_size = 0;
-    globalMemCounter.last_new_align = 0;
-    T* ap = a.allocate(3);
-    DoNotOptimize(ap);
-    assert(globalMemCounter.checkOutstandingNewEq(1));
-    assert(globalMemCounter.checkNewCalledEq(1));
-    assert(globalMemCounter.checkAlignedNewCalledEq(ExpectAligned));
-    assert(globalMemCounter.checkLastNewSizeEq(3 * sizeof(T)));
-    assert(globalMemCounter.checkLastNewAlignEq(ExpectAligned ? Align : 0));
-    assert(T::constructed == 0);
-    globalMemCounter.last_delete_align = 0;
-    a.deallocate(ap, 3);
-    assert(globalMemCounter.checkOutstandingNewEq(0));
-    assert(globalMemCounter.checkDeleteCalledEq(1));
-    assert(globalMemCounter.checkAlignedDeleteCalledEq(ExpectAligned));
-    assert(globalMemCounter.checkLastDeleteAlignEq(ExpectAligned ? Align : 0));
-    assert(T::constructed == 0);
-  }
-  globalMemCounter.reset();
-  {
     globalMemCounter.last_new_size = 0;
     globalMemCounter.last_new_align = 0;
     T* volatile ap2 = a.allocate(11, (const void*)5);
     DoNotOptimize(ap2);
     assert(globalMemCounter.checkOutstandingNewEq(1));
     assert(globalMemCounter.checkNewCalledEq(1));
     assert(globalMemCounter.checkAlignedNewCalledEq(ExpectAligned));
     assert(globalMemCounter.checkLastNewSizeEq(11 * sizeof(T)));

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/allocate.depr_in_cxx17.fail.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>
 
 // allocator:
-// size_type max_size() const throw();
+// T* allocate(size_t n, const void* hint);
 
-#include <memory>
-#include <limits>
-#include <cstddef>
-#include <cassert>
+// Deprecated in C++17
 
-#include "test_macros.h"
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// REQUIERS: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 
-int new_called = 0;
+#include <memory>
+#include "test_macros.h"
 
 int main(int, char**)
 {
-    const std::allocator<int> a;
-    std::size_t M = a.max_size();
-    assert(M > 0xFFFF && M <= (std::numeric_limits<std::size_t>::max() / sizeof(int)));
+    std::allocator<int> a;
+    TEST_IGNORE_NODISCARD a.allocate(3, nullptr); // expected-error {{'allocate' is deprecated}}
 
   return 0;
 }

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/construct.cxx2a.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>
 
 // allocator:
 // template <class... Args> void construct(pointer p, Args&&... args);
 
+//  In C++20, parts of std::allocator<T> have been removed.
+//  However, for backwards compatibility, if _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+//  is defined before including <memory>, then removed members will be restored.
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+// MODULES_DEFINES: _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 #include "count_new.h"
 
 int A_constructed = 0;
 

libcxx/test/libcxx/depr/depr.default.allocator/allocator.members/max_size.cxx2a.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>
 
 // allocator:
 // size_type max_size() const throw();
 
+//  In C++20, parts of std::allocator<T> have been removed.
+//  However, for backwards compatibility, if _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+//  is defined before including <memory>, then removed members will be restored.
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+// MODULES_DEFINES: _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <limits>
 #include <cstddef>
 #include <cassert>
 
 #include "test_macros.h"
 
 int new_called = 0;

libcxx/test/libcxx/depr/depr.default.allocator/allocator_types.cxx2a.pass.cpp

 // {
 // public:
 //     typedef size_t                                size_type;
 //     typedef ptrdiff_t                             difference_type;
 //     typedef T*                                    pointer;
 //     typedef const T*                              const_pointer;
 //     typedef typename add_lvalue_reference<T>::type       reference;
 //     typedef typename add_lvalue_reference<const T>::type const_reference;
-//     typedef T                                     value_type;
-//     typedef true_type                             is_always_equal;
 //
 //     template <class U> struct rebind {typedef allocator<U> other;};
 // ...
 // };
 
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+// MODULES_DEFINES: _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <type_traits>
 #include <cstddef>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     static_assert((std::is_same<std::allocator<char>::size_type, std::size_t>::value), "");
     static_assert((std::is_same<std::allocator<char>::difference_type, std::ptrdiff_t>::value), "");
     static_assert((std::is_same<std::allocator<char>::pointer, char*>::value), "");
     static_assert((std::is_same<std::allocator<char>::const_pointer, const char*>::value), "");
-    static_assert((std::is_same<std::allocator<char>::value_type, char>::value), "");
     static_assert((std::is_same<std::allocator<char>::reference, char&>::value), "");
     static_assert((std::is_same<std::allocator<char>::const_reference, const char&>::value), "");
     static_assert((std::is_same<std::allocator<char>::rebind<int>::other,
                                 std::allocator<int> >::value), "");
 
-    static_assert((std::is_same<std::allocator<      char>::is_always_equal, std::true_type>::value), "");
-    LIBCPP_STATIC_ASSERT((std::is_same<std::allocator<const char>::is_always_equal, std::true_type>::value), "");
-
-    std::allocator<char> a;
-    std::allocator<char> a2 = a;
-    a2 = a;
-    std::allocator<int> a3 = a2;
-    ((void)a3);
-
   return 0;
 }

libcxx/test/libcxx/depr/depr.default.allocator/allocator_types.depr_in_cxx17.fail.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>
+
+// check nested types:
+
+// template <class T>
+// class allocator
+// {
+// public:
+//     typedef size_t                                size_type;
+//     typedef ptrdiff_t                             difference_type;
+//     typedef T*                                    pointer;
+//     typedef const T*                              const_pointer;
+//     typedef typename add_lvalue_reference<T>::type       reference;
+//     typedef typename add_lvalue_reference<const T>::type const_reference;
+//
+//     template <class U> struct rebind {typedef allocator<U> other;};
+// ...
+// };
+
+// Deprecated in C++17
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// REQUIRES: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+
+#include <memory>
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    typedef std::allocator<char>::size_type AST;          // expected-error{{'size_type' is deprecated}}
+    typedef std::allocator<char>::difference_type ADT;    // expected-error{{'difference_type' is deprecated}}
+    typedef std::allocator<char>::pointer AP;             // expected-error{{'pointer' is deprecated}}
+    typedef std::allocator<char>::const_pointer ACP;      // expected-error{{'const_pointer' is deprecated}}
+    typedef std::allocator<char>::reference AR;           // expected-error{{'reference' is deprecated}}
+    typedef std::allocator<char>::const_reference ACR;    // expected-error{{'const_reference' is deprecated}}
+    typedef std::allocator<char>::rebind<int>::other ARO; // expected-error{{'rebind<int>' is deprecated}}
+
+  return 0;
+}

libcxx/test/libcxx/depr/depr.default.allocator/allocator_void.cxx2a.pass.cpp

 // public:
 //     typedef void*                                 pointer;
 //     typedef const void*                           const_pointer;
 //     typedef void                                  value_type;
 //
 //     template <class _Up> struct rebind {typedef allocator<_Up> other;};
 // };
 
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+// MODULES_DEFINES: _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <memory>
 #include <type_traits>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     static_assert((std::is_same<std::allocator<void>::pointer, void*>::value), "");

libcxx/test/libcxx/depr/depr.default.allocator/allocator_void.depr_in_cxx17.fail.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 allocator<void>
 // {
 // public:
 //     typedef void*                                 pointer;
 //     typedef const void*                           const_pointer;
 //     typedef void                                  value_type;
 //
 //     template <class _Up> struct rebind {typedef allocator<_Up> other;};
 // };
+//
+// Deprecated in C++17
 
-#include <memory>
-#include <type_traits>
+// UNSUPPORTED: c++98, c++03, c++11, c++14
+// REQUIRES: verify-support
+
+// MODULES_DEFINES: _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
 
+#include <memory>
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    static_assert((std::is_same<std::allocator<void>::pointer, void*>::value), "");
-    static_assert((std::is_same<std::allocator<void>::const_pointer, const void*>::value), "");
-    static_assert((std::is_same<std::allocator<void>::value_type, void>::value), "");
-    static_assert((std::is_same<std::allocator<void>::rebind<int>::other,
-                                std::allocator<int> >::value), "");
-    std::allocator<void> a;
-    std::allocator<void> a2 = a;
-    a2 = a;
+    typedef std::allocator<void>::pointer AP;             // expected-error{{'allocator<void>' is deprecated}}
+    typedef std::allocator<void>::const_pointer ACP;      // expected-error{{'allocator<void>' is deprecated}}
+    typedef std::allocator<void>::rebind<int>::other ARO; // expected-error{{'allocator<void>' is deprecated}}
 
   return 0;
 }

libcxx/test/libcxx/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.fail.cpp

// expected-error@tuple:* 0+ {{reference member '__value_' binds to a temporary object whose lifetime would be shorter than the lifetime of the constructed object}}
     ConvertsTo<int> ct;
     std::tuple<int const&, void*> t(ct, nullptr); // expected-note {{requested here}}
   }
   {
     ConvertsTo<Derived> ct;
     std::tuple<Base const&, int> t(ct, 42); // expected-note {{requested here}}
   }
   {
-    std::allocator<void> alloc;
+    std::allocator<int> alloc;
     std::tuple<std::string &&> t2("hello"); // expected-note {{requested here}}
     std::tuple<std::string &&> t3(std::allocator_arg, alloc, "hello"); // expected-note {{requested here}}
   }
 #else
 #error force failure
 // expected-error@-1 {{force failure}}
 #endif
 
   return 0;
 }

libcxx/test/std/containers/sequences/deque/types.pass.cpp

 //     typedef typename allocator_type::size_type       size_type;
 //     typedef typename allocator_type::difference_type difference_type;
 //     typedef typename allocator_type::pointer         pointer;
 //     typedef typename allocator_type::const_pointer   const_pointer;
 //     typedef std::reverse_iterator<iterator>          reverse_iterator;
 //     typedef std::reverse_iterator<const_iterator>    const_reverse_iterator;
 // };
 
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <deque>
 #include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "../../Copyable.h"
 #include "min_allocator.h"

libcxx/test/std/containers/sequences/list/types.pass.cpp

 //     // types:
 //     typedef T value_type;
 //     typedef Alloc allocator_type;
 //     typedef typename allocator_type::reference reference;
 //     typedef typename allocator_type::const_reference const_reference;
 //     typedef typename allocator_type::pointer pointer;
 //     typedef typename allocator_type::const_pointer const_pointer;
 
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <list>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "min_allocator.h"
 
 struct A { std::list<A> v; }; // incomplete type support
 

libcxx/test/std/containers/sequences/vector/types.pass.cpp

 //     typedef typename allocator_type::size_type       size_type;
 //     typedef typename allocator_type::difference_type difference_type;
 //     typedef typename allocator_type::pointer         pointer;
 //     typedef typename allocator_type::const_pointer   const_pointer;
 //     typedef std::reverse_iterator<iterator>          reverse_iterator;
 //     typedef std::reverse_iterator<const_iterator>    const_reverse_iterator;
 // };
 
+#define _LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS
+#define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <vector>
 #include <iterator>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_allocator.h"
 #include "../../Copyable.h"
 #include "min_allocator.h"

libcxx/test/std/experimental/memory/memory.resource.adaptor/memory.resource.adaptor.overview/overview.pass.cpp

 #include <cassert>
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::pmr;
 
 int main(int, char**)
 {
-    typedef ex::resource_adaptor<std::allocator<void>> R;
+    typedef ex::resource_adaptor<std::allocator<int>> R;
     typedef ex::resource_adaptor<std::allocator<long>> R2;
     static_assert(std::is_same<R, R2>::value, "");
     {
         static_assert(std::is_base_of<ex::memory_resource, R>::value, "");
         static_assert(std::is_same<R::allocator_type, std::allocator<char>>::value, "");
     }
     {
         static_assert(std::is_default_constructible<R>::value, "");
         static_assert(std::is_copy_constructible<R>::value, "");
         static_assert(std::is_move_constructible<R>::value, "");
         static_assert(std::is_copy_assignable<R>::value, "");
         static_assert(std::is_move_assignable<R>::value, "");
    }
 
   return 0;
 }

libcxx/test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp

assert(globalMemCounter.checkOutstandingNewEq(0));
         DisableAllocationGuard g;
         using Ref = std::reference_wrapper<A>;
         A a;
         Ref aref(a);
         std::function<int(int)> f(aref);
         assert(A::count == 1);
         assert(f.target<A>() == nullptr);
         assert(f.target<Ref>());
-        std::function<int(int)> f2(std::allocator_arg, std::allocator<void>{},
+        std::function<int(int)> f2(std::allocator_arg, std::allocator<int>{},
                                    std::move(f));
         assert(A::count == 1);
         assert(f2.target<A>() == nullptr);
         assert(f2.target<Ref>());
         assert(f.target<Ref>()); // f is unchanged because the target is small
     }
     {
         // Test that moving a function constructed from a function pointer
         // is done without allocating
         DisableAllocationGuard guard;
         using Ptr = int(*)(int);
         Ptr p = g;
         std::function<int(int)> f(p);
         assert(f.target<A>() == nullptr);
         assert(f.target<Ptr>());
-        std::function<int(int)> f2(std::allocator_arg, std::allocator<void>(),
+        std::function<int(int)> f2(std::allocator_arg, std::allocator<int>(),
                                    std::move(f));
         assert(f2.target<A>() == nullptr);
         assert(f2.target<Ptr>());
         assert(f.target<Ptr>()); // f is unchanged because the target is small
     }
 
   return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.fail.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+
 // <memory>
 
 // allocator:
-// pointer allocate(size_type n, allocator<void>::const_pointer hint=0);
-
-// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
-// UNSUPPORTED: clang-3.3, clang-3.4, clang-3.5, clang-3.6, clang-3.7, clang-3.8
+// T* allocate(size_t n);
 
 #include <memory>
 #include <cassert>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
     std::allocator<int> a;
     a.allocate(3);          // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
-    a.allocate(3, nullptr); // expected-error {{ignoring return value of function declared with 'nodiscard' attribute}}
 
   return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // <memory>
 
 // allocator:
-// pointer allocate(size_type n, allocator<void>::const_pointer hint=0);
+// T* allocate(size_t n);
 
 #include <memory>
 #include <cassert>
 #include <cstddef>       // for std::max_align_t
 
 #include "test_macros.h"
 #include "count_new.h"
 
const bool ExpectAligned = IsOverAlignedType && UsingAlignedNew;
     globalMemCounter.last_delete_align = 0;
     a.deallocate(ap, 3);
     assert(globalMemCounter.checkOutstandingNewEq(0));
     assert(globalMemCounter.checkDeleteCalledEq(1));
     assert(globalMemCounter.checkAlignedDeleteCalledEq(ExpectAligned));
     assert(globalMemCounter.checkLastDeleteAlignEq(ExpectAligned ? Align : 0));
     assert(T::constructed == 0);
   }
-  globalMemCounter.reset();
-  {
-    globalMemCounter.last_new_size = 0;
-    globalMemCounter.last_new_align = 0;
-    T* volatile ap2 = a.allocate(11, (const void*)5);
-    DoNotOptimize(ap2);
-    assert(globalMemCounter.checkOutstandingNewEq(1));
-    assert(globalMemCounter.checkNewCalledEq(1));
-    assert(globalMemCounter.checkAlignedNewCalledEq(ExpectAligned));
-    assert(globalMemCounter.checkLastNewSizeEq(11 * sizeof(T)));
-    assert(globalMemCounter.checkLastNewAlignEq(ExpectAligned ? Align : 0));
-    assert(T::constructed == 0);
-    globalMemCounter.last_delete_align = 0;
-    a.deallocate(ap2, 11);
-    DoNotOptimize(ap2);
-    assert(globalMemCounter.checkOutstandingNewEq(0));
-    assert(globalMemCounter.checkDeleteCalledEq(1));
-    assert(globalMemCounter.checkAlignedDeleteCalledEq(ExpectAligned));
-    assert(globalMemCounter.checkLastDeleteAlignEq(ExpectAligned ? Align : 0));
-    assert(T::constructed == 0);
-  }
 }
 
 int main(int, char**) {
     test_aligned<1>();
     test_aligned<2>();
     test_aligned<4>();
     test_aligned<8>();
     test_aligned<16>();
     test_aligned<MaxAligned>();
     test_aligned<OverAligned>();
     test_aligned<OverAligned * 2>();
 
   return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator.members/allocate.size.pass.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 // UNSUPPORTED: libcpp-no-exceptions
 // <memory>
 
 // allocator:
-// pointer allocate(size_type n, allocator<void>::const_pointer hint=0);
+// T* allocate(size_t n);
 
 // When back-deploying to macosx10.7, the RTTI for exception classes
 // incorrectly provided by libc++.dylib is mixed with the one in
 // libc++abi.dylib and exceptions are not caught properly.
 // XFAIL: with_system_cxx_lib=macosx10.7
 
 #include <memory>
 #include <cassert>
void test_max(size_t count)
     } catch (const std::exception &) {
     }
 }
 
 template <typename T>
 void test()
 {
     // Bug 26812 -- allocating too large
-    std::allocator<T> a;
-    test_max<T> (a.max_size() + 1);                // just barely too large
-    test_max<T> (a.max_size() * 2);                // significantly too large
+    typedef std::allocator<T> A;
+    typedef std::allocator_traits<A> AT;
+    A a;
+    test_max<T> (AT::max_size(a) + 1);             // just barely too large
+    test_max<T> (AT::max_size(a) * 2);             // significantly too large
     test_max<T> (((size_t) -1) / sizeof(T) + 1);   // multiply will overflow
     test_max<T> ((size_t) -1);                     // way too large
 }
 
 int main(int, char**)
 {
     test<double>();
     LIBCPP_ONLY(test<const double>());
 
   return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator_types.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>
 
 // check nested types:
 
 // template <class T>
 // class allocator
 // {
 // public:
-//     typedef size_t                                size_type;
-//     typedef ptrdiff_t                             difference_type;
-//     typedef T*                                    pointer;
-//     typedef const T*                              const_pointer;
-//     typedef typename add_lvalue_reference<T>::type       reference;
-//     typedef typename add_lvalue_reference<const T>::type const_reference;
-//     typedef T                                     value_type;
-//     typedef true_type                             is_always_equal;
+//     typedef T         value_type;
 //
-//     template <class U> struct rebind {typedef allocator<U> other;};
+//     typedef true_type propagate_on_container_move_assignment;
+//     typedef true_type is_always_equal;
 // ...
 // };
 
 #include <memory>
 #include <type_traits>
 #include <cstddef>
 
 #include "test_macros.h"
 
 int main(int, char**)
 {
-    static_assert((std::is_same<std::allocator<char>::size_type, std::size_t>::value), "");
-    static_assert((std::is_same<std::allocator<char>::difference_type, std::ptrdiff_t>::value), "");
-    static_assert((std::is_same<std::allocator<char>::pointer, char*>::value), "");
-    static_assert((std::is_same<std::allocator<char>::const_pointer, const char*>::value), "");
     static_assert((std::is_same<std::allocator<char>::value_type, char>::value), "");
-    static_assert((std::is_same<std::allocator<char>::reference, char&>::value), "");
-    static_assert((std::is_same<std::allocator<char>::const_reference, const char&>::value), "");
-    static_assert((std::is_same<std::allocator<char>::rebind<int>::other,
-                                std::allocator<int> >::value), "");
+
+    static_assert((std::is_same<std::allocator<char>::propagate_on_container_move_assignment, std::true_type>::value), "");
+    LIBCPP_STATIC_ASSERT((std::is_same<std::allocator<const char>::propagate_on_container_move_assignment, std::true_type>::value), "");
 
-    static_assert((std::is_same<std::allocator<      char>::is_always_equal, std::true_type>::value), "");
+    static_assert((std::is_same<std::allocator<char>::is_always_equal, std::true_type>::value), "");
     LIBCPP_STATIC_ASSERT((std::is_same<std::allocator<const char>::is_always_equal, std::true_type>::value), "");
 
     std::allocator<char> a;
     std::allocator<char> a2 = a;
     a2 = a;
     std::allocator<int> a3 = a2;
     ((void)a3);
 
   return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR20855_tuple_ref_binding_diagnostics.pass.cpp

void compile_tests() {
   }
   {
     ConvertsTo<int&> ct;
     std::tuple<int, int&> t(42, ct);
   }
 }
 
 void allocator_tests() {
-    std::allocator<void> alloc;
+    std::allocator<int> alloc;
     int x = 42;
     {
         std::tuple<int&> t(std::ref(x));
         assert(&std::get<0>(t) == &x);
         std::tuple<int&> t1(std::allocator_arg, alloc, std::ref(x));
         assert(&std::get<0>(t1) == &x);
     }
     {

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/PR23256_constrain_UTypes_ctor.pass.cpp

typedef ExplicitUnconstrainedCtor ExplicitA;
         static_assert(std::is_copy_constructible<std::tuple<A>>::value, "");
         static_assert(std::is_move_constructible<std::tuple<A>>::value, "");
         static_assert(std::is_copy_constructible<std::tuple<ExplicitA>>::value, "");
         static_assert(std::is_move_constructible<std::tuple<ExplicitA>>::value, "");
     }
     {
         static_assert(std::is_constructible<
             std::tuple<A>,
-            std::allocator_arg_t, std::allocator<void>,
+            std::allocator_arg_t, std::allocator<int>,
             std::tuple<A> const&
         >::value, "");
         static_assert(std::is_constructible<
             std::tuple<A>,
-            std::allocator_arg_t, std::allocator<void>,
+            std::allocator_arg_t, std::allocator<int>,
             std::tuple<A> &&
         >::value, "");
         static_assert(std::is_constructible<
             std::tuple<ExplicitA>,
-            std::allocator_arg_t, std::allocator<void>,
+            std::allocator_arg_t, std::allocator<int>,
             std::tuple<ExplicitA> const&
         >::value, "");
         static_assert(std::is_constructible<
             std::tuple<ExplicitA>,
-            std::allocator_arg_t, std::allocator<void>,
+            std::allocator_arg_t, std::allocator<int>,
             std::tuple<ExplicitA> &&
         >::value, "");
     }
     {
         std::tuple<A&&> t(std::forward_as_tuple(A{}));
         ((void)t);
         std::tuple<ExplicitA&&> t2(std::forward_as_tuple(ExplicitA{}));
         ((void)t2);
     }
 
   return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_UTypes.pass.cpp

 struct Explicit {
   int value;
   explicit Explicit(int x) : value(x) {}
 };
 
 int main(int, char**)
 {
     {
-        std::tuple<Explicit> t{std::allocator_arg, std::allocator<void>{}, 42};
+        std::tuple<Explicit> t{std::allocator_arg, std::allocator<int>{}, 42};
         assert(std::get<0>(t).value == 42);
     }
     {
         std::tuple<MoveOnly> t(std::allocator_arg, A1<int>(), MoveOnly(0));
         assert(std::get<0>(t) == 0);
     }
     {
         using T = DefaultCtorBlowsUp<>;

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.fail.cpp

 
 struct ExplicitCopy {
   explicit ExplicitCopy(ExplicitCopy const&) {}
   explicit ExplicitCopy(int) {}
 };
 
 std::tuple<ExplicitCopy> const_explicit_copy_test() {
     const ExplicitCopy e(42);
-    return {std::allocator_arg, std::allocator<void>{}, e};
+    return {std::allocator_arg, std::allocator<int>{}, e};
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
 
 std::tuple<ExplicitCopy> non_const_explicity_copy_test() {
     ExplicitCopy e(42);
-    return {std::allocator_arg, std::allocator<void>{}, e};
+    return {std::allocator_arg, std::allocator<int>{}, e};
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
 int main(int, char**)
 {
     const_explicit_copy_test();
     non_const_explicity_copy_test();
 
   return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_const_Types.pass.cpp

struct ImplicitCopy {
   explicit ImplicitCopy(int) {}
   ImplicitCopy(ImplicitCopy const&) {}
 };
 
 // Test that tuple(std::allocator_arg, Alloc, Types const&...) allows implicit
 // copy conversions in return value expressions.
 std::tuple<ImplicitCopy> testImplicitCopy1() {
     ImplicitCopy i(42);
-    return {std::allocator_arg, std::allocator<void>{}, i};
+    return {std::allocator_arg, std::allocator<int>{}, i};
 }
 
 std::tuple<ImplicitCopy> testImplicitCopy2() {
     const ImplicitCopy i(42);
-    return {std::allocator_arg, std::allocator<void>{}, i};
+    return {std::allocator_arg, std::allocator<int>{}, i};
 }
 
 int main(int, char**)
 {
     {
         // check that the literal '0' can implicitly initialize a stored pointer.
-        std::tuple<int*> t = {std::allocator_arg, std::allocator<void>{}, 0};
+        std::tuple<int*> t = {std::allocator_arg, std::allocator<int>{}, 0};
     }
     {
         std::tuple<int> t(std::allocator_arg, A1<int>(), 3);
         assert(std::get<0>(t) == 3);
     }
     {
         assert(!alloc_first::allocator_constructed);
         std::tuple<alloc_first> t(std::allocator_arg, A1<int>(5), alloc_first(3));

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.fail.cpp

 struct ExplicitCopy {
   explicit ExplicitCopy(int) {}
   explicit ExplicitCopy(ExplicitCopy const&) {}
 
 };
 
 std::tuple<ExplicitCopy> const_explicit_copy_test() {
     const std::tuple<int> t1(42);
-    return {std::allocator_arg, std::allocator<void>{}, t1};
+    return {std::allocator_arg, std::allocator<int>{}, t1};
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
 
 std::tuple<ExplicitCopy> non_const_explicit_copy_test() {
     std::tuple<int> t1(42);
-    return {std::allocator_arg, std::allocator<void>{}, t1};
+    return {std::allocator_arg, std::allocator<int>{}, t1};
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
 
 int main(int, char**)
 {
 
 
   return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_copy.pass.cpp

int main(int, char**)
         assert(alloc_first::allocator_constructed);
         assert(alloc_last::allocator_constructed);
         assert(std::get<0>(t1) == 1);
         assert(std::get<1>(t1) == 2);
         assert(std::get<2>(t1) == 3);
     }
     {
         const std::tuple<int> t1(42);
-        std::tuple<Explicit> t2{std::allocator_arg, std::allocator<void>{},  t1};
+        std::tuple<Explicit> t2{std::allocator_arg, std::allocator<int>{},  t1};
         assert(std::get<0>(t2).value == 42);
     }
     {
         const std::tuple<int> t1(42);
-        std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<void>{}, t1};
+        std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<int>{}, t1};
         assert(std::get<0>(t2).value == 42);
     }
 
   return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.fail.cpp

 
 struct ExplicitCopy {
   explicit ExplicitCopy(int) {}
   explicit ExplicitCopy(ExplicitCopy const&) {}
 };
 
 std::tuple<ExplicitCopy> explicit_move_test() {
     std::tuple<int> t1(42);
-    return {std::allocator_arg, std::allocator<void>{}, std::move(t1)};
+    return {std::allocator_arg, std::allocator<int>{}, std::move(t1)};
     // expected-error@-1 {{chosen constructor is explicit in copy-initialization}}
 }
 
 int main(int, char**)
 {
 
 
   return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/alloc_convert_move.pass.cpp

int main(int, char**)
         assert(alloc_first::allocator_constructed);
         assert(alloc_last::allocator_constructed);
         assert(std::get<0>(t1) == 1);
         assert(std::get<1>(t1) == 2);
         assert(std::get<2>(t1)->id_ == 3);
     }
     {
         std::tuple<int> t1(42);
-        std::tuple<Explicit> t2{std::allocator_arg, std::allocator<void>{}, std::move(t1)};
+        std::tuple<Explicit> t2{std::allocator_arg, std::allocator<int>{}, std::move(t1)};
         assert(std::get<0>(t2).value == 42);
     }
     {
         std::tuple<int> t1(42);
-        std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<void>{}, std::move(t1)};
+        std::tuple<Implicit> t2 = {std::allocator_arg, std::allocator<int>{}, std::move(t1)};
         assert(std::get<0>(t2).value == 42);
     }
 
   return 0;
 }

libcxx/test/std/utilities/tuple/tuple.tuple/tuple.cnstr/move.pass.cpp

struct move_only_large final {
   move_only_large() : value(42) {}
   move_only_large(move_only_large&&) = default;
   int value;
 };
 
 template <class Elem>
 void test_sfinae() {
     using Tup = std::tuple<Elem>;
-    using Alloc = std::allocator<void>;
+    using Alloc = std::allocator<int>;
     using Tag = std::allocator_arg_t;
     // special members
     {
         static_assert(std::is_default_constructible<Tup>::value, "");
         static_assert(std::is_move_constructible<Tup>::value, "");
         static_assert(!std::is_copy_constructible<Tup>::value, "");
         static_assert(!std::is_constructible<Tup, Tup&>::value, "");
     }