From b42cc3ca244ea57d5112638a73e7f83c58202a84 Mon Sep 17 00:00:00 2001 From: Ville Voutilainen Date: Wed, 17 May 2017 16:54:23 +0300 Subject: [PATCH] Implement new C++ intrinsics __is_assignable and __is_constructible. c-family/ Implement new C++ intrinsics __is_assignable and __is_constructible. * c-common.c (__is_assignable, __is_constructible): New. * c-common.h (RID_IS_ASSIGNABLE, RID_IS_CONSTRUCTIBLE): Likewise. cp/ PR c++/80654 PR c++/80682 Implement new C++ intrinsics __is_assignable and __is_constructible. * cp-tree.h (CPTK_IS_ASSIGNABLE, CPTK_IS_CONSTRUCTIBLE): New. (is_xible): New. * cxx-pretty-print.c (pp_cxx_trait_expression): Handle CPTK_IS_ASSIGNABLE and CPTK_IS_CONSTRUCTIBLE. * method.c (constructible_expr): Set cp_unevaluated. (is_xible_helper): New. (is_trivially_xible): Adjust. (is_xible): New. * parser.c (cp_parser_primary_expression): Handle RID_IS_ASSIGNABLE and RID_IS_CONSTRUCTIBLE. (cp_parser_trait_expr): Likewise. * semantics.c (trait_expr_value): Handle CPTK_IS_ASSIGNABLE and CPTK_IS_CONSTRUCTIBLE. testsuite/ * g++.dg/ext/80654.C: New. libstdc++-v3/ Implement new C++ intrinsics __is_assignable and __is_constructible. * include/std/type_traits (__do_is_static_castable_impl): Remove. (__is_static_castable_impl, __is_static_castable_safe): Likewise. (__is_static_castable, __do_is_direct_constructible_impl): Likewise. (__is_direct_constructible_impl): Likewise. (__is_direct_constructible_new_safe): Likewise. (__is_base_to_derived_ref, __is_lvalue_to_rvalue_ref): Likewise. (__is_direct_constructible_ref_cast): Likewise. (__is_direct_constructible_new, __is_direct_constructible): Likewise. (__do_is_nary_constructible_impl): Likewise. (__is_nary_constructible_impl, __is_nary_constructible): Likewise. (__is_constructible_impl): Likewise. (is_constructible): Call the intrinsic. (__is_assignable_helper): Remove. (is_assignable): Call the intrinsic. (is_trivially_constructible): Likewise. (__is_trivially_copy_constructible_impl): New. (is_trivially_copy_constructible): Use it. (__is_trivially_move_constructible_impl): New. (is_trivially_move_constructible): Use it. (is_trivially_assignable): Call the intrinsic. (__is_trivially_copy_assignable_impl): New. (is_trivially_copy_assignable): Use it. (__is_trivially_move_assignable_impl): New. (is_trivially_move_assignable): Use it. (testsuite/20_util/declval/requirements/1_neg.cc): Adjust. (testsuite/20_util/is_trivially_copy_assignable/value.cc): Add test for void. (testsuite/20_util/is_trivially_copy_constructible/value.cc): Likewise. (testsuite/20_util/is_trivially_move_assignable/value.cc): Likewise. (testsuite/20_util/is_trivially_move_constructible/value.cc): Likewise. (testsuite/20_util/make_signed/requirements/typedefs_neg.cc): Adjust. (testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc): Likewise. From-SVN: r248153 --- gcc/c-family/ChangeLog | 6 + gcc/c-family/c-common.c | 2 + gcc/c-family/c-common.h | 1 + gcc/cp/ChangeLog | 19 ++ gcc/cp/cp-tree.h | 5 +- gcc/cp/cxx-pretty-print.c | 6 + gcc/cp/method.c | 42 ++- gcc/cp/parser.c | 10 + gcc/cp/semantics.c | 10 + gcc/testsuite/g++.dg/ext/80654.C | 18 ++ libstdc++-v3/ChangeLog | 37 +++ libstdc++-v3/include/std/type_traits | 290 ++++-------------- .../20_util/declval/requirements/1_neg.cc | 2 +- .../is_trivially_copy_assignable/value.cc | 2 + .../is_trivially_copy_constructible/value.cc | 2 + .../is_trivially_move_assignable/value.cc | 2 + .../is_trivially_move_constructible/value.cc | 2 + .../make_signed/requirements/typedefs_neg.cc | 2 +- .../requirements/typedefs_neg.cc | 4 +- 19 files changed, 220 insertions(+), 242 deletions(-) create mode 100644 gcc/testsuite/g++.dg/ext/80654.C diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index 4b1c226da813..428d733da1a3 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,9 @@ +2017-05-17 Ville Voutilainen + + Implement new C++ intrinsics __is_assignable and __is_constructible. + * c-common.c (__is_assignable, __is_constructible): New. + * c-common.h (RID_IS_ASSIGNABLE, RID_IS_CONSTRUCTIBLE): Likewise. + 2017-05-17 Martin Liska * c-common.h: Introduce dump_flags_t type and diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c index f606e948ae51..a3c63d74d00f 100644 --- a/gcc/c-family/c-common.c +++ b/gcc/c-family/c-common.c @@ -514,6 +514,8 @@ const struct c_common_resword c_common_reswords[] = { "volatile", RID_VOLATILE, 0 }, { "wchar_t", RID_WCHAR, D_CXXONLY }, { "while", RID_WHILE, 0 }, + { "__is_assignable", RID_IS_ASSIGNABLE, D_CXXONLY }, + { "__is_constructible", RID_IS_CONSTRUCTIBLE, D_CXXONLY }, /* C++ transactional memory. */ { "synchronized", RID_SYNCHRONIZED, D_CXX_OBJC | D_TRANSMEM }, diff --git a/gcc/c-family/c-common.h b/gcc/c-family/c-common.h index 5ce3b458af3d..3023b07af673 100644 --- a/gcc/c-family/c-common.h +++ b/gcc/c-family/c-common.h @@ -172,6 +172,7 @@ enum rid RID_IS_TRIVIALLY_ASSIGNABLE, RID_IS_TRIVIALLY_CONSTRUCTIBLE, RID_IS_TRIVIALLY_COPYABLE, RID_IS_UNION, RID_UNDERLYING_TYPE, + RID_IS_ASSIGNABLE, RID_IS_CONSTRUCTIBLE, /* C++11 */ RID_CONSTEXPR, RID_DECLTYPE, RID_NOEXCEPT, RID_NULLPTR, RID_STATIC_ASSERT, diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 7136b5d8946e..f657194f419e 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,22 @@ +2017-05-17 Ville Voutilainen + + PR c++/80654 + PR c++/80682 + Implement new C++ intrinsics __is_assignable and __is_constructible. + * cp-tree.h (CPTK_IS_ASSIGNABLE, CPTK_IS_CONSTRUCTIBLE): New. + (is_xible): New. + * cxx-pretty-print.c (pp_cxx_trait_expression): Handle + CPTK_IS_ASSIGNABLE and CPTK_IS_CONSTRUCTIBLE. + * method.c (constructible_expr): Set cp_unevaluated. + (is_xible_helper): New. + (is_trivially_xible): Adjust. + (is_xible): New. + * parser.c (cp_parser_primary_expression): Handle + RID_IS_ASSIGNABLE and RID_IS_CONSTRUCTIBLE. + (cp_parser_trait_expr): Likewise. + * semantics.c (trait_expr_value): Handle + CPTK_IS_ASSIGNABLE and CPTK_IS_CONSTRUCTIBLE. + 2017-05-17 Nathan Sidwell * cp-tree.h (ovl_iterator::using_p): New predicate. diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 942ac6195b6d..921118635a68 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -1016,7 +1016,9 @@ enum cp_trait_kind CPTK_IS_TRIVIALLY_CONSTRUCTIBLE, CPTK_IS_TRIVIALLY_COPYABLE, CPTK_IS_UNION, - CPTK_UNDERLYING_TYPE + CPTK_UNDERLYING_TYPE, + CPTK_IS_ASSIGNABLE, + CPTK_IS_CONSTRUCTIBLE }; /* The types that we are processing. */ @@ -6227,6 +6229,7 @@ extern void use_thunk (tree, bool); extern bool trivial_fn_p (tree); extern tree forward_parm (tree); extern bool is_trivially_xible (enum tree_code, tree, tree); +extern bool is_xible (enum tree_code, tree, tree); extern tree get_defaulted_eh_spec (tree); extern tree unevaluated_noexcept_spec (void); extern void after_nsdmi_defaulted_late_checks (tree); diff --git a/gcc/cp/cxx-pretty-print.c b/gcc/cp/cxx-pretty-print.c index e92a72af1292..b74a56f42000 100644 --- a/gcc/cp/cxx-pretty-print.c +++ b/gcc/cp/cxx-pretty-print.c @@ -2634,6 +2634,12 @@ pp_cxx_trait_expression (cxx_pretty_printer *pp, tree t) case CPTK_IS_LITERAL_TYPE: pp_cxx_ws_string (pp, "__is_literal_type"); break; + case CPTK_IS_ASSIGNABLE: + pp_cxx_ws_string (pp, "__is_assignable"); + break; + case CPTK_IS_CONSTRUCTIBLE: + pp_cxx_ws_string (pp, "__is_constructible"); + break; default: gcc_unreachable (); diff --git a/gcc/cp/method.c b/gcc/cp/method.c index 9898ff190897..756b59dc354b 100644 --- a/gcc/cp/method.c +++ b/gcc/cp/method.c @@ -1162,6 +1162,7 @@ constructible_expr (tree to, tree from) { tree ctype = to; vec *args = NULL; + cp_unevaluated cp_uneval_guard; if (TREE_CODE (to) != REFERENCE_TYPE) to = cp_build_reference_type (to, /*rval*/false); tree ob = build_stub_object (to); @@ -1198,22 +1199,36 @@ constructible_expr (tree to, tree from) return expr; } -/* Returns true iff TO is trivially assignable (if CODE is MODIFY_EXPR) or +/* Returns a tree iff TO is assignable (if CODE is MODIFY_EXPR) or constructible (otherwise) from FROM, which is a single type for assignment or a list of types for construction. */ -bool -is_trivially_xible (enum tree_code code, tree to, tree from) +static tree +is_xible_helper (enum tree_code code, tree to, tree from, bool trivial) { - if (VOID_TYPE_P (to)) - return false; + if (VOID_TYPE_P (to) || ABSTRACT_CLASS_TYPE_P (to) + || (from && FUNC_OR_METHOD_TYPE_P (from) + && (TYPE_READONLY (from) || FUNCTION_REF_QUALIFIED (from)))) + return error_mark_node; tree expr; if (code == MODIFY_EXPR) expr = assignable_expr (to, from); - else if (from && TREE_CHAIN (from)) - return false; // only 0- and 1-argument ctors can be trivial + else if (trivial && from && TREE_CHAIN (from)) + return error_mark_node; // only 0- and 1-argument ctors can be trivial else expr = constructible_expr (to, from); + return expr; +} + +/* Returns true iff TO is trivially assignable (if CODE is MODIFY_EXPR) or + constructible (otherwise) from FROM, which is a single type for + assignment or a list of types for construction. */ + +bool +is_trivially_xible (enum tree_code code, tree to, tree from) +{ + tree expr; + expr = is_xible_helper (code, to, from, /*trivial*/true); if (expr == error_mark_node) return false; @@ -1221,6 +1236,19 @@ is_trivially_xible (enum tree_code code, tree to, tree from) return !nt; } +/* Returns true iff TO is assignable (if CODE is MODIFY_EXPR) or + constructible (otherwise) from FROM, which is a single type for + assignment or a list of types for construction. */ + +bool +is_xible (enum tree_code code, tree to, tree from) +{ + tree expr = is_xible_helper (code, to, from, /*trivial*/false); + if (expr == error_mark_node) + return false; + return !!expr; +} + /* Subroutine of synthesized_method_walk. Update SPEC_P, TRIVIAL_P and DELETED_P or give an error message MSG with argument ARG. */ diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 7ba20752b6a6..7a87a5e623d5 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -5135,6 +5135,8 @@ cp_parser_primary_expression (cp_parser *parser, case RID_IS_TRIVIALLY_CONSTRUCTIBLE: case RID_IS_TRIVIALLY_COPYABLE: case RID_IS_UNION: + case RID_IS_ASSIGNABLE: + case RID_IS_CONSTRUCTIBLE: return cp_parser_trait_expr (parser, token->keyword); // C++ concepts @@ -9686,6 +9688,14 @@ cp_parser_trait_expr (cp_parser* parser, enum rid keyword) case RID_DIRECT_BASES: kind = CPTK_DIRECT_BASES; break; + case RID_IS_ASSIGNABLE: + kind = CPTK_IS_ASSIGNABLE; + binary = true; + break; + case RID_IS_CONSTRUCTIBLE: + kind = CPTK_IS_CONSTRUCTIBLE; + variadic = true; + break; default: gcc_unreachable (); } diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index d3249fedd8d8..fa02b27145ac 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -9211,6 +9211,12 @@ trait_expr_value (cp_trait_kind kind, tree type1, tree type2) case CPTK_IS_UNION: return type_code1 == UNION_TYPE; + case CPTK_IS_ASSIGNABLE: + return is_xible (MODIFY_EXPR, type1, type2); + + case CPTK_IS_CONSTRUCTIBLE: + return is_xible (INIT_EXPR, type1, type2); + default: gcc_unreachable (); return false; @@ -9284,6 +9290,10 @@ finish_trait_expr (cp_trait_kind kind, tree type1, tree type2) return error_mark_node; break; + case CPTK_IS_ASSIGNABLE: + case CPTK_IS_CONSTRUCTIBLE: + break; + case CPTK_IS_TRIVIALLY_ASSIGNABLE: case CPTK_IS_TRIVIALLY_CONSTRUCTIBLE: if (!check_trait_type (type1) diff --git a/gcc/testsuite/g++.dg/ext/80654.C b/gcc/testsuite/g++.dg/ext/80654.C new file mode 100644 index 000000000000..8679613e966d --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/80654.C @@ -0,0 +1,18 @@ +// { dg-do compile { target c++11 } } + +template struct wrap +{ + T t; + wrap(const wrap& other) : t(other.t) {} +}; + +struct nocopy { + nocopy (const nocopy&) = delete; +}; + +int main () +{ + static_assert(!__is_trivially_constructible(wrap, + const wrap&), ""); + return 0; +} diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index c32dc62abca8..98d363acc2e1 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,40 @@ +2017-05-17 Ville Voutilainen + + Implement new C++ intrinsics __is_assignable and __is_constructible. + * include/std/type_traits (__do_is_static_castable_impl): Remove. + (__is_static_castable_impl, __is_static_castable_safe): Likewise. + (__is_static_castable, __do_is_direct_constructible_impl): Likewise. + (__is_direct_constructible_impl): Likewise. + (__is_direct_constructible_new_safe): Likewise. + (__is_base_to_derived_ref, __is_lvalue_to_rvalue_ref): Likewise. + (__is_direct_constructible_ref_cast): Likewise. + (__is_direct_constructible_new, __is_direct_constructible): Likewise. + (__do_is_nary_constructible_impl): Likewise. + (__is_nary_constructible_impl, __is_nary_constructible): Likewise. + (__is_constructible_impl): Likewise. + (is_constructible): Call the intrinsic. + (__is_assignable_helper): Remove. + (is_assignable): Call the intrinsic. + (is_trivially_constructible): Likewise. + (__is_trivially_copy_constructible_impl): New. + (is_trivially_copy_constructible): Use it. + (__is_trivially_move_constructible_impl): New. + (is_trivially_move_constructible): Use it. + (is_trivially_assignable): Call the intrinsic. + (__is_trivially_copy_assignable_impl): New. + (is_trivially_copy_assignable): Use it. + (__is_trivially_move_assignable_impl): New. + (is_trivially_move_assignable): Use it. + (testsuite/20_util/declval/requirements/1_neg.cc): Adjust. + (testsuite/20_util/is_trivially_copy_assignable/value.cc): + Add test for void. + (testsuite/20_util/is_trivially_copy_constructible/value.cc): Likewise. + (testsuite/20_util/is_trivially_move_assignable/value.cc): Likewise. + (testsuite/20_util/is_trivially_move_constructible/value.cc): Likewise. + (testsuite/20_util/make_signed/requirements/typedefs_neg.cc): Adjust. + (testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc): + Likewise. + 2017-05-16 Jonathan Wakely * testsuite/experimental/source_location/1.cc: Change expected result diff --git a/libstdc++-v3/include/std/type_traits b/libstdc++-v3/include/std/type_traits index aac7cff6cf61..390b6f40af50 100644 --- a/libstdc++-v3/include/std/type_traits +++ b/libstdc++-v3/include/std/type_traits @@ -924,213 +924,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : public __is_default_constructible_safe<_Tp>::type { }; - - // Implementation of is_constructible. - - // The hardest part of this trait is the binary direct-initialization - // case, because we hit into a functional cast of the form T(arg). - // This implementation uses different strategies depending on the - // target type to reduce the test overhead as much as possible: - // - // a) For a reference target type, we use a static_cast expression - // modulo its extra cases. - // - // b) For a non-reference target type we use a ::new expression. - struct __do_is_static_castable_impl - { - template(declval<_From>()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_static_castable_impl - : public __do_is_static_castable_impl - { - typedef decltype(__test<_From, _To>(0)) type; - }; - - template - struct __is_static_castable_safe - : public __is_static_castable_impl<_From, _To>::type - { }; - - // __is_static_castable - template - struct __is_static_castable - : public integral_constant::value)> - { }; - - // Implementation for non-reference types. To meet the proper - // variable definition semantics, we also need to test for - // is_destructible in this case. - // This form should be simplified by a single expression: - // ::delete ::new _Tp(declval<_Arg>()), see c++/51222. - struct __do_is_direct_constructible_impl - { - template()))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_direct_constructible_impl - : public __do_is_direct_constructible_impl - { - typedef decltype(__test<_Tp, _Arg>(0)) type; - }; - - template - struct __is_direct_constructible_new_safe - : public __and_, - __is_direct_constructible_impl<_Tp, _Arg>> - { }; - - template - struct is_same; - - template - struct is_base_of; - - template - struct remove_reference; - - template, - is_function<_From>>>::value> - struct __is_base_to_derived_ref; - - template - struct is_constructible; - - // Detect whether we have a downcast situation during - // reference binding. - template - struct __is_base_to_derived_ref<_From, _To, true> - { - typedef typename remove_cv::type>::type __src_t; - typedef typename remove_cv::type>::type __dst_t; - typedef __and_<__not_>, - is_base_of<__src_t, __dst_t>, - __not_>> type; - static constexpr bool value = type::value; - }; - - template - struct __is_base_to_derived_ref<_From, _To, false> - : public false_type - { }; - - template, - is_rvalue_reference<_To>>::value> - struct __is_lvalue_to_rvalue_ref; - - // Detect whether we have an lvalue of non-function type - // bound to a reference-compatible rvalue-reference. - template - struct __is_lvalue_to_rvalue_ref<_From, _To, true> - { - typedef typename remove_cv::type>::type __src_t; - typedef typename remove_cv::type>::type __dst_t; - typedef __and_<__not_>, - __or_, - is_base_of<__dst_t, __src_t>>> type; - static constexpr bool value = type::value; - }; - - template - struct __is_lvalue_to_rvalue_ref<_From, _To, false> - : public false_type - { }; - - // Here we handle direct-initialization to a reference type as - // equivalent to a static_cast modulo overshooting conversions. - // These are restricted to the following conversions: - // a) A base class value to a derived class reference - // b) An lvalue to an rvalue-reference of reference-compatible - // types that are not functions - template - struct __is_direct_constructible_ref_cast - : public __and_<__is_static_castable<_Arg, _Tp>, - __not_<__or_<__is_base_to_derived_ref<_Arg, _Tp>, - __is_lvalue_to_rvalue_ref<_Arg, _Tp> - >>> - { }; - - template - struct __is_direct_constructible_new - : public conditional::value, - __is_direct_constructible_ref_cast<_Tp, _Arg>, - __is_direct_constructible_new_safe<_Tp, _Arg> - >::type - { }; - - template - struct __is_direct_constructible - : public __is_direct_constructible_new<_Tp, _Arg>::type - { }; - - // Since default-construction and binary direct-initialization have - // been handled separately, the implementation of the remaining - // n-ary construction cases is rather straightforward. We can use - // here a functional cast, because array types are excluded anyway - // and this form is never interpreted as a C cast. - struct __do_is_nary_constructible_impl - { - template()...))> - static true_type __test(int); - - template - static false_type __test(...); - }; - - template - struct __is_nary_constructible_impl - : public __do_is_nary_constructible_impl - { - typedef decltype(__test<_Tp, _Args...>(0)) type; - }; - - template - struct __is_nary_constructible - : public __is_nary_constructible_impl<_Tp, _Args...>::type - { - static_assert(sizeof...(_Args) > 1, - "Only useful for > 1 arguments"); - }; - - template - struct __is_constructible_impl - : public __is_nary_constructible<_Tp, _Args...> - { }; - - template - struct __is_constructible_impl<_Tp, _Arg> - : public __is_direct_constructible<_Tp, _Arg> - { }; - - template - struct __is_constructible_impl<_Tp> - : public is_default_constructible<_Tp> - { }; - /// is_constructible template struct is_constructible - : public __is_constructible_impl<_Tp, _Args...>::type + : public __bool_constant<__is_constructible(_Tp, _Args...)> { }; template::value> @@ -1255,26 +1052,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION : public __is_nothrow_move_constructible_impl<_Tp> { }; - template - class __is_assignable_helper - { - template() = declval<_Up1>())> - static true_type - __test(int); - - template - static false_type - __test(...); - - public: - typedef decltype(__test<_Tp, _Up>(0)) type; - }; - /// is_assignable template struct is_assignable - : public __is_assignable_helper<_Tp, _Up>::type + : public __bool_constant<__is_assignable(_Tp, _Up)> { }; template::value> @@ -1364,8 +1145,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION /// is_trivially_constructible template struct is_trivially_constructible - : public __and_, integral_constant> + : public __bool_constant<__is_trivially_constructible(_Tp, _Args...)> { }; /// is_trivially_default_constructible @@ -1405,45 +1185,95 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION { }; /// is_trivially_copy_constructible + + template::value> + struct __is_trivially_copy_constructible_impl; + template - struct is_trivially_copy_constructible + struct __is_trivially_copy_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_copy_constructible_impl<_Tp, true> : public __and_, integral_constant> { }; + template + struct is_trivially_copy_constructible + : public __is_trivially_copy_constructible_impl<_Tp> + { }; + /// is_trivially_move_constructible + + template::value> + struct __is_trivially_move_constructible_impl; + template - struct is_trivially_move_constructible + struct __is_trivially_move_constructible_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_move_constructible_impl<_Tp, true> : public __and_, integral_constant> { }; + template + struct is_trivially_move_constructible + : public __is_trivially_move_constructible_impl<_Tp> + { }; + /// is_trivially_assignable template struct is_trivially_assignable - : public __and_, - integral_constant> + : public __bool_constant<__is_trivially_assignable(_Tp, _Up)> { }; /// is_trivially_copy_assignable + + template::value> + struct __is_trivially_copy_assignable_impl; + template - struct is_trivially_copy_assignable + struct __is_trivially_copy_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_copy_assignable_impl<_Tp, true> : public __and_, integral_constant> { }; + template + struct is_trivially_copy_assignable + : public __is_trivially_copy_assignable_impl<_Tp> + { }; + /// is_trivially_move_assignable + + template::value> + struct __is_trivially_move_assignable_impl; + template - struct is_trivially_move_assignable + struct __is_trivially_move_assignable_impl<_Tp, false> + : public false_type { }; + + template + struct __is_trivially_move_assignable_impl<_Tp, true> : public __and_, integral_constant> { }; + template + struct is_trivially_move_assignable + : public __is_trivially_move_assignable_impl<_Tp> + { }; + /// is_trivially_destructible template struct is_trivially_destructible diff --git a/libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc b/libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc index dc9daeb42ce5..4e254e891915 100644 --- a/libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc +++ b/libstdc++-v3/testsuite/20_util/declval/requirements/1_neg.cc @@ -18,7 +18,7 @@ // with this library; see the file COPYING3. If not see // . -// { dg-error "static assertion failed" "" { target *-*-* } 2259 } +// { dg-error "static assertion failed" "" { target *-*-* } 2089 } #include diff --git a/libstdc++-v3/testsuite/20_util/is_trivially_copy_assignable/value.cc b/libstdc++-v3/testsuite/20_util/is_trivially_copy_assignable/value.cc index b002246dfd51..902aa5e59322 100644 --- a/libstdc++-v3/testsuite/20_util/is_trivially_copy_assignable/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_trivially_copy_assignable/value.cc @@ -88,4 +88,6 @@ void test01() MoveOnly>(false), ""); static_assert(test_property(false), ""); + static_assert(test_property(false), ""); } diff --git a/libstdc++-v3/testsuite/20_util/is_trivially_copy_constructible/value.cc b/libstdc++-v3/testsuite/20_util/is_trivially_copy_constructible/value.cc index 845e05861512..627410bdc309 100644 --- a/libstdc++-v3/testsuite/20_util/is_trivially_copy_constructible/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_trivially_copy_constructible/value.cc @@ -82,4 +82,6 @@ void test01() MoveOnly>(false), ""); static_assert(test_property(false), ""); + static_assert(test_property(false), ""); } diff --git a/libstdc++-v3/testsuite/20_util/is_trivially_move_assignable/value.cc b/libstdc++-v3/testsuite/20_util/is_trivially_move_assignable/value.cc index 68833b67f12e..221048347a22 100644 --- a/libstdc++-v3/testsuite/20_util/is_trivially_move_assignable/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_trivially_move_assignable/value.cc @@ -88,4 +88,6 @@ void test01() MoveOnly>(true), ""); static_assert(test_property(false), ""); + static_assert(test_property(false), ""); } diff --git a/libstdc++-v3/testsuite/20_util/is_trivially_move_constructible/value.cc b/libstdc++-v3/testsuite/20_util/is_trivially_move_constructible/value.cc index ad6045bda813..9a21b6e2133d 100644 --- a/libstdc++-v3/testsuite/20_util/is_trivially_move_constructible/value.cc +++ b/libstdc++-v3/testsuite/20_util/is_trivially_move_constructible/value.cc @@ -82,4 +82,6 @@ void test01() MoveOnly>(true), ""); static_assert(test_property(false), ""); + static_assert(test_property(false), ""); } diff --git a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc index 664fb70fb4b4..e3e80f919799 100644 --- a/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc +++ b/libstdc++-v3/testsuite/20_util/make_signed/requirements/typedefs_neg.cc @@ -47,4 +47,4 @@ void test01() // { dg-error "required from here" "" { target *-*-* } 39 } // { dg-error "required from here" "" { target *-*-* } 41 } -// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1924 } +// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1754 } diff --git a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc index 6d6471755f74..86b0c2d6da71 100644 --- a/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc +++ b/libstdc++-v3/testsuite/20_util/make_unsigned/requirements/typedefs_neg.cc @@ -47,5 +47,5 @@ void test01() // { dg-error "required from here" "" { target *-*-* } 39 } // { dg-error "required from here" "" { target *-*-* } 41 } -// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1820 } -// { dg-error "declaration of" "" { target *-*-* } 1777 } +// { dg-error "invalid use of incomplete type" "" { target *-*-* } 1650 } + -- 2.39.2