From 608a080c3f6e5a8338ff99658b27e226cbba7a67 Mon Sep 17 00:00:00 2001 From: Antony Polukhin Date: Fri, 31 May 2019 10:35:03 +0000 Subject: [PATCH] PR libstdc++/71579 assert that type traits are not misused with incomplete types This patch adds static asserts for type traits misuse with incomplete classes and unions. This gives a nice readable error message instead of an UB and odr-violations. Some features of the patch: * each type trait has it's own static_assert inside. This gives better diagnostics than the approach with putting the assert into a helper structure and using it in each trait. * the result of completeness check is not memorized by the compiler. This gives no false positive after the first failed check. * some of the compiler builtins already implement the check. But not all of them! So the asserts are in all the type_traits that may benefit from the check. This also makes the behavior of libstdc++ more consistent across different (non GCC) compilers. * std::is_base_of does not have the assert as it works well in many cases with incomplete types 2019-05-31 Antony Polukhin PR libstdc++/71579 * include/std/type_traits __type_identity, __is_complete_or_unbounded): New helpers for checking preconditions in traits. (is_trivial, is_trivially_copyable, is_standard_layout, is_pod) (is_literal_type, is_empty, is_polymorphic, is_final, is_abstract) (is_destructible, is_nothrow_destructible, is_constructible) (is_default_constructible, is_copy_constructible) (is_move_constructible, is_nothrow_default_constructible) (is_nothrow_constructible, is_nothrow_copy_constructible) (is_nothrow_move_constructible, is_copy_assignable, is_move_assignable) (is_nothrow_assignable, is_nothrow_copy_assignable) (is_nothrow_move_assignable, is_trivially_constructible) (is_trivially_copy_constructible, is_trivially_move_constructible) is_trivially_assignable, is_trivially_copy_assignable) (is_trivially_move_assignable, is_trivially_destructible) (alignment_of, is_swappable, is_nothrow_swappable, is_invocable) (is_invocable_r, is_nothrow_invocable) (has_unique_object_representations, is_aggregate): Add static_asserts to make sure that type traits are not misused with incomplete types. (__is_constructible_impl, __is_nothrow_default_constructible_impl) (__is_nothrow_constructible_impl, __is_nothrow_assignable_impl): New base characteristics without assertions that can be reused in other traits. * testsuite/20_util/is_complete_or_unbounded/memoization.cc: New test. * testsuite/20_util/is_complete_or_unbounded/memoization_neg.cc: New test. * testsuite/20_util/is_complete_or_unbounded/value.cc: New test. * testsuite/20_util/is_abstract/incomplete_neg.cc: New test. * testsuite/20_util/is_aggregate/incomplete_neg.cc: New test. * testsuite/20_util/is_class/value.cc: Check incomplete type. * testsuite/20_util/is_function/value.cc: Likewise. * testsuite/20_util/is_move_constructible/incomplete_neg.cc: New test. * testsuite/20_util/is_nothrow_move_assignable/incomplete_neg.cc: New test. * testsuite/20_util/is_polymorphic/incomplete_neg.cc: New test. * testsuite/20_util/is_reference/value.cc: Check incomplete types. * testsuite/20_util/is_unbounded_array/value.cc: Likewise. * testsuite/20_util/is_union/value.cc: Likewise. * testsuite/20_util/is_void/value.cc: Likewise. * testsuite/util/testsuite_tr1.h: Add incomplete union type. From-SVN: r271806 --- libstdc++-v3/ChangeLog | 43 +++ libstdc++-v3/include/std/type_traits | 334 +++++++++++++----- .../20_util/is_abstract/incomplete_neg.cc | 29 ++ .../20_util/is_aggregate/incomplete_neg.cc | 29 ++ .../testsuite/20_util/is_class/value.cc | 2 + .../is_complete_or_unbounded/memoization.cc | 29 ++ .../memoization_neg.cc | 27 ++ .../20_util/is_complete_or_unbounded/value.cc | 100 ++++++ .../testsuite/20_util/is_function/value.cc | 2 + .../is_move_constructible/incomplete_neg.cc | 29 ++ .../incomplete_neg.cc | 29 ++ .../20_util/is_polymorphic/incomplete_neg.cc | 29 ++ .../testsuite/20_util/is_reference/value.cc | 3 + .../20_util/is_unbounded_array/value.cc | 4 + .../testsuite/20_util/is_union/value.cc | 2 + .../testsuite/20_util/is_void/value.cc | 2 + libstdc++-v3/testsuite/util/testsuite_tr1.h | 2 + 17 files changed, 614 insertions(+), 81 deletions(-) create mode 100644 libstdc++-v3/testsuite/20_util/is_abstract/incomplete_neg.cc create mode 100644 libstdc++-v3/testsuite/20_util/is_aggregate/incomplete_neg.cc create mode 100644 libstdc++-v3/testsuite/20_util/is_complete_or_unbounded/memoization.cc create mode 100644 libstdc++-v3/testsuite/20_util/is_complete_or_unbounded/memoization_neg.cc create mode 100644 libstdc++-v3/testsuite/20_util/is_complete_or_unbounded/value.cc create mode 100644 libstdc++-v3/testsuite/20_util/is_move_constructible/incomplete_neg.cc create mode 100644 libstdc++-v3/testsuite/20_util/is_nothrow_move_assignable/incomplete_neg.cc create mode 100644 libstdc++-v3/testsuite/20_util/is_polymorphic/incomplete_neg.cc diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index 71ef811e052..3fe84943e7b 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,46 @@ +2019-05-31 Antony Polukhin + + PR libstdc++/71579 + * include/std/type_traits __type_identity, __is_complete_or_unbounded): + New helpers for checking preconditions in traits. + (is_trivial, is_trivially_copyable, is_standard_layout, is_pod) + (is_literal_type, is_empty, is_polymorphic, is_final, is_abstract) + (is_destructible, is_nothrow_destructible, is_constructible) + (is_default_constructible, is_copy_constructible) + (is_move_constructible, is_nothrow_default_constructible) + (is_nothrow_constructible, is_nothrow_copy_constructible) + (is_nothrow_move_constructible, is_copy_assignable, is_move_assignable) + (is_nothrow_assignable, is_nothrow_copy_assignable) + (is_nothrow_move_assignable, is_trivially_constructible) + (is_trivially_copy_constructible, is_trivially_move_constructible) + is_trivially_assignable, is_trivially_copy_assignable) + (is_trivially_move_assignable, is_trivially_destructible) + (alignment_of, is_swappable, is_nothrow_swappable, is_invocable) + (is_invocable_r, is_nothrow_invocable) + (has_unique_object_representations, is_aggregate): Add static_asserts + to make sure that type traits are not misused with incomplete types. + (__is_constructible_impl, __is_nothrow_default_constructible_impl) + (__is_nothrow_constructible_impl, __is_nothrow_assignable_impl): New + base characteristics without assertions that can be reused in other + traits. + * testsuite/20_util/is_complete_or_unbounded/memoization.cc: New test. + * testsuite/20_util/is_complete_or_unbounded/memoization_neg.cc: New + test. + * testsuite/20_util/is_complete_or_unbounded/value.cc: New test. + * testsuite/20_util/is_abstract/incomplete_neg.cc: New test. + * testsuite/20_util/is_aggregate/incomplete_neg.cc: New test. + * testsuite/20_util/is_class/value.cc: Check incomplete type. + * testsuite/20_util/is_function/value.cc: Likewise. + * testsuite/20_util/is_move_constructible/incomplete_neg.cc: New test. + * testsuite/20_util/is_nothrow_move_assignable/incomplete_neg.cc: New + test. + * testsuite/20_util/is_polymorphic/incomplete_neg.cc: New test. + * testsuite/20_util/is_reference/value.cc: Check incomplete types. + * testsuite/20_util/is_unbounded_array/value.cc: Likewise. + * testsuite/20_util/is_union/value.cc: Likewise. + * testsuite/20_util/is_void/value.cc: Likewise. + * testsuite/util/testsuite_tr1.h: Add incomplete union type. + 2019-05-31 Jonathan Wakely * include/bits/random.h (random_device::_M_init(const char*, size_t)): diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits index 3a622eb61e0..78a113af415 100644 --- a/libstdc++-v3/include/std/type_traits +++ b/libstdc++-v3/include/std/type_traits @@ -91,6 +91,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct conditional; + template + struct __type_identity { + using type = _Type; + }; + template struct __or_; @@ -177,6 +182,33 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION #endif // C++17 + // Forward declarations + template + struct is_reference; + template + struct is_function; + template + struct is_void; + template + struct __is_array_unknown_bounds; + + // Helper functions that return false_type for incomplete classes, + // incomplete unions and arrays of known bound from those. + + template + constexpr true_type __is_complete_or_unbounded(__type_identity<_T>) + { return {}; } + + template + constexpr typename __or_< + is_reference<_NestedType>, + is_function<_NestedType>, + is_void<_NestedType>, + __is_array_unknown_bounds<_NestedType> + >::type __is_complete_or_unbounded(_TypeIdentity) + { return {}; } + // For several sfinae-friendly trait implementations we transport both the // result information (as the member type) and the failure information (no // member type). This is very similar to std::enable_if, but we cannot use @@ -398,9 +430,6 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION struct is_rvalue_reference<_Tp&&> : public true_type { }; - template - struct is_function; - template struct __is_member_object_pointer_helper : public false_type { }; @@ -671,44 +700,65 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct is_trivial : public integral_constant - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; // is_trivially_copyable template struct is_trivially_copyable : public integral_constant - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// is_standard_layout template struct is_standard_layout : public integral_constant - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// is_pod // Could use is_standard_layout && is_trivial instead of the builtin. template struct is_pod : public integral_constant - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// is_literal_type template struct is_literal_type : public integral_constant - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// is_empty template struct is_empty : public integral_constant - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// is_polymorphic template struct is_polymorphic : public integral_constant - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; #if __cplusplus >= 201402L #define __cpp_lib_is_final 201402L @@ -716,14 +766,20 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct is_final : public integral_constant - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; #endif /// is_abstract template struct is_abstract : public integral_constant - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template::value> @@ -828,7 +884,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct is_destructible : public __is_destructible_safe<_Tp>::type - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; // is_nothrow_destructible requires that is_destructible is // satisfied as well. We realize that by mimicing the @@ -876,19 +935,33 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct is_nothrow_destructible : public __is_nt_destructible_safe<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + + template + struct __is_constructible_impl + : public __bool_constant<__is_constructible(_Tp, _Args...)> { }; /// is_constructible template struct is_constructible - : public __bool_constant<__is_constructible(_Tp, _Args...)> - { }; + : public __is_constructible_impl<_Tp, _Args...> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// is_default_constructible template struct is_default_constructible - : public is_constructible<_Tp>::type - { }; + : public __is_constructible_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template::value> struct __is_copy_constructible_impl; @@ -899,14 +972,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __is_copy_constructible_impl<_Tp, true> - : public is_constructible<_Tp, const _Tp&> + : public __is_constructible_impl<_Tp, const _Tp&> { }; /// is_copy_constructible template struct is_copy_constructible : public __is_copy_constructible_impl<_Tp> - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template::value> struct __is_move_constructible_impl; @@ -917,14 +993,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __is_move_constructible_impl<_Tp, true> - : public is_constructible<_Tp, _Tp&&> + : public __is_constructible_impl<_Tp, _Tp&&> { }; /// is_move_constructible template struct is_move_constructible : public __is_move_constructible_impl<_Tp> - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template struct __is_nt_default_constructible_atom @@ -946,12 +1025,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : public __is_nt_default_constructible_atom<_Tp> { }; + template + using __is_nothrow_default_constructible_impl + = __and_<__is_constructible_impl<_Tp>, + __is_nt_default_constructible_impl<_Tp>>; + /// is_nothrow_default_constructible template struct is_nothrow_default_constructible - : public __and_, - __is_nt_default_constructible_impl<_Tp>> - { }; + : public __is_nothrow_default_constructible_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template struct __is_nt_constructible_impl @@ -966,16 +1052,24 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __is_nt_constructible_impl<_Tp> - : public is_nothrow_default_constructible<_Tp> + : public __is_nothrow_default_constructible_impl<_Tp> { }; - /// is_nothrow_constructible template - struct is_nothrow_constructible - : public __and_, + struct __is_nothrow_constructible_impl + : public __and_<__is_constructible_impl<_Tp, _Args...>, __is_nt_constructible_impl<_Tp, _Args...>> { }; + /// is_nothrow_constructible + template + struct is_nothrow_constructible + : public __is_nothrow_constructible_impl<_Tp, _Args...>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + template::value> struct __is_nothrow_copy_constructible_impl; @@ -985,14 +1079,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __is_nothrow_copy_constructible_impl<_Tp, true> - : public is_nothrow_constructible<_Tp, const _Tp&> + : public __is_nothrow_constructible_impl<_Tp, const _Tp&> { }; /// is_nothrow_copy_constructible template struct is_nothrow_copy_constructible - : public __is_nothrow_copy_constructible_impl<_Tp> - { }; + : public __is_nothrow_copy_constructible_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template::value> struct __is_nothrow_move_constructible_impl; @@ -1003,20 +1100,26 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __is_nothrow_move_constructible_impl<_Tp, true> - : public is_nothrow_constructible<_Tp, _Tp&&> + : public __is_nothrow_constructible_impl<_Tp, _Tp&&> { }; /// is_nothrow_move_constructible template struct is_nothrow_move_constructible - : public __is_nothrow_move_constructible_impl<_Tp> - { }; + : public __is_nothrow_move_constructible_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// is_assignable template struct is_assignable - : public __bool_constant<__is_assignable(_Tp, _Up)> - { }; + : public __bool_constant<__is_assignable(_Tp, _Up)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template::value> struct __is_copy_assignable_impl; @@ -1027,14 +1130,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __is_copy_assignable_impl<_Tp, true> - : public is_assignable<_Tp&, const _Tp&> + : public __bool_constant<__is_assignable(_Tp&, const _Tp&)> { }; /// is_copy_assignable template struct is_copy_assignable - : public __is_copy_assignable_impl<_Tp> - { }; + : public __is_copy_assignable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template::value> struct __is_move_assignable_impl; @@ -1045,27 +1151,38 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __is_move_assignable_impl<_Tp, true> - : public is_assignable<_Tp&, _Tp&&> + : public __bool_constant<__is_assignable(_Tp&, _Tp&&)> { }; /// is_move_assignable template struct is_move_assignable - : public __is_move_assignable_impl<_Tp> - { }; + : public __is_move_assignable_impl<_Tp>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template struct __is_nt_assignable_impl : public integral_constant() = declval<_Up>())> { }; - /// is_nothrow_assignable template - struct is_nothrow_assignable - : public __and_, + struct __is_nothrow_assignable_impl + : public __and_<__bool_constant<__is_assignable(_Tp, _Up)>, __is_nt_assignable_impl<_Tp, _Up>> { }; + /// is_nothrow_assignable + template + struct is_nothrow_assignable + : public __is_nothrow_assignable_impl<_Tp, _Up> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; + template::value> struct __is_nt_copy_assignable_impl; @@ -1075,14 +1192,17 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __is_nt_copy_assignable_impl<_Tp, true> - : public is_nothrow_assignable<_Tp&, const _Tp&> + : public __is_nothrow_assignable_impl<_Tp&, const _Tp&> { }; /// is_nothrow_copy_assignable template struct is_nothrow_copy_assignable : public __is_nt_copy_assignable_impl<_Tp> - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template::value> struct __is_nt_move_assignable_impl; @@ -1093,26 +1213,35 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __is_nt_move_assignable_impl<_Tp, true> - : public is_nothrow_assignable<_Tp&, _Tp&&> + : public __is_nothrow_assignable_impl<_Tp&, _Tp&&> { }; /// is_nothrow_move_assignable template struct is_nothrow_move_assignable : public __is_nt_move_assignable_impl<_Tp> - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// is_trivially_constructible template struct is_trivially_constructible : public __bool_constant<__is_trivially_constructible(_Tp, _Args...)> - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// is_trivially_default_constructible template struct is_trivially_default_constructible - : public is_trivially_constructible<_Tp>::type - { }; + : public __bool_constant<__is_trivially_constructible(_Tp)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; struct __do_is_implicitly_default_constructible_impl { @@ -1140,12 +1269,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __is_implicitly_default_constructible - : public __and_, + : public __and_<__is_constructible_impl<_Tp>, __is_implicitly_default_constructible_safe<_Tp>> { }; - /// is_trivially_copy_constructible - template::value> struct __is_trivially_copy_constructible_impl; @@ -1155,17 +1282,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __is_trivially_copy_constructible_impl<_Tp, true> - : public __and_, + : public __and_<__is_copy_constructible_impl<_Tp>, integral_constant> { }; + /// is_trivially_copy_constructible template struct is_trivially_copy_constructible : public __is_trivially_copy_constructible_impl<_Tp> - { }; - - /// is_trivially_move_constructible + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template::value> struct __is_trivially_move_constructible_impl; @@ -1176,23 +1305,28 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct __is_trivially_move_constructible_impl<_Tp, true> - : public __and_, + : public __and_<__is_move_constructible_impl<_Tp>, integral_constant> { }; + /// is_trivially_move_constructible template struct is_trivially_move_constructible : public __is_trivially_move_constructible_impl<_Tp> - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// is_trivially_assignable template struct is_trivially_assignable : public __bool_constant<__is_trivially_assignable(_Tp, _Up)> - { }; - - /// is_trivially_copy_assignable + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template::value> struct __is_trivially_copy_assignable_impl; @@ -1206,12 +1340,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : public __bool_constant<__is_trivially_assignable(_Tp&, const _Tp&)> { }; + /// is_trivially_copy_assignable template struct is_trivially_copy_assignable : public __is_trivially_copy_assignable_impl<_Tp> - { }; - - /// is_trivially_move_assignable + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template::value> struct __is_trivially_move_assignable_impl; @@ -1225,24 +1361,34 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : public __bool_constant<__is_trivially_assignable(_Tp&, _Tp&&)> { }; + /// is_trivially_move_assignable template struct is_trivially_move_assignable : public __is_trivially_move_assignable_impl<_Tp> - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// is_trivially_destructible template struct is_trivially_destructible - : public __and_, + : public __and_<__is_destructible_safe<_Tp>, __bool_constant<__has_trivial_destructor(_Tp)>> - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// has_virtual_destructor template struct has_virtual_destructor : public integral_constant - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; // type property queries. @@ -1250,7 +1396,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// alignment_of template struct alignment_of - : public integral_constant { }; + : public integral_constant + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// rank template @@ -1336,7 +1486,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : public __is_convertible_helper<_From, _To>::type { }; - template, is_function<_To>, is_array<_To>>::value> struct __is_nt_convertible_helper @@ -2577,13 +2727,19 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct is_swappable : public __is_swappable_impl<_Tp>::type - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// is_nothrow_swappable template struct is_nothrow_swappable : public __is_nothrow_swappable_impl<_Tp>::type - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; #if __cplusplus >= 201402L /// is_swappable_v @@ -2774,20 +2930,29 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION template struct is_invocable : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + }; /// std::is_invocable_r template struct is_invocable_r : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + }; /// std::is_nothrow_invocable template struct is_nothrow_invocable : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>, - __call_is_nothrow_<_Fn, _ArgTypes...>>::type - { }; + __call_is_nothrow_<_Fn, _ArgTypes...>>::type + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}), + "_Fn must be a complete class or an unbounded array"); + }; template struct __is_nt_invocable_impl : false_type { }; @@ -2993,7 +3158,10 @@ template : bool_constant<__has_unique_object_representations( remove_cv_t> )> - { }; + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; template inline constexpr bool has_unique_object_representations_v @@ -3005,7 +3173,11 @@ template /// is_aggregate template struct is_aggregate - : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> { }; + : bool_constant<__is_aggregate(remove_cv_t<_Tp>)> + { + static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}), + "template argument must be a complete class or an unbounded array"); + }; /// is_aggregate_v template diff --git a/libstdc++-v3/testsuite/20_util/is_abstract/incomplete_neg.cc b/libstdc++-v3/testsuite/20_util/is_abstract/incomplete_neg.cc new file mode 100644 index 00000000000..94f4ecd6000 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_abstract/incomplete_neg.cc @@ -0,0 +1,29 @@ +// { dg-do compile { target c++11 } } +// { dg-prune-output "invalid use of incomplete type" } +// { dg-prune-output "must be a complete" } +// +// Copyright (C) 2019 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include + +class X; + +void test01() +{ + std::is_abstract(); // { dg-error "required from here" } +} diff --git a/libstdc++-v3/testsuite/20_util/is_aggregate/incomplete_neg.cc b/libstdc++-v3/testsuite/20_util/is_aggregate/incomplete_neg.cc new file mode 100644 index 00000000000..8a3dd551cbb --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_aggregate/incomplete_neg.cc @@ -0,0 +1,29 @@ +// { dg-do compile { target c++17 } } +// +// Copyright (C) 2019 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +// { dg-error "must be a complete class" "" { target *-*-* } 0 } + +#include + +class X; + +void test01() +{ + std::is_aggregate(); // { dg-error "required from here" } +} diff --git a/libstdc++-v3/testsuite/20_util/is_class/value.cc b/libstdc++-v3/testsuite/20_util/is_class/value.cc index 6391e286147..801dc679a21 100644 --- a/libstdc++-v3/testsuite/20_util/is_class/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_class/value.cc @@ -27,6 +27,7 @@ void test01() // Positive tests. static_assert(test_category(true), ""); + static_assert(test_category(true), ""); static_assert(test_category(true), ""); static_assert(test_category(true), ""); static_assert(test_category(true), ""); @@ -47,4 +48,5 @@ void test01() static_assert(test_category(false), ""); static_assert(test_category(false), ""); static_assert(test_category(false), ""); + static_assert(test_category(false), ""); } diff --git a/libstdc++-v3/testsuite/20_util/is_complete_or_unbounded/memoization.cc b/libstdc++-v3/testsuite/20_util/is_complete_or_unbounded/memoization.cc new file mode 100644 index 00000000000..83afb40cd18 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_complete_or_unbounded/memoization.cc @@ -0,0 +1,29 @@ +// { dg-do compile { target c++11 } } + +// Copyright (C) 2019 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include + +struct X; +static_assert( + !std::__is_complete_or_unbounded(std::__type_identity{}), "error"); + +struct X{}; +static_assert( + std::__is_complete_or_unbounded(std::__type_identity{}), + "Result memoized. This leads to worse diagnostics"); diff --git a/libstdc++-v3/testsuite/20_util/is_complete_or_unbounded/memoization_neg.cc b/libstdc++-v3/testsuite/20_util/is_complete_or_unbounded/memoization_neg.cc new file mode 100644 index 00000000000..04b83a21c01 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_complete_or_unbounded/memoization_neg.cc @@ -0,0 +1,27 @@ +// { dg-do compile { target c++11 } } +// { dg-prune-output "must be a complete" } + +// Copyright (C) 2019 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include + +struct X; +constexpr bool res_incomplete = std::is_move_constructible::value; // { dg-error "required from here" } + +struct X{}; +constexpr bool res_complete = std::is_default_constructible::value; // { dg-bogus "required from here" } diff --git a/libstdc++-v3/testsuite/20_util/is_complete_or_unbounded/value.cc b/libstdc++-v3/testsuite/20_util/is_complete_or_unbounded/value.cc new file mode 100644 index 00000000000..5a03ad67a30 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_complete_or_unbounded/value.cc @@ -0,0 +1,100 @@ +// { dg-do compile { target c++11 } } + +// Copyright (C) 2019 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include + + +struct incomplete_type; +class incomplete_type2; +union incomplete_union; +enum class incomplete_enum: int; +enum incomplete_enum2: int; +static_assert(!std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(!std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(!std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); + +static_assert(!std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(!std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(!std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); + +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); + + +struct complete_type{ ~complete_type() = delete; }; +class complete_type2{ int i; }; +union complete_union{}; +enum class complete_enum: int {}; +enum complete_enum2: int {}; +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); + +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); + +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); + + +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); + +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); + +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); + +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); +static_assert(std::__is_complete_or_unbounded(std::__type_identity{}), ""); diff --git a/libstdc++-v3/testsuite/20_util/is_function/value.cc b/libstdc++-v3/testsuite/20_util/is_function/value.cc index cef2e3de2a1..7b94b58b6cb 100644 --- a/libstdc++-v3/testsuite/20_util/is_function/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_function/value.cc @@ -46,4 +46,6 @@ void test01() // Sanity check. static_assert(test_category(false), ""); + static_assert(test_category(false), ""); + static_assert(test_category(false), ""); } diff --git a/libstdc++-v3/testsuite/20_util/is_move_constructible/incomplete_neg.cc b/libstdc++-v3/testsuite/20_util/is_move_constructible/incomplete_neg.cc new file mode 100644 index 00000000000..d6a08d77639 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_move_constructible/incomplete_neg.cc @@ -0,0 +1,29 @@ +// { dg-do compile { target c++11 } } +// +// Copyright (C) 2019 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +// { dg-error "must be a complete class" "" { target *-*-* } 0 } + +#include + +class X; + +void test01() +{ + std::is_move_constructible(); // { dg-error "required from here" } +} diff --git a/libstdc++-v3/testsuite/20_util/is_nothrow_move_assignable/incomplete_neg.cc b/libstdc++-v3/testsuite/20_util/is_nothrow_move_assignable/incomplete_neg.cc new file mode 100644 index 00000000000..ebceec5474b --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_nothrow_move_assignable/incomplete_neg.cc @@ -0,0 +1,29 @@ +// { dg-do compile { target c++11 } } +// +// Copyright (C) 2019 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +// { dg-error "must be a complete class" "" { target *-*-* } 0 } + +#include + +class X; + +void test01() +{ + std::is_nothrow_move_assignable(); // { dg-error "required from here" } +} diff --git a/libstdc++-v3/testsuite/20_util/is_polymorphic/incomplete_neg.cc b/libstdc++-v3/testsuite/20_util/is_polymorphic/incomplete_neg.cc new file mode 100644 index 00000000000..8cd1b402a41 --- /dev/null +++ b/libstdc++-v3/testsuite/20_util/is_polymorphic/incomplete_neg.cc @@ -0,0 +1,29 @@ +// { dg-do compile { target c++11 } } +// { dg-prune-output "invalid use of incomplete type" } +// { dg-prune-output "must be a complete" } +// +// Copyright (C) 2019 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 3, or (at your option) +// any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING3. If not see +// . + +#include + +class X; + +void test01() +{ + std::is_polymorphic(); // { dg-error "required from here" } +} diff --git a/libstdc++-v3/testsuite/20_util/is_reference/value.cc b/libstdc++-v3/testsuite/20_util/is_reference/value.cc index 79a99737eab..4676894a5e9 100644 --- a/libstdc++-v3/testsuite/20_util/is_reference/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_reference/value.cc @@ -33,8 +33,11 @@ void test01() static_assert(test_category(true), ""); static_assert(test_category(true), ""); static_assert(test_category(true), ""); + static_assert(test_category(true), ""); + static_assert(test_category(true), ""); // Sanity check. static_assert(test_category(false), ""); + static_assert(test_category(false), ""); } diff --git a/libstdc++-v3/testsuite/20_util/is_unbounded_array/value.cc b/libstdc++-v3/testsuite/20_util/is_unbounded_array/value.cc index 19fb0524cd8..bca0e3cb82e 100644 --- a/libstdc++-v3/testsuite/20_util/is_unbounded_array/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_unbounded_array/value.cc @@ -44,6 +44,8 @@ void test01() static_assert(test_category(true), ""); static_assert(test_category(false), ""); static_assert(test_category(true), ""); + static_assert(test_category(false), ""); + static_assert(test_category(true), ""); static_assert(test_category(false), ""); static_assert(test_category(false), ""); static_assert(test_category(false), ""); @@ -51,6 +53,8 @@ void test01() // Sanity check. static_assert(test_category(false), ""); + static_assert(test_category(false), ""); + static_assert(test_category(false), ""); } template void pos() diff --git a/libstdc++-v3/testsuite/20_util/is_union/value.cc b/libstdc++-v3/testsuite/20_util/is_union/value.cc index 7d0f2011fca..54df151e025 100644 --- a/libstdc++-v3/testsuite/20_util/is_union/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_union/value.cc @@ -27,6 +27,7 @@ void test01() // Positive tests. static_assert(test_category(true), ""); + static_assert(test_category(true), ""); // Negative tests. static_assert(test_category(false), ""); @@ -47,4 +48,5 @@ void test01() static_assert(test_category(false), ""); static_assert(test_category(false), ""); static_assert(test_category(false), ""); + static_assert(test_category(false), ""); } diff --git a/libstdc++-v3/testsuite/20_util/is_void/value.cc b/libstdc++-v3/testsuite/20_util/is_void/value.cc index f04cdd61ad7..dc116f7ad09 100644 --- a/libstdc++-v3/testsuite/20_util/is_void/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_void/value.cc @@ -47,4 +47,6 @@ void test01() // Sanity check. static_assert(test_category(false), ""); + static_assert(test_category(false), ""); + static_assert(test_category(false), ""); } diff --git a/libstdc++-v3/testsuite/util/testsuite_tr1.h b/libstdc++-v3/testsuite/util/testsuite_tr1.h index b431682a06e..2e1cbb096b0 100644 --- a/libstdc++-v3/testsuite/util/testsuite_tr1.h +++ b/libstdc++-v3/testsuite/util/testsuite_tr1.h @@ -126,6 +126,8 @@ namespace __gnu_test union UnionType { }; + union IncompleteUnion; + class IncompleteClass; struct ExplicitClass -- 2.30.2