[libc++] Implement P1413R3 (Deprecate std::aligned_storage and std::aligned_union)

[philnik]

Summary

There are no tests for the aliases because clang doesn't diagnose deprecated template aliases currently.

[Mordante]

libcxx/docs/Status/Cxx2bPapers.csv

45

Since it's not possible to deprecated using I would consider this complete, but let's keep the note for clarity.

libcxx/include/type_traits

160–161

Please update the synopsis.

[philnik]

Address comments

libcxx/docs/Status/Cxx2bPapers.csv

45

Apparently it's actually supported and clang currently just doesn't feel like issuing a diagnostic for it. I've marked the using declarations as deprecated now and updated the note. Hopefully clang will get this fixed soon. I've seen a patch fixing it at some point, but I can't find it anymore.

[philnik]

Try to fix CI

[philnik]

Rebased

[ldionne]

libcxx/include/any

142–144

I know this is easy to change, but I would stick with the DEPRECATED_PUSH here and everywhere else. This is *really* supposed to be a NFC patch. Once we get rid of aligned_storage everywhere in our code base, we can do it here as well trivially.

[ldionne]

I think the CI issue on GCC is likely to yield interesting findings. I somewhat suspect that non-lockfree-atomics is subtly broken, or that the atomic tests that fail should not have been marked as XFAIL, or a combination of both. Please investigate using the Docker image, I think you'll find something interesting.

[philnik]

Address comments

I wasn't able to reproduce the issue locally. I hope the rebase fixed the problem.

[philnik]

Try to fix CI

libcxx/docs/Status/Cxx2b.rst

.. csv-table::
    :file: Cxx2bPapers.csv
    :header-rows: 1
    :widths: auto
 
 .. note::
 
    .. [#note-P2273] P2273: ``make_unique_for_overwrite`` isn't done yet since `P1020` hasn't been implemented yet.
    .. [#note-P0533R9] P0533R9: ``isfinite``, ``isinf``, ``isnan`` and ``isnormal`` are implemented.
+   .. [#note-P1413R3] P1413R3: ``std::aligned_storage_t`` and ``std::aligned_union_t`` are marked deprecated, but
+      clang doesn't issue a diagnostic for deprecated using template declarations.
 
 .. _issues-status-cxx2b:
 
 Library Working Group Issues Status
 ====================================
 
 .. csv-table::
    :file: Cxx2bIssues.csv
    :header-rows: 1
    :widths: auto

libcxx/docs/Status/Cxx2bPapers.csv

 "`P2340R1 <https://wg21.link/P2340R1>`__","LWG","Clarifying the status of the 'C headers'","October 2021","",""
 "`P2393R1 <https://wg21.link/P2393R1>`__","LWG","Cleaning up ``integer``-class types","October 2021","",""
 "`P2401R0 <https://wg21.link/P2401R0>`__","LWG","Add a conditional ``noexcept`` specification to ``std::exchange``","October 2021","|Complete|","14.0"
 "","","","","","",""
 "`P0323R12 <https://wg21.link/P0323R12>`__","LWG","``std::expected``","February 2022","|Complete|","16.0"
 "`P0533R9 <https://wg21.link/P0533R9>`__","LWG","``constexpr`` for ``<cmath>`` and ``<cstdlib>``","February 2022","|In progress| [#note-P0533R9]_",""
 "`P0627R6 <https://wg21.link/P0627R6>`__","LWG","Function to mark unreachable code","February 2022","|Complete|","15.0"
 "`P1206R7 <https://wg21.link/P1206R7>`__","LWG","``ranges::to``: A function to convert any range to a container","February 2022","","","|ranges|"
-"`P1413R3 <https://wg21.link/P1413R3>`__","LWG","Deprecate ``std::aligned_storage`` and ``std::aligned_union``","February 2022","",""
+"`P1413R3 <https://wg21.link/P1413R3>`__","LWG","Deprecate ``std::aligned_storage`` and ``std::aligned_union``","February 2022","|Complete| [#note-P1413R3]_",""
 "`P2255R2 <https://wg21.link/P2255R2>`__","LWG","A type trait to detect reference binding to temporary","February 2022","",""
 "`P2273R3 <https://wg21.link/P2273R3>`__","LWG","Making ``std::unique_ptr`` constexpr","February 2022","|Partial| [#note-P2273]_","16.0"
 "`P2387R3 <https://wg21.link/P2387R3>`__","LWG","Pipe support for user-defined range adaptors","February 2022","","","|ranges|"
 "`P2440R1 <https://wg21.link/P2440R1>`__","LWG","``ranges::iota``, ``ranges::shift_left`` and ``ranges::shift_right``","February 2022","","","|ranges|"
 "`P2441R2 <https://wg21.link/P2441R2>`__","LWG","``views::join_with``","February 2022","","","|ranges|"
 "`P2442R1 <https://wg21.link/P2442R1>`__","LWG","Windowing range adaptors: ``views::chunk`` and ``views::slide``","February 2022","","","|ranges|"
 "`P2443R1 <https://wg21.link/P2443R1>`__","LWG","``views::chunk_by``","February 2022","","","|ranges|"
 "","","","","","",""

libcxx/include/__config

 #  endif
 
 #  if _LIBCPP_STD_VER > 17
 #    define _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_DEPRECATED
 #  else
 #    define _LIBCPP_DEPRECATED_IN_CXX20
 #  endif
 
+#if _LIBCPP_STD_VER >= 23
+#  define _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_DEPRECATED
+#else
+#  define _LIBCPP_DEPRECATED_IN_CXX23
+#endif
+
 #  if !defined(_LIBCPP_HAS_NO_CHAR8_T)
 #    define _LIBCPP_DEPRECATED_WITH_CHAR8_T _LIBCPP_DEPRECATED
 #  else
 #    define _LIBCPP_DEPRECATED_WITH_CHAR8_T
 #  endif
 
 // Macros to enter and leave a state where deprecation warnings are suppressed.
 #  if defined(_LIBCPP_COMPILER_CLANG_BASED) || defined(_LIBCPP_COMPILER_GCC)

libcxx/include/__functional/function.h

 #endif // _LIBCPP_NO_RTTI
 
 // __value_func creates a value-type from a __func.
 
 template <class _Fp> class __value_func;
 
 template <class _Rp, class... _ArgTypes> class __value_func<_Rp(_ArgTypes...)>
 {
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
     typename aligned_storage<3 * sizeof(void*)>::type __buf_;
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
 
     typedef __base<_Rp(_ArgTypes...)> __func;
     __func* __f_;
 
     _LIBCPP_NO_CFI static __func* __as_base(void* __p)
     {
         return reinterpret_cast<__func*>(__p);
     }
public:
 
     _LIBCPP_INLINE_VISIBILITY
     void swap(__value_func& __f) _NOEXCEPT
     {
         if (&__f == this)
             return;
         if ((void*)__f_ == &__buf_ && (void*)__f.__f_ == &__f.__buf_)
         {
+            _LIBCPP_SUPPRESS_DEPRECATED_PUSH
             typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
+            _LIBCPP_SUPPRESS_DEPRECATED_POP
             __func* __t = __as_base(&__tempbuf);
             __f_->__clone(__t);
             __f_->destroy();
             __f_ = nullptr;
             __f.__f_->__clone(__as_base(&__buf_));
             __f.__f_->destroy();
             __f.__f_ = nullptr;
             __f_ = __as_base(&__buf_);

libcxx/include/__type_traits/aligned_storage.h

public:
     static const size_t value = _Len < __max ? __min : __max;
 };
 
 template <class _Hp, class _Tp, size_t _Len>
 struct __find_max_align<__type_list<_Hp, _Tp>, _Len>
     : public integral_constant<size_t, __select_align<_Len, _Hp::value, __find_max_align<_Tp, _Len>::value>::value> {};
 
 template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
-struct _LIBCPP_TEMPLATE_VIS aligned_storage
+struct _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_TEMPLATE_VIS aligned_storage
 {
     typedef typename __find_pod<__all_types, _Align>::type _Aligner;
     union type
     {
         _Aligner __align;
         unsigned char __data[(_Len + _Align - 1)/_Align * _Align];
     };
 };
 
 #if _LIBCPP_STD_VER > 11
+
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
-    using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
+    using aligned_storage_t _LIBCPP_DEPRECATED_IN_CXX23 = typename aligned_storage<_Len, _Align>::type;
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
+
 #endif
 
 #define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n) \
 template <size_t _Len>\
-struct _LIBCPP_TEMPLATE_VIS aligned_storage<_Len, n>\
+struct _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_TEMPLATE_VIS aligned_storage<_Len, n>\
 {\
     struct _ALIGNAS(n) type\
     {\
         unsigned char __lx[(_Len + n - 1)/n * n];\
     };\
 }
 
 _CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1);

libcxx/include/__type_traits/aligned_union.h

 template <size_t _I0, size_t _I1, size_t ..._In>
 struct __static_max<_I0, _I1, _In...>
 {
     static const size_t value = _I0 >= _I1 ? __static_max<_I0, _In...>::value :
                                              __static_max<_I1, _In...>::value;
 };
 
 template <size_t _Len, class _Type0, class ..._Types>
-struct aligned_union
+struct _LIBCPP_DEPRECATED_IN_CXX23 aligned_union
 {
     static const size_t alignment_value = __static_max<_LIBCPP_PREFERRED_ALIGNOF(_Type0),
                                                        _LIBCPP_PREFERRED_ALIGNOF(_Types)...>::value;
     static const size_t __len = __static_max<_Len, sizeof(_Type0),
                                              sizeof(_Types)...>::value;
     typedef typename aligned_storage<__len, alignment_value>::type type;
 };
 
 #if _LIBCPP_STD_VER > 11
-template <size_t _Len, class ..._Types> using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
+template <size_t _Len, class... _Types>
+using aligned_union_t _LIBCPP_DEPRECATED_IN_CXX23 = typename aligned_union<_Len, _Types...>::type;
 #endif
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___TYPE_TRAITS_ALIGNED_UNION_H

libcxx/include/any

 any_cast(any const *) _NOEXCEPT;
 
 template <class _ValueType>
 _LIBCPP_INLINE_VISIBILITY
 add_pointer_t<_ValueType> any_cast(any *) _NOEXCEPT;
 
 namespace __any_imp
 {
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
   using _Buffer = aligned_storage_t<3*sizeof(void*), alignment_of<void*>::value>;
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 
   template <class _Tp>
   using _IsSmallObject = integral_constant<bool
         , sizeof(_Tp) <= sizeof(_Buffer)
           && alignment_of<_Buffer>::value
              % alignment_of<_Tp>::value == 0
           && is_nothrow_move_constructible<_Tp>::value
         >;
 

libcxx/include/future

__assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
     return wait_until(chrono::steady_clock::now() + __rel_time);
 }
 
 template <class _Rp>
 class _LIBCPP_AVAILABILITY_FUTURE _LIBCPP_HIDDEN __assoc_state
     : public __assoc_sub_state
 {
     typedef __assoc_sub_state base;
+_LIBCPP_SUPPRESS_DEPRECATED_PUSH
     typedef typename aligned_storage<sizeof(_Rp), alignment_of<_Rp>::value>::type _Up;
+_LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
     _Up __value_;
 
     void __on_zero_shared() _NOEXCEPT override;
 public:
 
     template <class _Arg>
     void set_value(_Arg&& __arg);

 template<class _Rp, class ..._ArgTypes>
 class _LIBCPP_AVAILABILITY_FUTURE __packaged_task_function<_Rp(_ArgTypes...)>
 {
     typedef __packaged_task_base<_Rp(_ArgTypes...)> __base;
 
     _LIBCPP_INLINE_VISIBILITY _LIBCPP_NO_CFI
     __base* __get_buf() { return (__base*)&__buf_; }
 
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
     typename aligned_storage<3*sizeof(void*)>::type __buf_;
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
     __base* __f_;
 
 public:
     typedef _Rp result_type;
 
     // construct/copy/destroy:
     _LIBCPP_INLINE_VISIBILITY
     __packaged_task_function() _NOEXCEPT : __f_(nullptr) {}

 
 template<class _Rp, class ..._ArgTypes>
 _LIBCPP_NO_CFI
 void
 __packaged_task_function<_Rp(_ArgTypes...)>::swap(__packaged_task_function& __f) _NOEXCEPT
 {
     if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
     {
+        _LIBCPP_SUPPRESS_DEPRECATED_PUSH
         typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
+        _LIBCPP_SUPPRESS_DEPRECATED_POP
         __base* __t = (__base*)&__tempbuf;
         __f_->__move_to(__t);
         __f_->destroy();
         __f_ = nullptr;
         __f.__f_->__move_to((__base*)&__buf_);
         __f.__f_->destroy();
         __f.__f_ = nullptr;
         __f_ = (__base*)&__buf_;

libcxx/include/type_traits

namespace std
     template <class Fn, class... ArgTypes> struct is_invocable;
     template <class R, class Fn, class... ArgTypes> struct is_invocable_r;
 
     template <class Fn, class... ArgTypes> struct is_nothrow_invocable;
     template <class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r;
 
     // Alignment properties and transformations:
     template <class T> struct alignment_of;
     template <size_t Len, size_t Align = most_stringent_alignment_requirement>
-        struct aligned_storage;
-    template <size_t Len, class... Types> struct aligned_union;
+        struct aligned_storage;                                 // deprecated in C++23
+    template <size_t Len, class... Types> struct aligned_union; // deprecated in C++23
     template <class T> struct remove_cvref; // C++20
 
     template <class T> struct decay;
     template <class... T> struct common_type;
     template <class T> struct underlying_type;
     template <class> class result_of; // undefined; deprecated in C++17; removed in C++20
     template <class Fn, class... ArgTypes> class result_of<Fn(ArgTypes...)>; // deprecated in C++17; removed in C++20
     template <class Fn, class... ArgTypes> struct invoke_result;  // C++17

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

 
 #include "test_macros.h"
 #include "test_memory_resource.h"
 
 namespace ex = std::experimental::pmr;
 
 template <size_t S, size_t Align>
 void testForSizeAndAlign() {
-    using T = typename std::aligned_storage<S, Align>::type;
+    struct T { alignas(Align) char data[S]; };
     TestResource R;
     ex::polymorphic_allocator<T> a(&R);
 
     for (int N = 1; N <= 5; ++N) {
         auto ret = a.allocate(N);
         assert(R.checkAlloc(ret, N * sizeof(T), alignof(T)));
 
         a.deallocate(ret, N);
         R.reset();
     }
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 template <size_t S>
 void testAllocForSizeThrows() {
-    using T = typename std::aligned_storage<S>::type;
+    struct T { char data[S]; };
     using Alloc = ex::polymorphic_allocator<T>;
     using Traits = std::allocator_traits<Alloc>;
     NullResource R;
     Alloc a(&R);
 
     // Test that allocating exactly the max size does not throw.
     size_t maxSize = Traits::max_size(a);
     try {

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

 #include "test_memory_resource.h"
 
 #include "test_macros.h"
 
 namespace ex = std::experimental::pmr;
 
 template <size_t S, size_t Align>
 void testForSizeAndAlign() {
-    using T = typename std::aligned_storage<S, Align>::type;
+    struct T { alignas(Align) char data[S]; };
 
     TestResource R;
     ex::polymorphic_allocator<T> a(&R);
 
     for (int N = 1; N <= 5; ++N) {
         auto ret = a.allocate(N);
         assert(R.checkAlloc(ret, N * sizeof(T), alignof(T)));
 

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.depr.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <type_traits>
+
+std::aligned_storage<1, 1>::type s2; // expected-warning {{'aligned_storage<1, 1>' is deprecated}}
+std::aligned_storage<3, 1>::type s3; // expected-warning {{'aligned_storage<3, 1>' is deprecated}}

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.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
 //
 //===----------------------------------------------------------------------===//
 
 // type_traits
 
 // aligned_storage
 //
 //  Issue 3034 added:
 //  The member typedef type shall be a trivial standard-layout type.
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 #include <type_traits>
 #include <cstddef>       // for std::max_align_t
 #include "test_macros.h"
 
 // The following tests assume naturally aligned types exist
 // up to 64bit (double). For larger types, max_align_t should
 // give the correct alignment. For pre-C++11 testing, only
 // the lower bound is checked.

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.depr.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
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
+
+#include <type_traits>
+
+std::aligned_union<1, int>::type s2; // expected-warning {{'aligned_union<1, int>' is deprecated}}
+std::aligned_union<3, char, char>::type s3; // expected-warning {{'aligned_union<3, char, char>' is deprecated}}

libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.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
 //
 //===----------------------------------------------------------------------===//
 
+// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS
+
 // type_traits
 
 // aligned_union<size_t Len, class ...Types>
 
 //  Issue 3034 added:
 //  The member typedef type shall be a trivial standard-layout type.
 
 #include <type_traits>

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/allocate.pass.cpp

 #include <memory>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_std_memory_resource.h"
 
 template <size_t S, size_t Align>
 void testForSizeAndAlign() {
-  using T = typename std::aligned_storage<S, Align>::type;
+  struct T {
+    alignas(Align) std::byte buf[S];
+  };
+
   TestResource R;
   std::pmr::polymorphic_allocator<T> a(&R);
 
   for (int N = 1; N <= 5; ++N) {
     auto ret = a.allocate(N);
     assert(R.checkAlloc(ret, N * sizeof(T), alignof(T)));
 
     a.deallocate(ret, N);
     R.reset();
   }
 }
 
 #ifndef TEST_HAS_NO_EXCEPTIONS
 template <size_t S>
 void testAllocForSizeThrows() {
-  using T      = typename std::aligned_storage<S>::type;
+  struct T {
+    std::byte buf[S];
+  };
+
   using Alloc  = std::pmr::polymorphic_allocator<T>;
   using Traits = std::allocator_traits<Alloc>;
   NullResource R;
   Alloc a(&R);
 
   // Test that allocating exactly the max size does not throw.
   size_t maxSize = Traits::max_size(a);
   size_t sizeTypeMax = std::numeric_limits<std::size_t>::max();

libcxx/test/std/utilities/utility/mem.res/mem.poly.allocator.class/mem.poly.allocator.mem/deallocate.pass.cpp

 #include <cassert>
 #include <type_traits>
 
 #include "test_macros.h"
 #include "test_std_memory_resource.h"
 
 template <size_t S, size_t Align>
 void testForSizeAndAlign() {
-  using T = typename std::aligned_storage<S, Align>::type;
+  struct T {
+    alignas(Align) std::byte buf[S];
+  };
 
   TestResource R;
   std::pmr::polymorphic_allocator<T> a(&R);
 
   for (int N = 1; N <= 5; ++N) {
     auto ret = a.allocate(N);
     assert(R.checkAlloc(ret, N * sizeof(T), alignof(T)));