diff --git a/libcxx/docs/ReleaseNotes/21.rst b/libcxx/docs/ReleaseNotes/21.rst index 1f479d19e4772..53639b01ad629 100644 --- a/libcxx/docs/ReleaseNotes/21.rst +++ b/libcxx/docs/ReleaseNotes/21.rst @@ -45,6 +45,7 @@ Implemented Papers - P2562R1: ``constexpr`` Stable Sorting (`Github `__) - P0472R3: Put std::monostate in (`Github `__) - P1222R4: A Standard ``flat_set`` (`Github `__) +- P3247R2: Deprecate the notion of trivial types (`Github `__) Improvements and New Features ----------------------------- @@ -65,6 +66,8 @@ Deprecations and Removals - ``std::is_pod`` and ``std::is_pod_v`` are deprecated in C++20 and later. +- ``std::is_trivial`` and ``std::is_trivial_v`` are deprecated in C++26 and later. + Upcoming Deprecations and Removals ---------------------------------- diff --git a/libcxx/docs/Status/Cxx2cPapers.csv b/libcxx/docs/Status/Cxx2cPapers.csv index 0cc41d2058dd5..b40d9eb58c24e 100644 --- a/libcxx/docs/Status/Cxx2cPapers.csv +++ b/libcxx/docs/Status/Cxx2cPapers.csv @@ -94,7 +94,7 @@ "`P1928R15 `__","``std::simd`` — merge data-parallel types from the Parallelism TS 2","2024-11 (Wrocław)","","","" "`P3325R5 `__","A Utility for Creating Execution Environments","2024-11 (Wrocław)","","","" "`P3068R6 `__","Allowing exception throwing in constant-evaluation","2024-11 (Wrocław)","","","" -"`P3247R2 `__","Deprecate the notion of trivial types","2024-11 (Wrocław)","","","" +"`P3247R2 `__","Deprecate the notion of trivial types","2024-11 (Wrocław)","|Complete|","21","" "","","","","","" "`P3074R7 `__","trivial unions (was ``std::uninitialized``)","2025-02 (Hagenberg)","","","" "`P1494R5 `__","Partial program correctness","2025-02 (Hagenberg)","","","" diff --git a/libcxx/include/__config b/libcxx/include/__config index ce8bc38acfe3e..a4269f5442610 100644 --- a/libcxx/include/__config +++ b/libcxx/include/__config @@ -750,8 +750,10 @@ typedef __char32_t char32_t; # if _LIBCPP_STD_VER >= 26 # define _LIBCPP_DEPRECATED_IN_CXX26 _LIBCPP_DEPRECATED +# define _LIBCPP_DEPRECATED_IN_CXX26_(m) _LIBCPP_DEPRECATED_(m) # else # define _LIBCPP_DEPRECATED_IN_CXX26 +# define _LIBCPP_DEPRECATED_IN_CXX26_(m) # endif # if _LIBCPP_HAS_CHAR8_T diff --git a/libcxx/include/__iterator/aliasing_iterator.h b/libcxx/include/__iterator/aliasing_iterator.h index 98b212cb39296..528e95eb14d68 100644 --- a/libcxx/include/__iterator/aliasing_iterator.h +++ b/libcxx/include/__iterator/aliasing_iterator.h @@ -14,7 +14,8 @@ #include <__iterator/iterator_traits.h> #include <__memory/addressof.h> #include <__memory/pointer_traits.h> -#include <__type_traits/is_trivial.h> +#include <__type_traits/is_trivially_constructible.h> +#include <__type_traits/is_trivially_copyable.h> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header @@ -45,7 +46,8 @@ struct __aliasing_iterator_wrapper { using reference = value_type&; using pointer = value_type*; - static_assert(is_trivial::value); + static_assert(is_trivially_default_constructible::value); + static_assert(is_trivially_copyable::value); static_assert(sizeof(__base_value_type) == sizeof(value_type)); _LIBCPP_HIDE_FROM_ABI __iterator() = default; diff --git a/libcxx/include/__type_traits/is_char_like_type.h b/libcxx/include/__type_traits/is_char_like_type.h index 913c0821c8c68..ca440b52fcd45 100644 --- a/libcxx/include/__type_traits/is_char_like_type.h +++ b/libcxx/include/__type_traits/is_char_like_type.h @@ -12,7 +12,8 @@ #include <__config> #include <__type_traits/conjunction.h> #include <__type_traits/is_standard_layout.h> -#include <__type_traits/is_trivial.h> +#include <__type_traits/is_trivially_constructible.h> +#include <__type_traits/is_trivially_copyable.h> #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header @@ -21,7 +22,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD template -using _IsCharLikeType _LIBCPP_NODEBUG = _And, is_trivial<_CharT> >; +using _IsCharLikeType _LIBCPP_NODEBUG = + _And, is_trivially_default_constructible<_CharT>, is_trivially_copyable<_CharT> >; _LIBCPP_END_NAMESPACE_STD diff --git a/libcxx/include/__type_traits/is_trivial.h b/libcxx/include/__type_traits/is_trivial.h index a4ca2d6b26d0e..6379d8a6962ce 100644 --- a/libcxx/include/__type_traits/is_trivial.h +++ b/libcxx/include/__type_traits/is_trivial.h @@ -19,11 +19,14 @@ _LIBCPP_BEGIN_NAMESPACE_STD template -struct _LIBCPP_TEMPLATE_VIS _LIBCPP_NO_SPECIALIZATIONS is_trivial : public integral_constant { -}; +struct _LIBCPP_TEMPLATE_VIS _LIBCPP_DEPRECATED_IN_CXX26_( + "Consider using is_trivially_copyable::value && is_trivially_default_constructible::value instead.") + _LIBCPP_NO_SPECIALIZATIONS is_trivial : public integral_constant {}; #if _LIBCPP_STD_VER >= 17 template +_LIBCPP_DEPRECATED_IN_CXX26_( + "Consider using is_trivially_copyable_v && is_trivially_default_constructible_v instead.") _LIBCPP_NO_SPECIALIZATIONS inline constexpr bool is_trivial_v = __is_trivial(_Tp); #endif diff --git a/libcxx/include/string b/libcxx/include/string index fa87dc2fddb59..091a9703e3f77 100644 --- a/libcxx/include/string +++ b/libcxx/include/string @@ -632,7 +632,8 @@ basic_string operator""s( const char32_t *str, size_t len ); # include <__type_traits/is_nothrow_constructible.h> # include <__type_traits/is_same.h> # include <__type_traits/is_standard_layout.h> -# include <__type_traits/is_trivial.h> +# include <__type_traits/is_trivially_constructible.h> +# include <__type_traits/is_trivially_copyable.h> # include <__type_traits/is_trivially_relocatable.h> # include <__type_traits/remove_cvref.h> # include <__type_traits/void_t.h> @@ -788,7 +789,9 @@ public: static_assert(!is_array::value, "Character type of basic_string must not be an array"); static_assert(is_standard_layout::value, "Character type of basic_string must be standard-layout"); - static_assert(is_trivial::value, "Character type of basic_string must be trivial"); + static_assert(is_trivially_default_constructible::value, + "Character type of basic_string must be trivially default constructible"); + static_assert(is_trivially_copyable::value, "Character type of basic_string must be trivially copyable"); static_assert(is_same<_CharT, typename traits_type::char_type>::value, "traits_type::char_type must be the same type as CharT"); static_assert(is_same::value, diff --git a/libcxx/include/string_view b/libcxx/include/string_view index c640ae4e79865..5054b14efd2d5 100644 --- a/libcxx/include/string_view +++ b/libcxx/include/string_view @@ -235,7 +235,8 @@ namespace std { # include <__type_traits/is_convertible.h> # include <__type_traits/is_same.h> # include <__type_traits/is_standard_layout.h> -# include <__type_traits/is_trivial.h> +# include <__type_traits/is_trivially_constructible.h> +# include <__type_traits/is_trivially_copyable.h> # include <__type_traits/remove_cvref.h> # include <__type_traits/remove_reference.h> # include <__type_traits/type_identity.h> @@ -302,7 +303,10 @@ public: static_assert(!is_array::value, "Character type of basic_string_view must not be an array"); static_assert(is_standard_layout::value, "Character type of basic_string_view must be standard-layout"); - static_assert(is_trivial::value, "Character type of basic_string_view must be trivial"); + static_assert(is_trivially_default_constructible::value, + "Character type of basic_string_view must be trivially default constructible"); + static_assert(is_trivially_copyable::value, + "Character type of basic_string_view must be trivially copyable"); static_assert(is_same<_CharT, typename traits_type::char_type>::value, "traits_type::char_type must be the same type as CharT"); diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits index a03a60917cd54..b63f61cfefe8e 100644 --- a/libcxx/include/type_traits +++ b/libcxx/include/type_traits @@ -93,7 +93,7 @@ namespace std template struct is_unbounded_array; // since C++20 // Member introspection: - template struct is_trivial; + template struct is_trivial; // deprecated in C++26 template struct is_pod; // deprecated in C++20 template struct is_trivially_copyable; template struct is_standard_layout; @@ -323,7 +323,7 @@ namespace std template inline constexpr bool is_volatile_v = is_volatile::value; // since C++17 template inline constexpr bool is_trivial_v - = is_trivial::value; // since C++17 + = is_trivial::value; // since C++17; deprecated in C++26 template inline constexpr bool is_trivially_copyable_v = is_trivially_copyable::value; // since C++17 template inline constexpr bool is_standard_layout_v diff --git a/libcxx/test/libcxx/memory/allocator_void.trivial.compile.pass.cpp b/libcxx/test/libcxx/memory/allocator_void.trivial.compile.pass.cpp index 69a4b8943caa6..b7dfc190e8e91 100644 --- a/libcxx/test/libcxx/memory/allocator_void.trivial.compile.pass.cpp +++ b/libcxx/test/libcxx/memory/allocator_void.trivial.compile.pass.cpp @@ -20,7 +20,7 @@ typedef std::allocator A1; struct A2 : std::allocator { }; static_assert(std::is_trivially_default_constructible::value, ""); -static_assert(std::is_trivial::value, ""); +static_assert(std::is_trivially_copyable::value, ""); static_assert(std::is_trivially_default_constructible::value, ""); -static_assert(std::is_trivial::value, ""); +static_assert(std::is_trivially_copyable::value, ""); diff --git a/libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/libcxx.control_block_layout.pass.cpp b/libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/libcxx.control_block_layout.pass.cpp index 7488f518c8bae..0b48bc92f02af 100644 --- a/libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/libcxx.control_block_layout.pass.cpp +++ b/libcxx/test/libcxx/utilities/memory/util.smartptr/util.smartptr.shared/libcxx.control_block_layout.pass.cpp @@ -123,7 +123,9 @@ void test() { // Make sure both types have the same triviality (that has ABI impact since // it determined how objects are passed). Both should be non-trivial. - static_assert(std::is_trivial::value == std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value == std::is_trivially_copyable::value, ""); + static_assert( + std::is_trivially_default_constructible::value == std::is_trivially_default_constructible::value, ""); } // Object types to store in the control block diff --git a/libcxx/test/libcxx/utilities/utility/private_constructor_tag.compile.pass.cpp b/libcxx/test/libcxx/utilities/utility/private_constructor_tag.compile.pass.cpp index bae0824109071..1644819a02f7f 100644 --- a/libcxx/test/libcxx/utilities/utility/private_constructor_tag.compile.pass.cpp +++ b/libcxx/test/libcxx/utilities/utility/private_constructor_tag.compile.pass.cpp @@ -18,4 +18,5 @@ #include <__utility/private_constructor_tag.h> #include -static_assert(std::is_trivial::value, ""); +static_assert(std::is_trivially_copyable::value, ""); +static_assert(std::is_trivially_default_constructible::value, ""); diff --git a/libcxx/test/std/depr/depr.c.headers/stddef_h.compile.pass.cpp b/libcxx/test/std/depr/depr.c.headers/stddef_h.compile.pass.cpp index fed867f460f26..9e44c4c471def 100644 --- a/libcxx/test/std/depr/depr.c.headers/stddef_h.compile.pass.cpp +++ b/libcxx/test/std/depr/depr.c.headers/stddef_h.compile.pass.cpp @@ -43,8 +43,9 @@ static_assert((std::is_same::value), ""); static_assert(sizeof(nullptr_t) == sizeof(void*), ""); #if TEST_STD_VER >= 11 # if TEST_STD_VER >= 20 -// P0767 -static_assert(std::is_trivial::value, ""); +// P0767R1 and P3247R2 +static_assert(std::is_trivially_copyable::value, ""); +static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); # else static_assert(std::is_pod::value, ""); diff --git a/libcxx/test/std/language.support/support.types/byte.pass.cpp b/libcxx/test/std/language.support/support.types/byte.pass.cpp index e79af0dec6550..c707bde584af5 100644 --- a/libcxx/test/std/language.support/support.types/byte.pass.cpp +++ b/libcxx/test/std/language.support/support.types/byte.pass.cpp @@ -16,7 +16,9 @@ // It is a distinct type for accessing the bits that ultimately make up object storage. #if TEST_STD_VER > 17 -static_assert( std::is_trivial::value, "" ); // P0767 +static_assert(std::is_trivially_copyable::value, ""); +static_assert(std::is_trivially_default_constructible::value, ""); +static_assert(std::is_standard_layout::value, ""); #else static_assert( std::is_pod::value, "" ); #endif diff --git a/libcxx/test/std/language.support/support.types/max_align_t.compile.pass.cpp b/libcxx/test/std/language.support/support.types/max_align_t.compile.pass.cpp index 5e335841c2a3c..bda965b22a9c1 100644 --- a/libcxx/test/std/language.support/support.types/max_align_t.compile.pass.cpp +++ b/libcxx/test/std/language.support/support.types/max_align_t.compile.pass.cpp @@ -16,7 +16,8 @@ #include "test_macros.h" -static_assert(std::is_trivial::value, ""); +static_assert(std::is_trivially_copyable::value, ""); +static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); diff --git a/libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp b/libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp index 060f179fe1683..3f4317a724add 100644 --- a/libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp +++ b/libcxx/test/std/library/description/conventions/customization.point.object/cpo.compile.pass.cpp @@ -23,7 +23,8 @@ template constexpr bool test(CPO& o, Args&&...) { static_assert(std::is_const_v); static_assert(std::is_class_v); - static_assert(std::is_trivial_v); + static_assert(std::is_trivially_copyable_v); + static_assert(std::is_trivially_default_constructible_v); auto p = o; using T = decltype(p); diff --git a/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp b/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp index 5a2ee189641c7..402bc1c9351aa 100644 --- a/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp +++ b/libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp @@ -36,7 +36,8 @@ template constexpr bool test(CPO& o, Args&&...) { static_assert(std::is_const_v); static_assert(std::is_class_v); - static_assert(std::is_trivial_v); + static_assert(std::is_trivially_copyable_v); + static_assert(std::is_trivially_default_constructible_v); auto p = o; using T = decltype(p); diff --git a/libcxx/test/std/ranges/range.req/range.view/view_base.compile.pass.cpp b/libcxx/test/std/ranges/range.req/range.view/view_base.compile.pass.cpp index ca9525d585b45..84293e3ed0cbf 100644 --- a/libcxx/test/std/ranges/range.req/range.view/view_base.compile.pass.cpp +++ b/libcxx/test/std/ranges/range.req/range.view/view_base.compile.pass.cpp @@ -16,7 +16,8 @@ #include static_assert(std::is_empty_v); -static_assert(std::is_trivial_v); +static_assert(std::is_trivially_copyable_v); +static_assert(std::is_trivially_default_constructible_v); // Make sure we can inherit from it, as it's intended (that wouldn't be the // case if e.g. it was marked as final). diff --git a/libcxx/test/std/strings/basic.string/char.bad.verify.cpp b/libcxx/test/std/strings/basic.string/char.bad.verify.cpp index 557604b415de3..e8305e310ee18 100644 --- a/libcxx/test/std/strings/basic.string/char.bad.verify.cpp +++ b/libcxx/test/std/strings/basic.string/char.bad.verify.cpp @@ -6,14 +6,25 @@ // //===----------------------------------------------------------------------===// +// XFAIL: FROZEN-CXX03-HEADERS-FIXME + // // ... manipulating sequences of any non-array trivial standard-layout types. #include +#include #include "test_traits.h" -struct NotTrivial { - NotTrivial() : value(3) {} +struct NotTriviallyCopyable { + int value; + NotTriviallyCopyable& operator=(const NotTriviallyCopyable& other) { + value = other.value; + return *this; + } +}; + +struct NotTriviallyDefaultConstructible { + NotTriviallyDefaultConstructible() : value(3) {} int value; }; @@ -37,10 +48,17 @@ void f() { } { - // not trivial - static_assert(!std::is_trivial::value, ""); - std::basic_string > s; - // expected-error-re@*:* {{static assertion failed{{.*}}Character type of basic_string must be trivial}} + // not trivially copyable + static_assert(!std::is_trivially_copyable::value, ""); + std::basic_string > s; + // expected-error-re@*:* {{static assertion failed{{.*}}Character type of basic_string must be trivially copyable}} + } + + { + // not trivially default constructible + static_assert(!std::is_trivially_default_constructible::value, ""); + std::basic_string > s; + // expected-error-re@*:* {{static assertion failed{{.*}}Character type of basic_string must be trivially default constructible}} } { diff --git a/libcxx/test/std/strings/string.view/char.bad.verify.cpp b/libcxx/test/std/strings/string.view/char.bad.verify.cpp index df91736388150..a8927a1952cc0 100644 --- a/libcxx/test/std/strings/string.view/char.bad.verify.cpp +++ b/libcxx/test/std/strings/string.view/char.bad.verify.cpp @@ -14,10 +14,19 @@ // ... manipulating sequences of any non-array trivial standard-layout types. #include +#include #include "../basic.string/test_traits.h" -struct NotTrivial { - NotTrivial() : value(3) {} +struct NotTriviallyCopyable { + int value; + NotTriviallyCopyable& operator=(const NotTriviallyCopyable& other) { + value = other.value; + return *this; + } +}; + +struct NotTriviallyDefaultConstructible { + NotTriviallyDefaultConstructible() : value(3) {} int value; }; @@ -41,10 +50,17 @@ int main(int, char**) { } { - // not trivial - static_assert(!std::is_trivial::value, ""); - std::basic_string_view > sv; - // expected-error-re@string_view:* {{static assertion failed{{.*}}Character type of basic_string_view must be trivial}} + // not trivially copyable + static_assert(!std::is_trivially_copyable::value, ""); + std::basic_string_view > s; + // expected-error-re@*:* {{static assertion failed{{.*}}Character type of basic_string_view must be trivially copyable}} + } + + { + // not trivially default constructible + static_assert(!std::is_trivially_default_constructible::value, ""); + std::basic_string_view > sv; + // expected-error-re@string_view:* {{static assertion failed{{.*}}Character type of basic_string_view must be trivially default constructible}} } { diff --git a/libcxx/test/std/time/time.zone/time.zone.zonedtraits/types.compile.pass.cpp b/libcxx/test/std/time/time.zone/time.zone.zonedtraits/types.compile.pass.cpp index 6e3410795c824..eff900fe4698b 100644 --- a/libcxx/test/std/time/time.zone/time.zone.zonedtraits/types.compile.pass.cpp +++ b/libcxx/test/std/time/time.zone/time.zone.zonedtraits/types.compile.pass.cpp @@ -24,10 +24,14 @@ // This test test whether non-specialized versions exhibit the expected // behavior. (Note these specializations are not really useful.) -static_assert(std::is_trivial_v>); -static_assert(std::is_trivial_v>); -static_assert(std::is_trivial_v>); +static_assert(std::is_trivially_copyable_v>); +static_assert(std::is_trivially_copyable_v>); +static_assert(std::is_trivially_copyable_v>); +static_assert(std::is_trivially_default_constructible_v>); +static_assert(std::is_trivially_default_constructible_v>); +static_assert(std::is_trivially_default_constructible_v>); struct foo {}; static_assert(std::is_empty_v>); -static_assert(std::is_trivial_v>); +static_assert(std::is_trivially_copyable_v>); +static_assert(std::is_trivially_default_constructible_v>); diff --git a/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp b/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp index 51fe5dc332e91..79b9294b7418a 100644 --- a/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp +++ b/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp @@ -43,7 +43,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 1, ""); static_assert(sizeof(T1) == 10, ""); @@ -56,7 +57,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 2, ""); static_assert(sizeof(T1) == 10, ""); @@ -69,7 +71,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 4, ""); static_assert(sizeof(T1) == 12, ""); @@ -82,7 +85,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 8, ""); static_assert(sizeof(T1) == 16, ""); @@ -95,7 +99,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 16, ""); static_assert(sizeof(T1) == 16, ""); @@ -108,7 +113,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 32, ""); static_assert(sizeof(T1) == 32, ""); @@ -121,7 +127,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 32, ""); static_assert(sizeof(T1) == 32, ""); @@ -134,7 +141,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 32, ""); static_assert(sizeof(T1) == 64, ""); @@ -147,7 +155,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 16, ""); static_assert(sizeof(T1) == 16, ""); @@ -160,7 +169,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 1, ""); static_assert(sizeof(T1) == 1, ""); @@ -173,7 +183,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 2, ""); static_assert(sizeof(T1) == 2, ""); @@ -186,7 +197,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 2, ""); static_assert(sizeof(T1) == 4, ""); @@ -199,7 +211,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 4, ""); static_assert(sizeof(T1) == 4, ""); @@ -212,7 +225,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 4, ""); static_assert(sizeof(T1) == 8, ""); @@ -222,7 +236,8 @@ int main(int, char**) #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<7>); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 4, ""); static_assert(sizeof(T1) == 8, ""); @@ -235,7 +250,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 8, ""); static_assert(sizeof(T1) == 8, ""); @@ -248,7 +264,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 8, ""); static_assert(sizeof(T1) == 16, ""); @@ -261,7 +278,8 @@ int main(int, char**) #if TEST_STD_VER <= 17 static_assert(std::is_pod::value, ""); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 8, ""); static_assert(sizeof(T1) == 16, ""); @@ -271,7 +289,8 @@ int main(int, char**) #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<16>); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); #if TEST_STD_VER >= 11 const std::size_t alignment = TEST_ALIGNOF(std::max_align_t) > 16 ? @@ -289,7 +308,8 @@ int main(int, char**) #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<17>); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); #if TEST_STD_VER >= 11 const std::size_t alignment = TEST_ALIGNOF(std::max_align_t) > 16 ? @@ -308,7 +328,8 @@ int main(int, char**) #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(T1, std::aligned_storage_t<10>); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 8, ""); static_assert(sizeof(T1) == 16, ""); @@ -316,7 +337,8 @@ int main(int, char**) { const int Align = 8192; typedef typename std::aligned_storage<1, Align>::type T1; - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == Align, ""); static_assert(sizeof(T1) == Align, ""); @@ -326,7 +348,8 @@ int main(int, char**) { const int Align = 65536; typedef typename std::aligned_storage<1, Align>::type T1; - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == Align, ""); static_assert(sizeof(T1) == Align, ""); diff --git a/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp b/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp index 73ca06532f082..943a3f6612a7c 100644 --- a/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp +++ b/libcxx/test/std/utilities/meta/meta.trans/meta.trans.other/aligned_union.pass.cpp @@ -26,7 +26,8 @@ int main(int, char**) #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(T1, std::aligned_union_t<10, char>); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 1, ""); static_assert(sizeof(T1) == 10, ""); @@ -36,7 +37,8 @@ int main(int, char**) #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(T1, std::aligned_union_t<10, short>); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 2, ""); static_assert(sizeof(T1) == 10, ""); @@ -46,7 +48,8 @@ int main(int, char**) #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(T1, std::aligned_union_t<10, int>); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 4, ""); static_assert(sizeof(T1) == 12, ""); @@ -56,7 +59,8 @@ int main(int, char**) #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(T1, std::aligned_union_t<10, double>); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 8, ""); static_assert(sizeof(T1) == 16, ""); @@ -66,7 +70,8 @@ int main(int, char**) #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(T1, std::aligned_union_t<10, short, char>); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 2, ""); static_assert(sizeof(T1) == 10, ""); @@ -76,7 +81,8 @@ int main(int, char**) #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(T1, std::aligned_union_t<10, char, short>); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 2, ""); static_assert(sizeof(T1) == 10, ""); @@ -86,7 +92,8 @@ int main(int, char**) #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(T1, std::aligned_union_t<2, int, char, short>); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 4, ""); static_assert(sizeof(T1) == 4, ""); @@ -96,7 +103,8 @@ int main(int, char**) #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(T1, std::aligned_union_t<2, char, int, short>); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 4, ""); static_assert(sizeof(T1) == 4, ""); @@ -106,7 +114,8 @@ int main(int, char**) #if TEST_STD_VER > 11 ASSERT_SAME_TYPE(T1, std::aligned_union_t<2, char, short, int>); #endif - static_assert(std::is_trivial::value, ""); + static_assert(std::is_trivially_copyable::value, ""); + static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); static_assert(std::alignment_of::value == 4, ""); static_assert(sizeof(T1) == 4, ""); diff --git a/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.deprecated.verify.cpp b/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.deprecated.verify.cpp new file mode 100644 index 0000000000000..5c9e6f4ec2332 --- /dev/null +++ b/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.deprecated.verify.cpp @@ -0,0 +1,20 @@ +//===----------------------------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +// REQUIRES: std-at-least-c++26 + +// + +// is_trivial and is_trivial_v are deprecated in C++26 by P3247R2 + +#include + +static_assert(std::is_trivial::value); +// expected-warning@-1 {{'is_trivial' is deprecated: Consider using is_trivially_copyable::value && is_trivially_default_constructible::value instead.}} +static_assert(std::is_trivial_v); +// expected-warning@-1 {{'is_trivial_v' is deprecated: Consider using is_trivially_copyable_v && is_trivially_default_constructible_v instead.}} diff --git a/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp b/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp index 8bb1b7c9b09dd..e09091ac9fd17 100644 --- a/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp +++ b/libcxx/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivial.pass.cpp @@ -10,6 +10,8 @@ // is_trivial +// ADDITIONAL_COMPILE_FLAGS: -D_LIBCPP_DISABLE_DEPRECATION_WARNINGS + #include #include "test_macros.h" diff --git a/libcxx/test/std/utilities/tuple/tuple.general/ignore.pass.cpp b/libcxx/test/std/utilities/tuple/tuple.general/ignore.pass.cpp index 525ffde5cf177..ea258de1a34ce 100644 --- a/libcxx/test/std/utilities/tuple/tuple.general/ignore.pass.cpp +++ b/libcxx/test/std/utilities/tuple/tuple.general/ignore.pass.cpp @@ -19,7 +19,8 @@ #include "test_macros.h" -static_assert(std::is_trivial::value, ""); +static_assert(std::is_trivially_copyable::value, ""); +static_assert(std::is_trivially_default_constructible::value, ""); #if TEST_STD_VER >= 17 [[nodiscard]] constexpr int test_nodiscard() { return 8294; } diff --git a/libcxx/test/support/nasty_string.h b/libcxx/test/support/nasty_string.h index ea9d83ccf282a..fa4c1b6764314 100644 --- a/libcxx/test/support/nasty_string.h +++ b/libcxx/test/support/nasty_string.h @@ -55,7 +55,8 @@ struct nasty_char { char c; }; -static_assert(std::is_trivial::value, ""); +static_assert(std::is_trivially_copyable::value, ""); +static_assert(std::is_trivially_default_constructible::value, ""); static_assert(std::is_standard_layout::value, ""); // These traits are based on the constexpr_traits test class. diff --git a/libcxxabi/src/demangle/ItaniumDemangle.h b/libcxxabi/src/demangle/ItaniumDemangle.h index 3df41b5f4d7d0..4122781beb599 100644 --- a/libcxxabi/src/demangle/ItaniumDemangle.h +++ b/libcxxabi/src/demangle/ItaniumDemangle.h @@ -38,8 +38,10 @@ DEMANGLE_NAMESPACE_BEGIN template class PODSmallVector { - static_assert(std::is_trivial::value, - "T is required to be a trivial type"); + static_assert(std::is_trivially_copyable::value, + "T is required to be a trivially copyable type"); + static_assert(std::is_trivially_default_constructible::value, + "T is required to be trivially default constructible"); T *First = nullptr; T *Last = nullptr; T *Cap = nullptr;