[libc++] Remove extension to support allocator<const T>

[ldionne]

Summary

This extension is a portability trap for users, since no other standard
library supports it. Furthermore, the Standard explicitly allows
implementations to reject std::allocator<cv T>, so allowing it is
really going against the current.

This was discovered in D120684: this extension required const_casting
in __construct_range_forward, a fishy bit of code that can be removed
if we don't support the extension anymore.

This is a re-application of dbc647643577, which was reverted in 9138666f5
because it broke std::shared_ptr<T const>. Tests have now been added and
we've made sure that std::shared_ptr<T const> wouldn't be broken in this
version.

[jloser]

LGTM!

[• Quuxplusone]

libcxx/docs/ReleaseNotes.rst

69–72

I think this buries the lede a little bit. I'd say more like

- libc++ no longer supports containers of ``const``-qualified element type,
  such as ``vector<const T>`` and ``list<const T>``. This used to be supported
  as an extension. Likewise, ``std::allocator<const T>`` is no longer supported.
  If you were using ``vector<const T>``, replace it with ``vector<T>`` instead.

I actually wonder whether this change matters to list<const T>, since it's a node-based container. Should you add libcxx/test/libcxx/.../const_element_type.verify.cpp tests that check what happens with const-qualified element types? If list<const T> and set<const T> still work in practice, should we continue kinda-sorta-supporting them, and document here that vector and deque are the only two containers that have been de-supported?

[ldionne]

Address comments and fix CI.

[• Quuxplusone]

This is the sort of thing to alert libc++-vendors about, right?

libcxx/include/__memory/allocator.h

73–74

Nit: Maybe swap these lines to alphabetize them? (also to put the shorter and more common cv-qualifier first)

libcxx/include/__memory/shared_ptr.h

291–293

Pre-existing: Why do we rebind the allocator at all? construct is supposed to work on any allocator in the same family, isn't it? (IIRC, it deduces the type-to-construct from the pointer type of __get_elem(), not from the type of __tmp.) Is this a QoI thing, or just "historical reasons"?

[ldionne]

libcxx/docs/ReleaseNotes.rst

69–72

[Sorry, it seems I didn't publish this reply the first time around]

I had to remove one instance of list<const T> in the tests because it broke, so I guess it means it doesn't work anymore either. Which makes sense, since std::allocator<const T> is not supposed to work, period. So regardless of the fact that std::list will rebind the allocator to the node type, you're still technically mentioning std::allocator<const T>, and so it's not valid.

I will reword the release note.

libcxx/include/__memory/shared_ptr.h

291–293

I'm not sure I understand. allocator_traits<>::construct(alloc, ptr, args...) will call alloc.construct(ptr, args...), and that requires ptr to be of type alloc.value_type [sic], doesn't it?

[• Quuxplusone]

libcxx/include/__memory/shared_ptr.h

291–293

No, ptr is of type T*, where T is deduced independently:
https://en.cppreference.com/w/cpp/memory/allocator_traits/construct
allocate/deallocate are value_type-dependent, but construct/destroy are heterogeneous. Yes this makes no sense, but it's how it has always been. (I assume there was an original bad rationale related to node-based containers.)

[ldionne]

libcxx/include/__memory/shared_ptr.h

291–293

Hmm, I guess you're right. However, prior to C++11, std::allocator did use pointer instead of T*: https://en.cppreference.com/w/cpp/memory/allocator/construct

I suspect that is why it's like that. I'd be tempted to leave it as-is, at least in this patch. I can try to change it in a separate patch if you're curious.

[phosek]

After this change, gtest version that's used in LLVM is failing to build with:

In file included from /b/s/w/ir/x/w/llvm-llvm-project/llvm/utils/unittest/googletest/include/gtest/gtest.h:56:
In file included from /b/s/w/ir/x/w/staging/llvm_build/./bin/../include/c++/v1/memory:810:
/b/s/w/ir/x/w/staging/llvm_build/./bin/../include/c++/v1/__memory/allocator.h:72:5: error: static_assert failed due to requirement '!is_const<const testing::MatcherInterface<const std::string &>>::value' "std::allocator does not support const types"
    static_assert(!is_const<_Tp>::value, "std::allocator does not support const types");
    ^             ~~~~~~~~~~~~~~~~~~~~~

That broke compiler-rt runtimes whose tests use gtest: memprof, orc.

You can see the full log here: https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket/8820315548532839729/+/u/clang/build/stdout

[ldionne]

In D120996#3365559, @phosek wrote:

After this change, gtest version that's used in LLVM is failing to build with:

In file included from /b/s/w/ir/x/w/llvm-llvm-project/llvm/utils/unittest/googletest/include/gtest/gtest.h:56:
In file included from /b/s/w/ir/x/w/staging/llvm_build/./bin/../include/c++/v1/memory:810:
/b/s/w/ir/x/w/staging/llvm_build/./bin/../include/c++/v1/__memory/allocator.h:72:5: error: static_assert failed due to requirement '!is_const<const testing::MatcherInterface<const std::string &>>::value' "std::allocator does not support const types"
    static_assert(!is_const<_Tp>::value, "std::allocator does not support const types");
    ^             ~~~~~~~~~~~~~~~~~~~~~

That broke compiler-rt runtimes whose tests use gtest: memprof, orc.

You can see the full log here: https://logs.chromium.org/logs/fuchsia/buildbucket/cr-buildbucket/8820315548532839729/+/u/clang/build/stdout

Thanks for the heads up. I'll need to add more tests for std::shared_ptr<T const>, it seems.

[ldionne]

Add tests for std::shared_ptr and fix issues.

[• Quuxplusone]

libcxx/include/__memory/shared_ptr.h

285

AFAICT, we never used to instantiate TheUsersAllocator<_Tp> in pre-C++20 modes; this diff makes us instantiate that type. Pathological user-defined allocators might explode at that, so we might want to avoid the instantiation as a QoI issue. However, given that

• we already instantiate that type in C++20, so this is just front-loading the pain (if any),
• hopefully you'll quickly do a followup PR to eliminate the instantiation of _TpAlloc entirely,

I think this is fine.

291–293

However, prior to C++11, std::allocator did use pointer instead of T*

Ah. Well, that's definitely a good enough reason in C++03 codepaths, then... but this codepath is under _LIBCPP_STD_VER > 17! So yeah, I think it would be nice to change (and don't object to making that a separate PR if that's what you want).

[ldionne]

I'll try landing this again now, since CI is green and I've added tests + fixed the issues reported by @phosek.

libcxx/include/__memory/shared_ptr.h

291–293

Alright, will do.

[rnk]

In D120996#3362137, @Quuxplusone wrote:

This is the sort of thing to alert libc++-vendors about, right?

It seems this change is already causing problems for us. Google aims to uptake new versions of libc++ often. To support that, we are constantly testing new LLVM and libc++ versions ~daily. With this change, we can't continue testing new LLVM and libc++ versions. I estimate that it could take us a week to migrate our code, but that's a pretty soft estimate, I am not a domain expert. I would like to avoid a week long gap in our testing. Would you consider delaying this, setting up an opt-out configuration macro, or some other mitigation strategy to allow vendors to handle this transition gracefully?

[ldionne]

In D120996#3370437, @rnk wrote:

In D120996#3362137, @Quuxplusone wrote:

This is the sort of thing to alert libc++-vendors about, right?

It seems this change is already causing problems for us. Google aims to uptake new versions of libc++ often. To support that, we are constantly testing new LLVM and libc++ versions ~daily. With this change, we can't continue testing new LLVM and libc++ versions. I estimate that it could take us a week to migrate our code, but that's a pretty soft estimate, I am not a domain expert. I would like to avoid a week long gap in our testing. Would you consider delaying this, setting up an opt-out configuration macro, or some other mitigation strategy to allow vendors to handle this transition gracefully?

Yes. I've been in touch with @EricWF about this. I did not expect this to cause so much trouble. I think we definitely want to make this change in the mid/long term, however we should also make breaking changes in a friendly way whenever possible. I will revert this for now and I'll propose a softer approach (probably with a escape hatch) soon.

[MaskRay]

Thanks for giving a transition period:) We are actively working on the migration.

The good news is that std::allocator<const is extremely rare. The breakage mostly comes from container usage like: [[ https://codesearch.debian.net/search?q=std%3A%3Avector%3Cconst%5B+%5D%2B%5Cw%2B%28%3C%5B%5E%3E*%5D%2B%3E%5B+%5D*%29%3F%3E&literal=0 | std::vector<const[ ]+\w+(<[^>*]+>[ ]*)?> ]], which is rare as well because https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48101 libstdc++ since 8.0 has static_assert with diagnostics like error: static assertion failed: std::vector must have a non-const, non-volatile value_type (deque/forward_list/list/multiset/set are similar)

libcxx/docs/ReleaseNotes.rst

 
 - The integer distributions ``binomial_distribution``, ``discrete_distribution``,
   ``geometric_distribution``, ``negative_binomial_distribution``, ``poisson_distribution``,
   and ``uniform_int_distribution`` now conform to the Standard by rejecting
   template parameter types other than ``short``, ``int``, ``long``, ``long long``,
   (as an extension) ``__int128_t``, and the unsigned versions thereof.
   In particular, ``uniform_int_distribution<int8_t>`` is no longer supported.
 
 - The C++14 function ``std::quoted(const char*)`` is no longer supported in
   C++03 or C++11 modes.
 
+- libc++ no longer supports containers of ``const``-qualified element type,
+  such as ``vector<const T>`` and ``list<const T>``. This used to be supported
+  as an extension. Likewise, ``std::allocator<const T>`` is no longer supported.
+  If you were using ``vector<const T>``, replace it with ``vector<T>`` instead.
+
 ABI Changes
 -----------
 
 - The ``_LIBCPP_ABI_USE_CXX03_NULLPTR_EMULATION`` macro controlling whether we use an
   emulation for ``std::nullptr_t`` in C++03 mode has been removed. After this change,
   ``_LIBCPP_ABI_USE_CXX03_NULLPTR_EMULATION`` will not be honoured anymore and there
   will be no way to opt back into the C++03 emulation of ``std::nullptr_t``.
 

libcxx/include/__memory/allocator.h

 {
 public:
     _LIBCPP_DEPRECATED_IN_CXX17 typedef void*             pointer;
     _LIBCPP_DEPRECATED_IN_CXX17 typedef const void*       const_pointer;
     _LIBCPP_DEPRECATED_IN_CXX17 typedef void              value_type;
 
     template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;};
 };
-
-template <>
-class _LIBCPP_TEMPLATE_VIS allocator<const void>
-{
-public:
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef const void*       pointer;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef const void*       const_pointer;
-    _LIBCPP_DEPRECATED_IN_CXX17 typedef const void        value_type;
-
-    template <class _Up> struct _LIBCPP_DEPRECATED_IN_CXX17 rebind {typedef allocator<_Up> other;};
-};
 #endif
 
 // This class provides a non-trivial default constructor to the class that derives from it
 // if the condition is satisfied.
 //
 // The second template parameter exists to allow giving a unique type to __non_trivial_if,
 // which makes it possible to avoid breaking the ABI when making this a base class of an
 // existing class. Without that, imagine we have classes D1 and D2, both of which used to

 //
 // Note: For ABI compatibility between C++20 and previous standards, we make
 //       allocator<void> trivial in C++20.
 
 template <class _Tp>
 class _LIBCPP_TEMPLATE_VIS allocator
     : private __non_trivial_if<!is_void<_Tp>::value, allocator<_Tp> >
 {
+    static_assert(!is_const<_Tp>::value, "std::allocator does not support const types");
     static_assert(!is_volatile<_Tp>::value, "std::allocator does not support volatile types");
 public:
     typedef size_t      size_type;
     typedef ptrdiff_t   difference_type;
     typedef _Tp         value_type;
     typedef true_type   propagate_on_container_move_assignment;
     typedef true_type   is_always_equal;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
     allocator() _NOEXCEPT = default;
#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
 
     _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
     void destroy(pointer __p) {
         __p->~_Tp();
     }
 #endif
 };
 
-template <class _Tp>
-class _LIBCPP_TEMPLATE_VIS allocator<const _Tp>
-    : private __non_trivial_if<!is_void<_Tp>::value, allocator<const _Tp> >
-{
-    static_assert(!is_volatile<_Tp>::value, "std::allocator does not support volatile types");
-public:
-    typedef size_t      size_type;
-    typedef ptrdiff_t   difference_type;
-    typedef const _Tp   value_type;
-    typedef true_type   propagate_on_container_move_assignment;
-    typedef true_type   is_always_equal;
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    allocator() _NOEXCEPT = default;
-
-    template <class _Up>
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    allocator(const allocator<_Up>&) _NOEXCEPT { }
-
-    _LIBCPP_NODISCARD_AFTER_CXX17 _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    const _Tp* allocate(size_t __n) {
-        if (__n > allocator_traits<allocator>::max_size(*this))
-            __throw_bad_array_new_length();
-        if (__libcpp_is_constant_evaluated()) {
-            return static_cast<const _Tp*>(::operator new(__n * sizeof(_Tp)));
-        } else {
-            return static_cast<const _Tp*>(_VSTD::__libcpp_allocate(__n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)));
-        }
-    }
-
-    _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-    void deallocate(const _Tp* __p, size_t __n) {
-        if (__libcpp_is_constant_evaluated()) {
-            ::operator delete(const_cast<_Tp*>(__p));
-        } else {
-            _VSTD::__libcpp_deallocate((void*) const_cast<_Tp *>(__p), __n * sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp));
-        }
-    }
-
-    // C++20 Removed members
-#if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_ALLOCATOR_MEMBERS)
-    _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;
-    };
-
-    _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 _LIBCPP_DEPRECATED_IN_CXX17
-    const _Tp* allocate(size_t __n, const void*) {
-        return allocate(__n);
-    }
-
-    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT {
-        return size_type(~0) / sizeof(_Tp);
-    }
-
-    template <class _Up, class... _Args>
-    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
-    void construct(_Up* __p, _Args&&... __args) {
-        ::new ((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
-    }
-
-    _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_INLINE_VISIBILITY
-    void destroy(pointer __p) {
-        __p->~_Tp();
-    }
-#endif
-};
-
 template <class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool operator==(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return true;}
 
 template <class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 bool operator!=(const allocator<_Tp>&, const allocator<_Up>&) _NOEXCEPT {return false;}
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___MEMORY_ALLOCATOR_H

libcxx/include/__memory/shared_ptr.h

__shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT
     __data_.second().~_Alloc();
     __a.deallocate(_PTraits::pointer_to(*this), 1);
 }
 
 template <class _Tp, class _Alloc>
 struct __shared_ptr_emplace
     : __shared_weak_count
 {
     template<class ..._Args>
     _LIBCPP_HIDE_FROM_ABI
     explicit __shared_ptr_emplace(_Alloc __a, _Args&& ...__args)
         : __storage_(_VSTD::move(__a))
     {
 #if _LIBCPP_STD_VER > 17
-        using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
+        using _TpAlloc = typename __allocator_traits_rebind<_Alloc, remove_cv_t<_Tp>>::type;
         _TpAlloc __tmp(*__get_alloc());
         allocator_traits<_TpAlloc>::construct(__tmp, __get_elem(), _VSTD::forward<_Args>(__args)...);
 #else
         ::new ((void*)__get_elem()) _Tp(_VSTD::forward<_Args>(__args)...);
 #endif
     }
 
     _LIBCPP_HIDE_FROM_ABI
     _Alloc* __get_alloc() _NOEXCEPT { return __storage_.__get_alloc(); }
 
     _LIBCPP_HIDE_FROM_ABI
     _Tp* __get_elem() _NOEXCEPT { return __storage_.__get_elem(); }
 
 private:
     virtual void __on_zero_shared() _NOEXCEPT {
 #if _LIBCPP_STD_VER > 17
-        using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
+        using _TpAlloc = typename __allocator_traits_rebind<_Alloc, remove_cv_t<_Tp>>::type;
         _TpAlloc __tmp(*__get_alloc());
         allocator_traits<_TpAlloc>::destroy(__tmp, __get_elem());
 #else
         __get_elem()->~_Tp();
 #endif
     }
 
     virtual void __on_zero_shared_weak() _NOEXCEPT {
shared_ptr<_Tp> allocate_shared(const _Alloc& __a, _Args&& ...__args)
     auto __control_block = __guard.__release_ptr();
     return shared_ptr<_Tp>::__create_with_control_block((*__control_block).__get_elem(), _VSTD::addressof(*__control_block));
 }
 
 template<class _Tp, class ..._Args, class = __enable_if_t<!is_array<_Tp>::value> >
 _LIBCPP_HIDE_FROM_ABI
 shared_ptr<_Tp> make_shared(_Args&& ...__args)
 {
-    return _VSTD::allocate_shared<_Tp>(allocator<_Tp>(), _VSTD::forward<_Args>(__args)...);
+    return _VSTD::allocate_shared<_Tp>(allocator<typename remove_cv<_Tp>::type>(), _VSTD::forward<_Args>(__args)...);
 }
 
 template<class _Tp, class _Up>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT
 {
     return __x.get() == __y.get();

libcxx/include/memory

 void __construct_range_forward(_Alloc& __a, _Iter __begin1, _Iter __end1, _Ptr& __begin2) {
     typedef allocator_traits<_Alloc> _Traits;
     for (; __begin1 != __end1; ++__begin1, (void) ++__begin2) {
         _Traits::construct(__a, _VSTD::__to_address(__begin2), *__begin1);
     }
 }
 
 template <class _Alloc, class _Source, class _Dest,
-          class _RawSource = typename remove_const<_Source>::type,
-          class _RawDest = typename remove_const<_Dest>::type,
           class =
     typename enable_if<
         is_trivially_copy_constructible<_Dest>::value &&
-        is_same<_RawSource, _RawDest>::value &&
+        is_same<typename remove_const<_Source>::type, _Dest>::value &&
         (__is_default_allocator<_Alloc>::value || !__has_construct<_Alloc, _Dest*, _Source&>::value)
     >::type>
 _LIBCPP_INLINE_VISIBILITY
 void __construct_range_forward(_Alloc&, _Source* __begin1, _Source* __end1, _Dest*& __begin2) {
     ptrdiff_t _Np = __end1 - __begin1;
     if (_Np > 0) {
-        _VSTD::memcpy(const_cast<_RawDest*>(__begin2), __begin1, _Np * sizeof(_Dest));
+        _VSTD::memcpy(__begin2, __begin1, _Np * sizeof(_Dest));
         __begin2 += _Np;
     }
 }
 
 template <class _Alloc, class _Ptr>
 _LIBCPP_INLINE_VISIBILITY
 void __construct_backward_with_exception_guarantees(_Alloc& __a, _Ptr __begin1, _Ptr __end1, _Ptr& __end2) {
     static_assert(__is_cpp17_move_insertable<_Alloc>::value,

libcxx/test/libcxx/containers/sequences/vector/const_value_type.pass.cpp

-//===----------------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-// UNSUPPORTED: c++03
-
-// <vector>
-
-// vector<const int> v;  // an extension
-
-#include <vector>
-#include <type_traits>
-
-#include "test_macros.h"
-
-int main(int, char**)
-{
-    std::vector<const int> v = {1, 2, 3};
-
-  return 0;
-}

libcxx/test/libcxx/memory/allocator.cv.verify.cpp

 //===----------------------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
-// http://wg21.link/LWG2447 gives implementors freedom to reject volatile types in `std::allocator`.
+// http://wg21.link/LWG2447 gives implementors freedom to reject const or volatile types in `std::allocator`.
 
 #include <memory>
 
 std::allocator<volatile int> A1; // expected-error@*:* {{std::allocator does not support volatile types}}
-std::allocator<const volatile int> A2; // expected-error@*:* {{std::allocator does not support volatile types}}
+std::allocator<const int> A2; // expected-error@*:* {{std::allocator does not support const types}}

libcxx/test/libcxx/memory/allocator_void.trivial.compile.pass.cpp

 //
 // This is important since triviality has implications on how the type is passed
 // as a function argument in the ABI.
 
 #include <memory>
 #include <type_traits>
 
 typedef std::allocator<void> A1;
-typedef std::allocator<void const> A2;
-struct A3 : std::allocator<void> { };
-struct A4 : std::allocator<void const> { };
+struct A2 : std::allocator<void> { };
 
 static_assert(std::is_trivially_default_constructible<A1>::value, "");
 static_assert(std::is_trivial<A1>::value, "");
 
 static_assert(std::is_trivially_default_constructible<A2>::value, "");
 static_assert(std::is_trivial<A2>::value, "");
-
-static_assert(std::is_trivially_default_constructible<A3>::value, "");
-static_assert(std::is_trivial<A3>::value, "");
-
-static_assert(std::is_trivially_default_constructible<A4>::value, "");
-static_assert(std::is_trivial<A4>::value, "");

libcxx/test/std/concepts/concepts.lang/concept.default.init/default_initializable.compile.pass.cpp

void test()
 
     // Sequence containers
     test_not_const<std::array<               int, 0>>();
     test_not_const<std::array<               int, 1>>();
     test_false    <std::array<const          int, 1>>();
     test_not_const<std::array<      volatile int, 1>>();
     test_false    <std::array<const volatile int, 1>>();
     test_true     <std::deque<               int>>();
-#ifdef _LIBCPP_VERSION
-    test_true     <std::deque<const          int>>();
-#endif // _LIBCPP_VERSION
     test_true     <std::forward_list<int>>();
     test_true     <std::list<int>>();
     test_true     <std::vector<int>>();
 
     // Associative containers
     test_true     <std::set<int>>();
     test_true     <std::map<int, int>>();
     test_true     <std::multiset<int>>();
     test_true     <std::multimap<int, int>>();
 
     // Unordered associative containers
     test_true     <std::unordered_set<int>>();
     test_true     <std::unordered_map<int, int>>();
     test_true     <std::unordered_multiset<int>>();
     test_true     <std::unordered_multimap<int, int>>();
 
     // Container adaptors
     test_true     <std::stack<               int>>();
-#ifdef _LIBCPP_VERSION
-    test_true     <std::stack<const          int>>();
-#endif // _LIBCPP_VERSION
     test_true     <std::queue<int>>();
     test_true     <std::priority_queue<int>>();
 
     test_true     <std::span<               int>>();
     test_true     <std::span<const          int>>();
     test_true     <std::span<      volatile int>>();
     test_true     <std::span<const volatile int>>();
 

libcxx/test/std/utilities/memory/default.allocator/allocator.ctor.pass.cpp

TEST_CONSTEXPR_CXX20 bool test() {
   A1 a1_copy = a1; (void)a1_copy;
   A2 a2 = a1; (void)a2;
 
   return true;
 }
 
 int main(int, char**) {
   test<char>();
-  test<char const>();
+  test<int>();
   test<void>();
 
 #if TEST_STD_VER > 17
   static_assert(test<char>());
-  static_assert(test<char const>());
+  static_assert(test<int>());
   static_assert(test<void>());
 #endif
   return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator.dtor.pass.cpp

constexpr bool test() {
     // destructor called here
     return true;
 }
 
 int main(int, char**)
 {
     test<int>();
     test<void>();
-#ifdef _LIBCPP_VERSION // extension
-    test<int const>();
-#endif // _LIBCPP_VERSION
 
     static_assert(test<int>());
     static_assert(test<void>());
-#ifdef _LIBCPP_VERSION // extension
-    static_assert(test<int const>());
-#endif // _LIBCPP_VERSION
 
     return 0;
 }

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

constexpr bool test()
     TEST_IGNORE_NODISCARD a.allocate((size_t) -1);                   // way too large
 
     return true;
 }
 
 int main(int, char**)
 {
     static_assert(test<double>()); // expected-error {{static_assert expression is not an integral constant expression}}
-    LIBCPP_STATIC_ASSERT(test<const double>()); // expected-error {{static_assert expression is not an integral constant expression}}
     return 0;
 }

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

void test()
     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.deprecated_in_cxx17.verify.cpp

int main(int, char**) {
     {
         typedef std::allocator<char>::pointer Pointer;                  // expected-warning {{'pointer' is deprecated}}
         typedef std::allocator<char>::const_pointer ConstPointer;       // expected-warning {{'const_pointer' is deprecated}}
         typedef std::allocator<char>::reference Reference;              // expected-warning {{'reference' is deprecated}}
         typedef std::allocator<char>::const_reference ConstReference;   // expected-warning {{'const_reference' is deprecated}}
         typedef std::allocator<char>::rebind<int>::other Rebind;        // expected-warning {{'rebind<int>' is deprecated}}
     }
     {
-        typedef std::allocator<char const>::pointer Pointer;                  // expected-warning {{'pointer' is deprecated}}
-        typedef std::allocator<char const>::const_pointer ConstPointer;       // expected-warning {{'const_pointer' is deprecated}}
-        typedef std::allocator<char const>::reference Reference;              // expected-warning {{'reference' is deprecated}}
-        typedef std::allocator<char const>::const_reference ConstReference;   // expected-warning {{'const_reference' is deprecated}}
-        typedef std::allocator<char const>::rebind<int>::other Rebind;        // expected-warning {{'rebind<int>' is deprecated}}
-    }
-    {
         typedef std::allocator<void>::pointer Pointer;                  // expected-warning {{'pointer' is deprecated}}
         typedef std::allocator<void>::const_pointer ConstPointer;       // expected-warning {{'const_pointer' is deprecated}}
         // reference and const_reference are not provided by std::allocator<void>
         typedef std::allocator<void>::rebind<int>::other Rebind;        // expected-warning {{'rebind<int>' is deprecated}}
     }
     return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator_types.pass.cpp

#if TEST_STD_VER <= 17
     static_assert((std::is_same<typename Alloc::reference, T&>::value), "");
     static_assert((std::is_same<typename Alloc::const_reference, T const&>::value), "");
     static_assert((std::is_same<typename Alloc::template rebind<U>::other, std::allocator<U> >::value), "");
 #endif
 }
 
 int main(int, char**) {
     test<char>();
-#ifdef _LIBCPP_VERSION
-    test<char const>(); // extension
-#endif
     return 0;
 }

libcxx/test/std/utilities/memory/default.allocator/allocator_types.removed_in_cxx20.verify.cpp

 // UNSUPPORTED: c++03, c++11, c++14, c++17
 
 #include <memory>
 #include "test_macros.h"
 
 template <typename T>
 void check()
 {
-    typedef typename std::allocator<T>::pointer AP;                      // expected-error 3 {{no type named 'pointer'}}
-    typedef typename std::allocator<T>::const_pointer ACP;               // expected-error 3 {{no type named 'const_pointer'}}
-    typedef typename std::allocator<T>::reference AR;                    // expected-error 3 {{no type named 'reference'}}
-    typedef typename std::allocator<T>::const_reference ACR;             // expected-error 3 {{no type named 'const_reference'}}
-    typedef typename std::allocator<T>::template rebind<int>::other ARO; // expected-error 3 {{no member named 'rebind'}}
+    typedef typename std::allocator<T>::pointer AP;                      // expected-error 2 {{no type named 'pointer'}}
+    typedef typename std::allocator<T>::const_pointer ACP;               // expected-error 2 {{no type named 'const_pointer'}}
+    typedef typename std::allocator<T>::reference AR;                    // expected-error 2 {{no type named 'reference'}}
+    typedef typename std::allocator<T>::const_reference ACR;             // expected-error 2 {{no type named 'const_reference'}}
+    typedef typename std::allocator<T>::template rebind<int>::other ARO; // expected-error 2 {{no member named 'rebind'}}
 }
 
 int main(int, char**)
 {
     check<char>();
-    check<char const>();
     check<void>();
     return 0;
 }

libcxx/test/std/utilities/memory/specialized.algorithms/specialized.construct/construct_at.pass.cpp

constexpr bool test()
         (p+1)->~Counted();
         assert(count == 1);
         p->~Counted();
         assert(count == 0);
         a.deallocate(p, 2);
     }
 
     {
-        std::allocator<Counted const> a;
+        std::allocator<Counted> a;
         Counted const* p = a.allocate(2);
         int count = 0;
         std::construct_at(p, count);
         assert(count == 1);
         std::construct_at(p+1, count);
         assert(count == 2);
         (p+1)->~Counted();
         assert(count == 1);
         p->~Counted();
         assert(count == 0);
-        a.deallocate(p, 2);
+        a.deallocate(const_cast<Counted*>(p), 2);
     }
 
     return true;
 }
 
 template <class ...Args, class = decltype(std::construct_at(std::declval<Args>()...))>
 constexpr bool can_construct_at(Args&&...) { return true; }