[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

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

141–143 ↗

(On Diff #485337)

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

 Paper Status
 ====================================
 
 .. csv-table::
    :file: Cxx2bPapers.csv
    :header-rows: 1
    :widths: auto
 
+.. note::
+
+   .. [#note-P1413R3] P1413R3: ``std::aligned_storage_t`` and ``std::aligned_union_t`` are not marked
+      deprecated because there is currently no way to do that.
+
 .. _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","",""
 "`P0533R9 <https://wg21.link/P0533R9>`__","LWG","``constexpr`` for ``<cmath>`` and ``<cstdlib>``","February 2022","",""
 "`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","",""
-"`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","|Partial| [#note-P1413R3]_",""
 "`P2255R3 <https://wg21.link/P2255R3>`__","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","",""
 "`P2387R3 <https://wg21.link/P2387R3>`__","LWG","Pipe support for user-defined range adaptors","February 2022","",""
 "`P2440R1 <https://wg21.link/P2440R1>`__","LWG","``ranges::iota``, ``ranges::shift_left`` and ``ranges::shift_right``","February 2022","",""
 "`P2441R2 <https://wg21.link/P2441R2>`__","LWG","``views::join_view``","February 2022","",""
 "`P2442R1 <https://wg21.link/P2442R1>`__","LWG","Windowing range adaptors: ``views::chunk`` and ``views::slide``","February 2022","",""
 "`P2443R1 <https://wg21.link/P2443R1>`__","LWG","``views::chunk_by``","February 2022","",""
 "","","","","",""

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 > 20
+#  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/type_traits

namespace std
     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;
     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
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
 template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
-    using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
 #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);

 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;
 };
 

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) std::byte 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 { std::byte 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) std::byte 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}}