diff options
46 files changed, 1894 insertions, 927 deletions
diff --git a/libcxx/include/__config b/libcxx/include/__config index f2460665f72..4dde70ad1c2 100644 --- a/libcxx/include/__config +++ b/libcxx/include/__config @@ -86,6 +86,8 @@ #if defined(__clang__) +#undef __STRICT_ANSI__ + #define _LIBCPP_HAS_NO_ADVANCED_SFINAE #define _LIBCPP_HAS_NO_TEMPLATE_ALIASES diff --git a/libcxx/include/__split_buffer b/libcxx/include/__split_buffer index e3c2b9dd0b0..88e2c837503 100644 --- a/libcxx/include/__split_buffer +++ b/libcxx/include/__split_buffer @@ -118,12 +118,12 @@ public: __construct_at_end(_ForwardIterator __first, _ForwardIterator __last); _LIBCPP_INLINE_VISIBILITY void __destruct_at_begin(pointer __new_begin) - {__destruct_at_begin(__new_begin, has_trivial_destructor<value_type>());} + {__destruct_at_begin(__new_begin, is_trivially_destructible<value_type>());} void __destruct_at_begin(pointer __new_begin, false_type); void __destruct_at_begin(pointer __new_begin, true_type); _LIBCPP_INLINE_VISIBILITY void __destruct_at_end(pointer __new_last) - {__destruct_at_end(__new_last, has_trivial_destructor<value_type>());} + {__destruct_at_end(__new_last, is_trivially_destructible<value_type>());} void __destruct_at_end(pointer __new_last, false_type); void __destruct_at_end(pointer __new_last, true_type); @@ -230,8 +230,8 @@ _LIBCPP_INLINE_VISIBILITY inline void __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x) { - __construct_at_end(__n, __x, integral_constant<bool, has_trivial_copy_constructor<value_type>::value && - has_trivial_copy_assign<value_type>::value>()); + __construct_at_end(__n, __x, integral_constant<bool, is_trivially_copy_constructible<value_type>::value && + is_trivially_copy_assignable<value_type>::value>()); } template <class _Tp, class _Allocator> diff --git a/libcxx/include/algorithm b/libcxx/include/algorithm index 17e20daed1c..a3764dfd0c1 100644 --- a/libcxx/include/algorithm +++ b/libcxx/include/algorithm @@ -1438,7 +1438,7 @@ template <class _Tp> inline _LIBCPP_INLINE_VISIBILITY typename enable_if < - has_trivial_copy_assign<_Tp>::value, + is_trivially_copy_assignable<_Tp>::value, _Tp* >::type __unwrap_iter(move_iterator<_Tp*> __i) @@ -1450,7 +1450,7 @@ template <class _Tp> inline _LIBCPP_INLINE_VISIBILITY typename enable_if < - has_trivial_copy_assign<_Tp>::value, + is_trivially_copy_assignable<_Tp>::value, _Tp* >::type __unwrap_iter(__wrap_iter<_Tp*> __i) @@ -1473,7 +1473,7 @@ inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_same<typename remove_const<_Tp>::type, _Up>::value && - has_trivial_copy_assign<_Up>::value, + is_trivially_copy_assignable<_Up>::value, _Up* >::type __copy(_Tp* __first, _Tp* __last, _Up* __result) @@ -1508,7 +1508,7 @@ inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_same<typename remove_const<_Tp>::type, _Up>::value && - has_trivial_copy_assign<_Up>::value, + is_trivially_copy_assignable<_Up>::value, _Up* >::type __copy_backward(_Tp* __first, _Tp* __last, _Up* __result) @@ -1593,7 +1593,7 @@ inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_same<typename remove_const<_Tp>::type, _Up>::value && - has_trivial_copy_assign<_Up>::value, + is_trivially_copy_assignable<_Up>::value, _Up* >::type __move(_Tp* __first, _Tp* __last, _Up* __result) @@ -1628,7 +1628,7 @@ inline _LIBCPP_INLINE_VISIBILITY typename enable_if < is_same<typename remove_const<_Tp>::type, _Up>::value && - has_trivial_copy_assign<_Up>::value, + is_trivially_copy_assignable<_Up>::value, _Up* >::type __move_backward(_Tp* __first, _Tp* __last, _Up* __result) @@ -1766,7 +1766,7 @@ fill_n(_OutputIterator __first, _Size __n, const _Tp& __value) { return _STD::__fill_n(__first, __n, __value, integral_constant<bool, is_pointer<_OutputIterator>::value && - has_trivial_copy_assign<_Tp>::value && + is_trivially_copy_assignable<_Tp>::value && sizeof(_Tp) == 1>()); } @@ -2169,7 +2169,7 @@ rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __l typename iterator_traits<_ForwardIterator>::iterator_category, random_access_iterator_tag >::value && - has_trivial_copy_assign + is_trivially_copy_assignable < typename iterator_traits<_ForwardIterator>::value_type >::value @@ -3434,8 +3434,8 @@ __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __c // _Compare is known to be a reference type typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type; typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type; - const difference_type __limit = has_trivial_copy_constructor<value_type>::value && - has_trivial_copy_assign<value_type>::value ? 30 : 6; + const difference_type __limit = is_trivially_copy_constructible<value_type>::value && + is_trivially_copy_assignable<value_type>::value ? 30 : 6; while (true) { __restart: @@ -4069,7 +4069,7 @@ __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, template <class _Tp> struct __inplace_merge_switch { - static const unsigned value = has_trivial_copy_assign<_Tp>::value; + static const unsigned value = is_trivially_copy_assignable<_Tp>::value; }; template <class _BidirectionalIterator, class _Compare> @@ -4237,7 +4237,7 @@ __stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1 template <class _Tp> struct __stable_sort_switch { - static const unsigned value = 128*has_trivial_copy_assign<_Tp>::value; + static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value; }; template <class _Compare, class _RandomAccessIterator> diff --git a/libcxx/include/iterator b/libcxx/include/iterator index 0ad489b9652..6fcb259f9a2 100644 --- a/libcxx/include/iterator +++ b/libcxx/include/iterator @@ -1038,7 +1038,7 @@ template <class _B1, class _B2> _B2 move_backward(_B1, _B1, _B2); template <class _Tp> typename enable_if < - has_trivial_copy_assign<_Tp>::value, + is_trivially_copy_assignable<_Tp>::value, _Tp* >::type __unwrap_iter(__wrap_iter<_Tp*>); @@ -1137,7 +1137,7 @@ private: friend typename enable_if < - has_trivial_copy_assign<_Tp>::value, + is_trivially_copy_assignable<_Tp>::value, _Tp* >::type __unwrap_iter(__wrap_iter<_Tp*>); diff --git a/libcxx/include/memory b/libcxx/include/memory index ba00f52e6d7..c20e1a0c615 100644 --- a/libcxx/include/memory +++ b/libcxx/include/memory @@ -2446,15 +2446,15 @@ public: template <class _Tp> _LIBCPP_INLINE_VISIBILITY void __incr(_Tp*) - {__incr(integral_constant<bool, has_trivial_destructor<_Tp>::value>());} + {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());} template <class _Tp> _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*) - {__set(__s, integral_constant<bool, has_trivial_destructor<_Tp>::value>());} + {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());} template <class _Tp> _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) - {__process(__p, integral_constant<bool, has_trivial_destructor<_Tp>::value>());} + {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());} }; template <class _Alloc> diff --git a/libcxx/include/type_traits b/libcxx/include/type_traits index 7514330c16c..6b8a99ff4b1 100644 --- a/libcxx/include/type_traits +++ b/libcxx/include/type_traits @@ -92,29 +92,32 @@ namespace std template <class T> struct is_abstract; template <class T, class... Args> struct is_constructible; - template <class T, class... Args> struct is_nothrow_constructible; - - template <class T> struct has_trivial_default_constructor - template <class T> struct has_nothrow_default_constructor; - template <class T> struct has_default_constructor; - - template <class T> struct has_trivial_copy_constructor; - template <class T> struct has_nothrow_copy_constructor; - template <class T> struct has_copy_constructor; - - template <class T> struct has_trivial_move_constructor; - template <class T> struct has_nothrow_move_constructor; - template <class T> struct has_move_constructor; + template <class T> struct is_default_constructible; + template <class T> struct is_copy_constructible; + template <class T> struct is_move_constructible; + template <class T, class U> struct is_assignable; + template <class T> struct is_copy_assignable; + template <class T> struct is_move_assignable; + template <class T> struct is_destructible; + + template <class T, class... Args> struct is_trivially_constructible; + template <class T> struct is_trivially_default_constructible; + template <class T> struct is_trivially_copy_constructible; + template <class T> struct is_trivially_move_constructible; + template <class T, class U> struct is_trivially_assignable; + template <class T> struct is_trivially_copy_assignable; + template <class T> struct is_trivially_move_assignable; + template <class T> struct is_trivially_destructible; - template <class T> struct has_trivial_copy_assign; - template <class T> struct has_nothrow_copy_assign; - template <class T> struct has_copy_assign; - - template <class T> struct has_trivial_move_assign; - template <class T> struct has_nothrow_move_assign; - template <class T> struct has_move_assign; + template <class T, class... Args> struct is_nothrow_constructible; + template <class T> struct is_nothrow_default_constructible; + template <class T> struct is_nothrow_copy_constructible; + template <class T> struct is_nothrow_move_constructible; + template <class T, class U> struct is_nothrow_assignable; + template <class T> struct is_nothrow_copy_assignable; + template <class T> struct is_nothrow_move_assignable; + template <class T> struct is_nothrow_destructible; - template <class T> struct has_trivial_destructor; template <class T> struct has_virtual_destructor; // Relationships between types: @@ -777,118 +780,6 @@ template <class _Tp> struct __libcpp_polymorphic<_Tp, false> : public false_type template <class _Tp> struct _LIBCPP_VISIBLE is_polymorphic : public __libcpp_polymorphic<_Tp> {}; -// has_trivial_default_constructor - -#ifdef _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_default_constructor - : public integral_constant<bool, __has_trivial_constructor(_Tp)> {}; - -#else // _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct __has_trivial_default_constructor - : public integral_constant<bool, is_scalar<_Tp>::value> {}; - -template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_default_constructor - : public __has_trivial_default_constructor<typename remove_all_extents<_Tp>::type> {}; - -#endif // _LIBCPP_HAS_TYPE_TRAITS - -// has_nothrow_default_constructor - -#ifdef _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_default_constructor - : public integral_constant<bool, __has_nothrow_constructor(_Tp)> {}; - -#else // _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_default_constructor - : public has_trivial_default_constructor<_Tp> {}; - -#endif // _LIBCPP_HAS_TYPE_TRAITS - -// has_trivial_copy_constructor - -#ifdef _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_copy_constructor - : public integral_constant<bool, __has_trivial_copy(_Tp)> {}; - -#else // _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_copy_constructor - : public integral_constant<bool, is_scalar<_Tp>::value || - is_reference<_Tp>::value> {}; - -#endif // _LIBCPP_HAS_TYPE_TRAITS - -// has_nothrow_copy_constructor - -#ifdef _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_copy_constructor - : public integral_constant<bool, __has_nothrow_copy(_Tp)> {}; - -#else // _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_copy_constructor - : public has_trivial_copy_constructor<_Tp> {}; - -#endif // _LIBCPP_HAS_TYPE_TRAITS - -// has_nothrow_move_constructor - -template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_move_constructor - : public has_nothrow_copy_constructor<_Tp> {}; - -// has_trivial_copy_assign - -#ifdef _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_copy_assign - : public integral_constant<bool, __has_trivial_assign(_Tp)> {}; - -#else // _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_copy_assign - : public integral_constant<bool, is_scalar<_Tp>::value && - !is_const<_Tp>::value> {}; - -#endif // _LIBCPP_HAS_TYPE_TRAITS - -// has_nothrow_copy_assign - -#ifdef _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_copy_assign - : public integral_constant<bool, __has_nothrow_assign(_Tp)> {}; - -#else // _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE has_nothrow_copy_assign - : public has_trivial_copy_assign<_Tp> {}; - -#endif // _LIBCPP_HAS_TYPE_TRAITS - -// has_trivial_destructor - -#ifdef _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_destructor - : public integral_constant<bool, __has_trivial_destructor(_Tp)> {}; - -#else // _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct __libcpp_trivial_destructor - : public integral_constant<bool, is_scalar<_Tp>::value || - is_reference<_Tp>::value> {}; - -template <class _Tp> struct _LIBCPP_VISIBLE has_trivial_destructor - : public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {}; - -#endif // _LIBCPP_HAS_TYPE_TRAITS - // has_virtual_destructor #ifdef _LIBCPP_HAS_TYPE_TRAITS @@ -903,23 +794,6 @@ template <class _Tp> struct _LIBCPP_VISIBLE has_virtual_destructor #endif // _LIBCPP_HAS_TYPE_TRAITS -// is_pod - -#ifdef _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE is_pod - : public integral_constant<bool, __is_pod(_Tp)> {}; - -#else // _LIBCPP_HAS_TYPE_TRAITS - -template <class _Tp> struct _LIBCPP_VISIBLE is_pod - : public integral_constant<bool, has_trivial_default_constructor<_Tp>::value && - has_trivial_copy_constructor<_Tp>::value && - has_trivial_copy_assign<_Tp>::value && - has_trivial_destructor<_Tp>::value> {}; - -#endif // _LIBCPP_HAS_TYPE_TRAITS - // alignment_of template <class _Tp> struct __alignment_of {_Tp _;}; @@ -1287,6 +1161,8 @@ struct _LIBCPP_VISIBLE common_type<_Tp, _Up, _Vp...> #endif // _LIBCPP_HAS_NO_VARIADICS +// is_assignable + template <class _Tp, class _Arg> decltype((_STD::declval<_Tp>() = _STD::declval<_Arg>(), true_type())) #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -1311,20 +1187,57 @@ struct __is_assignable_imp >::type {}; template <class _Tp, class _Arg> -struct __is_assignable +struct is_assignable : public __is_assignable_imp<_Tp, _Arg> {}; -// has_copy_assign +// is_copy_assignable -template <class _Tp> struct _LIBCPP_VISIBLE has_copy_assign - : public __is_assignable<_Tp&, const _Tp&> {}; +template <class _Tp> struct _LIBCPP_VISIBLE is_copy_assignable + : public is_assignable<_Tp&, const _Tp&> {}; -template <class _Tp> struct _LIBCPP_VISIBLE has_copy_assign<_Tp[]> - : public false_type {}; +// is_move_assignable + +template <class _Tp> struct _LIBCPP_VISIBLE is_move_assignable +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + : public is_assignable<_Tp&, _Tp&&> {}; +#else + : public is_copy_assignable<_Tp> {}; +#endif + +// is_destructible + +template <class _Tp> +struct __destructible_test +{ + _Tp __t; +}; -template <class _Tp> struct _LIBCPP_VISIBLE has_copy_assign<_Tp&> +template <class _Tp> +decltype((_STD::declval<__destructible_test<_Tp> >().~__destructible_test<_Tp>(), true_type())) +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES +__is_destructible_test(_Tp&&); +#else +__is_destructible_test(_Tp&); +#endif + +false_type +__is_destructible_test(__any); + +template <class _Tp, bool = is_void<_Tp>::value || is_abstract<_Tp>::value> +struct __destructible_imp + : public common_type + < + decltype(__is_destructible_test(declval<_Tp>())) + >::type {}; + +template <class _Tp> +struct __destructible_imp<_Tp, true> : public false_type {}; +template <class _Tp> +struct is_destructible + : public __destructible_imp<_Tp> {}; + // move #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES @@ -1638,7 +1551,7 @@ class _LIBCPP_VISIBLE result_of<_Fn(_A0, _A1, _A2)> #endif // _LIBCPP_HAS_NO_VARIADICS -#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE +#ifndef _LIBCPP_HAS_NO_VARIADICS // template <class T, class... Args> struct is_constructible; @@ -1758,24 +1671,35 @@ struct __is_constructible<false, _A[], _Args...> : public false_type {}; -template <class _Tp> -struct _LIBCPP_VISIBLE has_default_constructor - : public is_constructible<_Tp> - {}; - -#else // _LIBCPP_HAS_NO_ADVANCED_SFINAE +#else // _LIBCPP_HAS_NO_VARIADICS // template <class T> struct is_constructible0; // main is_constructible0 test template <class _Tp> -decltype((_STD::move(_Tp()), true_type())) +decltype((_Tp(), true_type())) __is_constructible0_test(_Tp&); false_type __is_constructible0_test(__any); +template <class _Tp, class _A0> +decltype((_Tp(_STD::declval<_A0>()), true_type())) +__is_constructible1_test(_Tp&, _A0&); + +template <class _A0> +false_type +__is_constructible1_test(__any, _A0&); + +template <class _Tp, class _A0, class _A1> +decltype((_Tp(_STD::declval<_A0>(), _STD::declval<_A1>()), true_type())) +__is_constructible2_test(_Tp&, _A0&, _A1&); + +template <class _A0, class _A1> +false_type +__is_constructible2_test(__any, _A0&, _A1&); + template <bool, class _Tp> struct __is_constructible0_imp // false, _Tp is not a scalar : public common_type @@ -1784,6 +1708,22 @@ struct __is_constructible0_imp // false, _Tp is not a scalar >::type {}; +template <bool, class _Tp, class _A0> +struct __is_constructible1_imp // false, _Tp is not a scalar + : public common_type + < + decltype(__is_constructible1_test(declval<_Tp&>(), declval<_A0&>())) + >::type + {}; + +template <bool, class _Tp, class _A0, class _A1> +struct __is_constructible2_imp // false, _Tp is not a scalar + : public common_type + < + decltype(__is_constructible2_test(declval<_Tp&>(), declval<_A0>(), declval<_A1>())) + >::type + {}; + // handle scalars and reference types // Scalars are default constructible, references are not @@ -1793,6 +1733,16 @@ struct __is_constructible0_imp<true, _Tp> : public is_scalar<_Tp> {}; +template <class _Tp, class _A0> +struct __is_constructible1_imp<true, _Tp, _A0> + : public is_convertible<_A0, _Tp> + {}; + +template <class _Tp, class _A0, class _A1> +struct __is_constructible2_imp<true, _Tp, _A0, _A1> + : public false_type + {}; + // Treat scalars and reference types separately template <bool, class _Tp> @@ -1801,6 +1751,18 @@ struct __is_constructible0_void_check _Tp> {}; +template <bool, class _Tp, class _A0> +struct __is_constructible1_void_check + : public __is_constructible1_imp<is_scalar<_Tp>::value || is_reference<_Tp>::value, + _Tp, _A0> + {}; + +template <bool, class _Tp, class _A0, class _A1> +struct __is_constructible2_void_check + : public __is_constructible2_imp<is_scalar<_Tp>::value || is_reference<_Tp>::value, + _Tp, _A0, _A1> + {}; + // If any of T or Args is void, is_constructible should be false template <class _Tp> @@ -1808,21 +1770,69 @@ struct __is_constructible0_void_check<true, _Tp> : public false_type {}; -// has_default_constructor entry point +template <class _Tp, class _A0> +struct __is_constructible1_void_check<true, _Tp, _A0> + : public false_type + {}; + +template <class _Tp, class _A0, class _A1> +struct __is_constructible2_void_check<true, _Tp, _A0, _A1> + : public false_type + {}; + +// is_constructible entry point + +namespace __is_construct +{ + +struct __nat {}; + +} + +template <class _Tp, class _A0 = __is_construct::__nat, + class _A1 = __is_construct::__nat> +struct _LIBCPP_VISIBLE is_constructible + : public __is_constructible2_void_check<is_void<_Tp>::value + || is_abstract<_Tp>::value + || is_function<_Tp>::value + || is_void<_A0>::value + || is_void<_A1>::value, + _Tp, _A0, _A1> + {}; template <class _Tp> -struct _LIBCPP_VISIBLE has_default_constructor +struct _LIBCPP_VISIBLE is_constructible<_Tp, __is_construct::__nat, __is_construct::__nat> : public __is_constructible0_void_check<is_void<_Tp>::value - || is_abstract<_Tp>::value, + || is_abstract<_Tp>::value + || is_function<_Tp>::value, _Tp> {}; +template <class _Tp, class _A0> +struct _LIBCPP_VISIBLE is_constructible<_Tp, _A0, __is_construct::__nat> + : public __is_constructible1_void_check<is_void<_Tp>::value + || is_abstract<_Tp>::value + || is_function<_Tp>::value + || is_void<_A0>::value, + _Tp, _A0> + {}; + // Array types are default constructible if their element type // is default constructible template <class _A, size_t _N> struct __is_constructible0_imp<false, _A[_N]> - : public has_default_constructor<typename remove_all_extents<_A>::type> + : public is_constructible<typename remove_all_extents<_A>::type> + {}; + +template <class _A, size_t _N, class _A0> +struct __is_constructible1_imp<false, _A[_N], _A0> + : public false_type + {}; + +template <class _A, size_t _N, class _A0, class _A1> +struct __is_constructible2_imp<false, _A[_N], _A0, _A1> + : public false_type {}; // Incomplete array types are not constructible @@ -1832,25 +1842,468 @@ struct __is_constructible0_imp<false, _A[]> : public false_type {}; -#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE +template <class _A, class _A0> +struct __is_constructible1_imp<false, _A[], _A0> + : public false_type + {}; + +template <class _A, class _A0, class _A1> +struct __is_constructible2_imp<false, _A[], _A0, _A1> + : public false_type + {}; -// has_copy_constructor +#endif // _LIBCPP_HAS_NO_VARIADICS -#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE +// is_default_constructible template <class _Tp> -struct _LIBCPP_VISIBLE has_copy_constructor - : public is_constructible<_Tp, typename add_lvalue_reference<const _Tp>::type> +struct _LIBCPP_VISIBLE is_default_constructible + : public is_constructible<_Tp> {}; -#else // _LIBCPP_HAS_NO_ADVANCED_SFINAE +// is_copy_constructible template <class _Tp> -struct _LIBCPP_VISIBLE has_copy_constructor - : public has_nothrow_copy_constructor<_Tp> +struct _LIBCPP_VISIBLE is_copy_constructible + : public is_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type> {}; -#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE +// is_move_constructible + +template <class _Tp> +struct _LIBCPP_VISIBLE is_move_constructible +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + : public is_constructible<_Tp, typename add_rvalue_reference<_Tp>::type> +#else + : public is_copy_constructible<_Tp> +#endif + {}; + +// is_trivially_constructible + +#ifndef _LIBCPP_HAS_NO_VARIADICS + +template <class _Tp, class... _Args> +struct _LIBCPP_VISIBLE is_trivially_constructible + : false_type +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_trivial_constructor(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +template <class _Tp> +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES +struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&&> +#else +struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp> +#endif +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_trivial_copy(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, const _Tp&> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_trivial_copy(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_trivial_copy(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +#else // _LIBCPP_HAS_NO_VARIADICS + +template <class _Tp, class _A0 = __is_construct::__nat, + class _A1 = __is_construct::__nat> +struct _LIBCPP_VISIBLE is_trivially_constructible + : false_type +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, __is_construct::__nat, + __is_construct::__nat> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_trivial_constructor(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp, + __is_construct::__nat> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_trivial_copy(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, const _Tp&, + __is_construct::__nat> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_trivial_copy(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_trivially_constructible<_Tp, _Tp&, + __is_construct::__nat> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_trivial_copy(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +#endif // _LIBCPP_HAS_NO_VARIADICS + +// is_trivially_default_constructible + +template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_default_constructible + : public is_trivially_constructible<_Tp> + {}; + +// is_trivially_copy_constructible + +template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_copy_constructible + : public is_trivially_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type> + {}; + +// is_trivially_move_constructible + +template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_move_constructible +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + : public is_trivially_constructible<_Tp, typename add_rvalue_reference<_Tp>::type> +#else + : public is_trivially_copy_constructible<_Tp> +#endif + {}; + +// is_trivially_assignable + +template <class _Tp, class _Arg> +struct is_trivially_assignable + : public false_type {}; + +template <class _Tp> +struct is_trivially_assignable<_Tp&, _Tp> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_trivial_assign(_Tp)> {}; +#else + : integral_constant<bool, is_scalar<_Tp>::value> {}; +#endif + +template <class _Tp> +struct is_trivially_assignable<_Tp&, _Tp&> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_trivial_assign(_Tp)> {}; +#else + : integral_constant<bool, is_scalar<_Tp>::value> {}; +#endif + +template <class _Tp> +struct is_trivially_assignable<_Tp&, const _Tp&> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_trivial_assign(_Tp)> {}; +#else + : integral_constant<bool, is_scalar<_Tp>::value> {}; +#endif + +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + +template <class _Tp> +struct is_trivially_assignable<_Tp&, _Tp&&> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_trivial_assign(_Tp)> {}; +#else + : integral_constant<bool, is_scalar<_Tp>::value> {}; +#endif + +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + +// is_trivially_copy_assignable + +template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_copy_assignable + : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type, + const typename add_lvalue_reference<_Tp>::type> + {}; + +// is_trivially_move_assignable + +template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_move_assignable + : public is_trivially_assignable<typename add_lvalue_reference<_Tp>::type, +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + typename add_rvalue_reference<_Tp>::type> +#else + typename add_lvalue_reference<_Tp>::type> +#endif + {}; + +// is_trivially_destructible + +#ifdef _LIBCPP_HAS_TYPE_TRAITS + +template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_destructible + : public integral_constant<bool, __has_trivial_destructor(_Tp)> {}; + +#else // _LIBCPP_HAS_TYPE_TRAITS + +template <class _Tp> struct __libcpp_trivial_destructor + : public integral_constant<bool, is_scalar<_Tp>::value || + is_reference<_Tp>::value> {}; + +template <class _Tp> struct _LIBCPP_VISIBLE is_trivially_destructible + : public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {}; + +#endif // _LIBCPP_HAS_TYPE_TRAITS + +// is_nothrow_constructible + +#ifndef _LIBCPP_HAS_NO_VARIADICS + +template <class _Tp, class... _Args> +struct _LIBCPP_VISIBLE is_nothrow_constructible + : false_type +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_nothrow_constructor(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +template <class _Tp> +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES +struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&&> +#else +struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp> +#endif +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_nothrow_copy(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, const _Tp&> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_nothrow_copy(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_nothrow_copy(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +#else // _LIBCPP_HAS_NO_VARIADICS + +template <class _Tp, class _A0 = __is_construct::__nat, + class _A1 = __is_construct::__nat> +struct _LIBCPP_VISIBLE is_nothrow_constructible + : false_type +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, __is_construct::__nat, + __is_construct::__nat> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_nothrow_constructor(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp, + __is_construct::__nat> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_nothrow_copy(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, const _Tp&, + __is_construct::__nat> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_nothrow_copy(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +template <class _Tp> +struct _LIBCPP_VISIBLE is_nothrow_constructible<_Tp, _Tp&, + __is_construct::__nat> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_nothrow_copy(_Tp)> +#else + : integral_constant<bool, is_scalar<_Tp>::value> +#endif +{ +}; + +#endif // _LIBCPP_HAS_NO_VARIADICS + +// is_nothrow_default_constructible + +template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_default_constructible + : public is_nothrow_constructible<_Tp> + {}; + +// is_nothrow_copy_constructible + +template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_copy_constructible + : public is_nothrow_constructible<_Tp, const typename add_lvalue_reference<_Tp>::type> + {}; + +// is_nothrow_move_constructible + +template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_move_constructible +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + : public is_nothrow_constructible<_Tp, typename add_rvalue_reference<_Tp>::type> +#else + : public is_nothrow_copy_constructible<_Tp> +#endif + {}; + +// is_nothrow_assignable + +template <class _Tp, class _Arg> +struct is_nothrow_assignable + : public false_type {}; + +template <class _Tp> +struct is_nothrow_assignable<_Tp&, _Tp> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_nothrow_assign(_Tp)> {}; +#else + : integral_constant<bool, is_scalar<_Tp>::value> {}; +#endif + +template <class _Tp> +struct is_nothrow_assignable<_Tp&, _Tp&> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_nothrow_assign(_Tp)> {}; +#else + : integral_constant<bool, is_scalar<_Tp>::value> {}; +#endif + +template <class _Tp> +struct is_nothrow_assignable<_Tp&, const _Tp&> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_nothrow_assign(_Tp)> {}; +#else + : integral_constant<bool, is_scalar<_Tp>::value> {}; +#endif + +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + +template <class _Tp> +struct is_nothrow_assignable<_Tp&, _Tp&&> +#ifdef _LIBCPP_HAS_TYPE_TRAITS + : integral_constant<bool, __has_nothrow_assign(_Tp)> {}; +#else + : integral_constant<bool, is_scalar<_Tp>::value> {}; +#endif + +#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES + +// is_nothrow_copy_assignable + +template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_copy_assignable + : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type, + const typename add_lvalue_reference<_Tp>::type> + {}; + +// is_nothrow_move_assignable + +template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_move_assignable + : public is_nothrow_assignable<typename add_lvalue_reference<_Tp>::type, +#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES + typename add_rvalue_reference<_Tp>::type> +#else + typename add_lvalue_reference<_Tp>::type> +#endif + {}; + +// is_nothrow_destructible + +template <class _Tp> struct __libcpp_nothrow_destructor + : public integral_constant<bool, is_scalar<_Tp>::value || + is_reference<_Tp>::value> {}; + +template <class _Tp> struct _LIBCPP_VISIBLE is_nothrow_destructible + : public __libcpp_nothrow_destructor<typename remove_all_extents<_Tp>::type> {}; + +// is_pod + +#ifdef _LIBCPP_HAS_TYPE_TRAITS + +template <class _Tp> struct _LIBCPP_VISIBLE is_pod + : public integral_constant<bool, __is_pod(_Tp)> {}; + +#else // _LIBCPP_HAS_TYPE_TRAITS + +template <class _Tp> struct _LIBCPP_VISIBLE is_pod + : public integral_constant<bool, is_trivially_default_constructible<_Tp>::value && + is_trivially_copy_constructible<_Tp>::value && + is_trivially_copy_assignable<_Tp>::value && + is_trivially_destructible<_Tp>::value> {}; + +#endif // _LIBCPP_HAS_TYPE_TRAITS template <class _Tp> struct __is_zero_default_constructible : public integral_constant<bool, is_scalar<_Tp>::value || is_empty<_Tp>::value> {}; diff --git a/libcxx/include/utility b/libcxx/include/utility index f4c94bea94f..f8a8fc529a9 100644 --- a/libcxx/include/utility +++ b/libcxx/include/utility @@ -38,7 +38,7 @@ template <class T> typename remove_reference<T>::type&& move(T&&); template <class T> typename conditional < - !has_nothrow_move_constructor<T>::value && has_copy_constructor<T>::value, + !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value, const T&, T&& >::type @@ -178,7 +178,7 @@ inline _LIBCPP_INLINE_VISIBILITY #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES typename conditional < - !has_nothrow_move_constructor<_Tp>::value && has_copy_constructor<_Tp>::value, + !is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value, const _Tp&, _Tp&& >::type diff --git a/libcxx/include/vector b/libcxx/include/vector index 80b1ceffce6..074e44546af 100644 --- a/libcxx/include/vector +++ b/libcxx/include/vector @@ -326,7 +326,7 @@ protected: _LIBCPP_INLINE_VISIBILITY size_type capacity() const {return static_cast<size_type>(__end_cap() - __begin_);} _LIBCPP_INLINE_VISIBILITY void __destruct_at_end(const_pointer __new_last) - {__destruct_at_end(__new_last, has_trivial_destructor<value_type>());} + {__destruct_at_end(__new_last, is_trivially_destructible<value_type>());} void __destruct_at_end(const_pointer __new_last, false_type); void __destruct_at_end(const_pointer __new_last, true_type); @@ -771,8 +771,8 @@ _LIBCPP_INLINE_VISIBILITY inline void vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x) { - __construct_at_end(__n, __x, integral_constant<bool, has_trivial_copy_constructor<value_type>::value && - has_trivial_copy_assign<value_type>::value>()); + __construct_at_end(__n, __x, integral_constant<bool, is_trivially_copy_constructible<value_type>::value && + is_trivially_copy_assignable<value_type>::value>()); } template <class _Tp, class _Allocator> diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_copy_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_copy_assign.pass.cpp deleted file mode 100644 index c6503722278..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_copy_assign.pass.cpp +++ /dev/null @@ -1,50 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_copy_assign - -#include <type_traits> - -class Empty -{ -}; - -class NotEmpty -{ -public: - virtual ~NotEmpty(); -}; - -union Union {}; - -struct bit_zero -{ - int : 0; -}; - -struct A -{ - A(); -}; - -int main() -{ - static_assert(( std::has_copy_assign<int>::value), ""); - static_assert((!std::has_copy_assign<const int>::value), ""); - static_assert((!std::has_copy_assign<int[]>::value), ""); - static_assert((!std::has_copy_assign<int[3]>::value), ""); - static_assert((!std::has_copy_assign<int&>::value), ""); - static_assert(( std::has_copy_assign<A>::value), ""); - static_assert(( std::has_copy_assign<bit_zero>::value), ""); - static_assert(( std::has_copy_assign<Union>::value), ""); - static_assert(( std::has_copy_assign<NotEmpty>::value), ""); - static_assert(( std::has_copy_assign<Empty>::value), ""); -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_copy_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_copy_constructor.pass.cpp deleted file mode 100644 index 8d74613494f..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_copy_constructor.pass.cpp +++ /dev/null @@ -1,67 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_copy_constructor - -#include <type_traits> - -template <class T, bool Result> -void test_has_copy_constructor() -{ - static_assert(std::has_copy_constructor<T>::value == Result, ""); -} - -class Empty -{ -}; - -class NotEmpty -{ -public: - virtual ~NotEmpty(); -}; - -union Union {}; - -struct bit_zero -{ - int : 0; -}; - -class Abstract -{ -public: - virtual ~Abstract() = 0; -}; - -struct A -{ - A(const A&); -}; - -int main() -{ - test_has_copy_constructor<char[3], false>(); - test_has_copy_constructor<char[], false>(); - test_has_copy_constructor<void, false>(); - test_has_copy_constructor<Abstract, false>(); - - test_has_copy_constructor<A, true>(); - test_has_copy_constructor<int&, true>(); - test_has_copy_constructor<Union, true>(); - test_has_copy_constructor<Empty, true>(); - test_has_copy_constructor<int, true>(); - test_has_copy_constructor<double, true>(); - test_has_copy_constructor<int*, true>(); - test_has_copy_constructor<const int*, true>(); - test_has_copy_constructor<NotEmpty, true>(); - test_has_copy_constructor<bit_zero, true>(); -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_default_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_default_constructor.pass.cpp deleted file mode 100644 index 7a4c98b3929..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_default_constructor.pass.cpp +++ /dev/null @@ -1,70 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_default_constructor - -#include <type_traits> - -template <class T, bool Result> -void test_has_default_constructor() -{ - static_assert(std::has_default_constructor<T>::value == Result, ""); - static_assert(std::has_default_constructor<const T>::value == Result, ""); - static_assert(std::has_default_constructor<volatile T>::value == Result, ""); - static_assert(std::has_default_constructor<const volatile T>::value == Result, ""); -} - -class Empty -{ -}; - -class NotEmpty -{ -public: - virtual ~NotEmpty(); -}; - -union Union {}; - -struct bit_zero -{ - int : 0; -}; - -class Abstract -{ -public: - virtual ~Abstract() = 0; -}; - -struct A -{ - A(); -}; - -int main() -{ - test_has_default_constructor<void, false>(); - test_has_default_constructor<int&, false>(); - test_has_default_constructor<char[], false>(); - test_has_default_constructor<Abstract, false>(); - - test_has_default_constructor<A, true>(); - test_has_default_constructor<Union, true>(); - test_has_default_constructor<Empty, true>(); - test_has_default_constructor<int, true>(); - test_has_default_constructor<double, true>(); - test_has_default_constructor<int*, true>(); - test_has_default_constructor<const int*, true>(); - test_has_default_constructor<char[3], true>(); - test_has_default_constructor<NotEmpty, true>(); - test_has_default_constructor<bit_zero, true>(); -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_move_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_move_assign.pass.cpp deleted file mode 100644 index 135a0ed79f8..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_move_assign.pass.cpp +++ /dev/null @@ -1,19 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_move_assign - -#include <type_traits> - -int main() -{ -#error has_move_assign not implemented -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_move_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_move_constructor.pass.cpp deleted file mode 100644 index 0f1161e0d20..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_move_constructor.pass.cpp +++ /dev/null @@ -1,19 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_move_constructor - -#include <type_traits> - -int main() -{ -#error has_move_constructor not implemented -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_constructor.pass.cpp deleted file mode 100644 index 53600872565..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_constructor.pass.cpp +++ /dev/null @@ -1,79 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_nothrow_copy_constructor - -#include <type_traits> - -template <class T> -void test_has_nothrow_copy_constructor() -{ - static_assert( std::has_nothrow_copy_constructor<T>::value, ""); - static_assert( std::has_nothrow_copy_constructor<const T>::value, ""); - static_assert( std::has_nothrow_copy_constructor<volatile T>::value, ""); - static_assert( std::has_nothrow_copy_constructor<const volatile T>::value, ""); -} - -template <class T> -void test_has_not_nothrow_copy_constructor() -{ - static_assert(!std::has_nothrow_copy_constructor<T>::value, ""); - static_assert(!std::has_nothrow_copy_constructor<const T>::value, ""); - static_assert(!std::has_nothrow_copy_constructor<volatile T>::value, ""); - static_assert(!std::has_nothrow_copy_constructor<const volatile T>::value, ""); -} - -class Empty -{ -}; - -class NotEmpty -{ -public: - virtual ~NotEmpty(); -}; - -union Union {}; - -struct bit_zero -{ - int : 0; -}; - -class Abstract -{ -public: - virtual ~Abstract() = 0; -}; - -struct A -{ - A(const A&); -}; - -int main() -{ - test_has_not_nothrow_copy_constructor<void>(); - test_has_not_nothrow_copy_constructor<A>(); - test_has_not_nothrow_copy_constructor<Abstract>(); - test_has_not_nothrow_copy_constructor<char[3]>(); - test_has_not_nothrow_copy_constructor<char[]>(); - - test_has_nothrow_copy_constructor<int&>(); - test_has_nothrow_copy_constructor<Union>(); - test_has_nothrow_copy_constructor<Empty>(); - test_has_nothrow_copy_constructor<int>(); - test_has_nothrow_copy_constructor<double>(); - test_has_nothrow_copy_constructor<int*>(); - test_has_nothrow_copy_constructor<const int*>(); - test_has_nothrow_copy_constructor<NotEmpty>(); - test_has_nothrow_copy_constructor<bit_zero>(); -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_default_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_default_constructor.pass.cpp deleted file mode 100644 index 071578392c3..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_default_constructor.pass.cpp +++ /dev/null @@ -1,79 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_nothrow_default_constructor - -#include <type_traits> - -template <class T> -void test_has_nothrow_default_constructor() -{ - static_assert( std::has_nothrow_default_constructor<T>::value, ""); - static_assert( std::has_nothrow_default_constructor<const T>::value, ""); - static_assert( std::has_nothrow_default_constructor<volatile T>::value, ""); - static_assert( std::has_nothrow_default_constructor<const volatile T>::value, ""); -} - -template <class T> -void test_has_not_nothrow_default_constructor() -{ - static_assert(!std::has_nothrow_default_constructor<T>::value, ""); - static_assert(!std::has_nothrow_default_constructor<const T>::value, ""); - static_assert(!std::has_nothrow_default_constructor<volatile T>::value, ""); - static_assert(!std::has_nothrow_default_constructor<const volatile T>::value, ""); -} - -class Empty -{ -}; - -class NotEmpty -{ -public: - virtual ~NotEmpty(); -}; - -union Union {}; - -struct bit_zero -{ - int : 0; -}; - -class Abstract -{ -public: - virtual ~Abstract() = 0; -}; - -struct A -{ - A(); -}; - -int main() -{ - test_has_not_nothrow_default_constructor<void>(); - test_has_not_nothrow_default_constructor<int&>(); - test_has_not_nothrow_default_constructor<A>(); - test_has_not_nothrow_default_constructor<char[]>(); - test_has_not_nothrow_default_constructor<Abstract>(); - - test_has_nothrow_default_constructor<Union>(); - test_has_nothrow_default_constructor<Empty>(); - test_has_nothrow_default_constructor<int>(); - test_has_nothrow_default_constructor<double>(); - test_has_nothrow_default_constructor<int*>(); - test_has_nothrow_default_constructor<const int*>(); - test_has_nothrow_default_constructor<char[3]>(); - test_has_nothrow_default_constructor<NotEmpty>(); - test_has_nothrow_default_constructor<bit_zero>(); -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_assign.pass.cpp deleted file mode 100644 index bee6a0646ed..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_assign.pass.cpp +++ /dev/null @@ -1,19 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_nothrow_move_assign - -#include <type_traits> - -int main() -{ -#error has_nothrow_move_assign not implemented -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_constructor.pass.cpp deleted file mode 100644 index 949256ac2f0..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_move_constructor.pass.cpp +++ /dev/null @@ -1,19 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_nothrow_move_constructor - -#include <type_traits> - -int main() -{ -#error has_nothrow_move_constructor not implemented -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_constructor.pass.cpp deleted file mode 100644 index 684466114a2..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_constructor.pass.cpp +++ /dev/null @@ -1,79 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_trivial_copy_constructor - -#include <type_traits> - -template <class T> -void test_has_trivial_copy_constructor() -{ - static_assert( std::has_trivial_copy_constructor<T>::value, ""); - static_assert( std::has_trivial_copy_constructor<const T>::value, ""); - static_assert( std::has_trivial_copy_constructor<volatile T>::value, ""); - static_assert( std::has_trivial_copy_constructor<const volatile T>::value, ""); -} - -template <class T> -void test_has_not_trivial_copy_constructor() -{ - static_assert(!std::has_trivial_copy_constructor<T>::value, ""); - static_assert(!std::has_trivial_copy_constructor<const T>::value, ""); - static_assert(!std::has_trivial_copy_constructor<volatile T>::value, ""); - static_assert(!std::has_trivial_copy_constructor<const volatile T>::value, ""); -} - -class Empty -{ -}; - -class NotEmpty -{ -public: - virtual ~NotEmpty(); -}; - -union Union {}; - -struct bit_zero -{ - int : 0; -}; - -class Abstract -{ -public: - virtual ~Abstract() = 0; -}; - -struct A -{ - A(const A&); -}; - -int main() -{ - test_has_not_trivial_copy_constructor<void>(); - test_has_not_trivial_copy_constructor<A>(); - test_has_not_trivial_copy_constructor<char[3]>(); - test_has_not_trivial_copy_constructor<char[]>(); - test_has_not_trivial_copy_constructor<Abstract>(); - test_has_not_trivial_copy_constructor<NotEmpty>(); - - test_has_trivial_copy_constructor<int&>(); - test_has_trivial_copy_constructor<Union>(); - test_has_trivial_copy_constructor<Empty>(); - test_has_trivial_copy_constructor<int>(); - test_has_trivial_copy_constructor<double>(); - test_has_trivial_copy_constructor<int*>(); - test_has_trivial_copy_constructor<const int*>(); - test_has_trivial_copy_constructor<bit_zero>(); -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_default_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_default_constructor.pass.cpp deleted file mode 100644 index 7dda08e8453..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_default_constructor.pass.cpp +++ /dev/null @@ -1,77 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_trivial_default_constructor - -#include <type_traits> - -template <class T> -void test_has_trivial_default_constructor() -{ - static_assert( std::has_trivial_default_constructor<T>::value, ""); - static_assert( std::has_trivial_default_constructor<const T>::value, ""); - static_assert( std::has_trivial_default_constructor<volatile T>::value, ""); - static_assert( std::has_trivial_default_constructor<const volatile T>::value, ""); -} - -template <class T> -void test_has_not_trivial_default_constructor() -{ - static_assert(!std::has_trivial_default_constructor<T>::value, ""); - static_assert(!std::has_trivial_default_constructor<const T>::value, ""); - static_assert(!std::has_trivial_default_constructor<volatile T>::value, ""); - static_assert(!std::has_trivial_default_constructor<const volatile T>::value, ""); -} - -class Empty -{ -}; - -class NotEmpty -{ - virtual ~NotEmpty(); -}; - -union Union {}; - -struct bit_zero -{ - int : 0; -}; - -class Abstract -{ - virtual ~Abstract() = 0; -}; - -struct A -{ - A(); -}; - -int main() -{ - test_has_not_trivial_default_constructor<void>(); - test_has_not_trivial_default_constructor<int&>(); - test_has_not_trivial_default_constructor<A>(); - test_has_not_trivial_default_constructor<Abstract>(); - test_has_not_trivial_default_constructor<NotEmpty>(); - test_has_not_trivial_default_constructor<char[]>(); - - test_has_trivial_default_constructor<Union>(); - test_has_trivial_default_constructor<Empty>(); - test_has_trivial_default_constructor<int>(); - test_has_trivial_default_constructor<double>(); - test_has_trivial_default_constructor<int*>(); - test_has_trivial_default_constructor<const int*>(); - test_has_trivial_default_constructor<char[3]>(); - test_has_trivial_default_constructor<bit_zero>(); -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_destructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_destructor.pass.cpp deleted file mode 100644 index cbfc416755e..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_destructor.pass.cpp +++ /dev/null @@ -1,77 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_trivial_destructor - -#include <type_traits> - -template <class T> -void test_has_trivial_destructor() -{ - static_assert( std::has_trivial_destructor<T>::value, ""); - static_assert( std::has_trivial_destructor<const T>::value, ""); - static_assert( std::has_trivial_destructor<volatile T>::value, ""); - static_assert( std::has_trivial_destructor<const volatile T>::value, ""); -} - -template <class T> -void test_has_not_trivial_destructor() -{ - static_assert(!std::has_trivial_destructor<T>::value, ""); - static_assert(!std::has_trivial_destructor<const T>::value, ""); - static_assert(!std::has_trivial_destructor<volatile T>::value, ""); - static_assert(!std::has_trivial_destructor<const volatile T>::value, ""); -} - -class Empty -{ -}; - -class NotEmpty -{ - virtual ~NotEmpty(); -}; - -union Union {}; - -struct bit_zero -{ - int : 0; -}; - -class Abstract -{ - virtual ~Abstract() = 0; -}; - -struct A -{ - ~A(); -}; - -int main() -{ - test_has_not_trivial_destructor<void>(); - test_has_not_trivial_destructor<A>(); - test_has_not_trivial_destructor<Abstract>(); - test_has_not_trivial_destructor<NotEmpty>(); - - test_has_trivial_destructor<int&>(); - test_has_trivial_destructor<Union>(); - test_has_trivial_destructor<Empty>(); - test_has_trivial_destructor<int>(); - test_has_trivial_destructor<double>(); - test_has_trivial_destructor<int*>(); - test_has_trivial_destructor<const int*>(); - test_has_trivial_destructor<char[3]>(); - test_has_trivial_destructor<char[3]>(); - test_has_trivial_destructor<bit_zero>(); -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_assign.pass.cpp deleted file mode 100644 index 268c1a698de..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_assign.pass.cpp +++ /dev/null @@ -1,19 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_trivial_move_assign - -#include <type_traits> - -int main() -{ -#error has_trivial_move_assign not implemented -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_constructor.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_constructor.pass.cpp deleted file mode 100644 index 5a47b14f8d2..00000000000 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_move_constructor.pass.cpp +++ /dev/null @@ -1,19 +0,0 @@ -//===----------------------------------------------------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -// type_traits - -// has_trivial_move_constructor - -#include <type_traits> - -int main() -{ -#error has_trivial_move_constructor not implemented -} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp new file mode 100644 index 00000000000..d836e6ac73a --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_assignable.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_assignable + +#include <type_traits> + +struct A +{ +}; + +struct B +{ + void operator=(A); +}; + +int main() +{ + static_assert(( std::is_assignable<int&, int&>::value), ""); + static_assert(( std::is_assignable<int&, int>::value), ""); + static_assert((!std::is_assignable<int, int&>::value), ""); + static_assert((!std::is_assignable<int, int>::value), ""); + static_assert(( std::is_assignable<int&, double>::value), ""); + static_assert(( std::is_assignable<B, A>::value), ""); + static_assert((!std::is_assignable<A, B>::value), ""); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp index 00b247b222d..40b15c4eaed 100644 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_constructible.pass.cpp @@ -14,25 +14,17 @@ #include <type_traits> -#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE - struct A { explicit A(int); A(int, double); }; -#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE - int main() { -#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE - static_assert((std::is_constructible<int>::value), ""); static_assert((std::is_constructible<int, const int>::value), ""); static_assert((std::is_constructible<A, int>::value), ""); static_assert((std::is_constructible<A, int, double>::value), ""); static_assert((!std::is_constructible<A>::value), ""); - -#endif // _LIBCPP_HAS_NO_ADVANCED_SFINAE } diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp new file mode 100644 index 00000000000..c44ba6d04d6 --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_assignable.pass.cpp @@ -0,0 +1,50 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_copy_assignable + +#include <type_traits> + +class Empty +{ +}; + +class NotEmpty +{ +public: + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +struct A +{ + A(); +}; + +int main() +{ + static_assert(( std::is_copy_assignable<int>::value), ""); + static_assert((!std::is_copy_assignable<const int>::value), ""); + static_assert((!std::is_copy_assignable<int[]>::value), ""); + static_assert((!std::is_copy_assignable<int[3]>::value), ""); + static_assert(( std::is_copy_assignable<int&>::value), ""); + static_assert(( std::is_copy_assignable<A>::value), ""); + static_assert(( std::is_copy_assignable<bit_zero>::value), ""); + static_assert(( std::is_copy_assignable<Union>::value), ""); + static_assert(( std::is_copy_assignable<NotEmpty>::value), ""); + static_assert(( std::is_copy_assignable<Empty>::value), ""); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp new file mode 100644 index 00000000000..691ac69301e --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_copy_constructible.pass.cpp @@ -0,0 +1,67 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_copy_constructible + +#include <type_traits> + +template <class T, bool Result> +void test_is_copy_constructible() +{ + static_assert(std::is_copy_constructible<T>::value == Result, ""); +} + +class Empty +{ +}; + +class NotEmpty +{ +public: + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +class Abstract +{ +public: + virtual ~Abstract() = 0; +}; + +struct A +{ + A(const A&); +}; + +int main() +{ + test_is_copy_constructible<char[3], false>(); + test_is_copy_constructible<char[], false>(); + test_is_copy_constructible<void, false>(); + test_is_copy_constructible<Abstract, false>(); + + test_is_copy_constructible<A, true>(); + test_is_copy_constructible<int&, true>(); + test_is_copy_constructible<Union, true>(); + test_is_copy_constructible<Empty, true>(); + test_is_copy_constructible<int, true>(); + test_is_copy_constructible<double, true>(); + test_is_copy_constructible<int*, true>(); + test_is_copy_constructible<const int*, true>(); + test_is_copy_constructible<NotEmpty, true>(); + test_is_copy_constructible<bit_zero, true>(); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp new file mode 100644 index 00000000000..0830ce166d1 --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_default_constructible.pass.cpp @@ -0,0 +1,70 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_default_constructible + +#include <type_traits> + +template <class T, bool Result> +void test_is_default_constructible() +{ + static_assert(std::is_default_constructible<T>::value == Result, ""); + static_assert(std::is_default_constructible<const T>::value == Result, ""); + static_assert(std::is_default_constructible<volatile T>::value == Result, ""); + static_assert(std::is_default_constructible<const volatile T>::value == Result, ""); +} + +class Empty +{ +}; + +class NotEmpty +{ +public: + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +class Abstract +{ +public: + virtual ~Abstract() = 0; +}; + +struct A +{ + A(); +}; + +int main() +{ + test_is_default_constructible<void, false>(); + test_is_default_constructible<int&, false>(); + test_is_default_constructible<char[], false>(); + test_is_default_constructible<Abstract, false>(); + + test_is_default_constructible<A, true>(); + test_is_default_constructible<Union, true>(); + test_is_default_constructible<Empty, true>(); + test_is_default_constructible<int, true>(); + test_is_default_constructible<double, true>(); + test_is_default_constructible<int*, true>(); + test_is_default_constructible<const int*, true>(); + test_is_default_constructible<char[3], true>(); + test_is_default_constructible<NotEmpty, true>(); + test_is_default_constructible<bit_zero, true>(); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp new file mode 100644 index 00000000000..61b04b2ab4a --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_destructible + +#include <type_traits> + +template <class T, bool Result> +void test_is_destructible() +{ + static_assert( std::is_destructible<T>::value == Result, ""); + static_assert( std::is_destructible<const T>::value == Result, ""); + static_assert( std::is_destructible<volatile T>::value == Result, ""); + static_assert( std::is_destructible<const volatile T>::value == Result, ""); +} + +class Empty +{ +}; + +class NotEmpty +{ + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +class Abstract +{ + virtual ~Abstract() = 0; +}; + +struct A +{ + ~A(); +}; + +int main() +{ + test_is_destructible<void, false>(); + test_is_destructible<A, true>(); + test_is_destructible<Abstract, false>(); + test_is_destructible<NotEmpty, false>(); + test_is_destructible<int&, true>(); + test_is_destructible<Union, true>(); + test_is_destructible<Empty, true>(); + test_is_destructible<int, true>(); + test_is_destructible<double, true>(); + test_is_destructible<int*, true>(); + test_is_destructible<const int*, true>(); + test_is_destructible<char[3], true>(); + test_is_destructible<bit_zero, true>(); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp new file mode 100644 index 00000000000..3f44f8ebcb9 --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_assignable.pass.cpp @@ -0,0 +1,50 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_move_assignable + +#include <type_traits> + +class Empty +{ +}; + +class NotEmpty +{ +public: + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +struct A +{ + A(); +}; + +int main() +{ + static_assert(( std::is_move_assignable<int>::value), ""); + static_assert((!std::is_move_assignable<const int>::value), ""); + static_assert((!std::is_move_assignable<int[]>::value), ""); + static_assert((!std::is_move_assignable<int[3]>::value), ""); + static_assert(( std::is_move_assignable<int&>::value), ""); + static_assert(( std::is_move_assignable<A>::value), ""); + static_assert(( std::is_move_assignable<bit_zero>::value), ""); + static_assert(( std::is_move_assignable<Union>::value), ""); + static_assert(( std::is_move_assignable<NotEmpty>::value), ""); + static_assert(( std::is_move_assignable<Empty>::value), ""); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp new file mode 100644 index 00000000000..3ad3666a222 --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_move_constructible.pass.cpp @@ -0,0 +1,73 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_move_constructible + +#include <type_traits> + +template <class T, bool Result> +void test_is_move_constructible() +{ + static_assert(std::is_move_constructible<T>::value == Result, ""); +} + +class Empty +{ +}; + +class NotEmpty +{ +public: + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +class Abstract +{ +public: + virtual ~Abstract() = 0; +}; + +struct A +{ + A(const A&); +}; + +struct B +{ + B(B&&); +}; + +int main() +{ + test_is_move_constructible<char[3], false>(); + test_is_move_constructible<char[], false>(); + test_is_move_constructible<void, false>(); + test_is_move_constructible<Abstract, false>(); + + test_is_move_constructible<A, true>(); + test_is_move_constructible<int&, true>(); + test_is_move_constructible<Union, true>(); + test_is_move_constructible<Empty, true>(); + test_is_move_constructible<int, true>(); + test_is_move_constructible<double, true>(); + test_is_move_constructible<int*, true>(); + test_is_move_constructible<const int*, true>(); + test_is_move_constructible<NotEmpty, true>(); + test_is_move_constructible<bit_zero, true>(); + test_is_move_constructible<B, true>(); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp new file mode 100644 index 00000000000..b57115269c2 --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_assignable.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_nothrow_assignable + +#include <type_traits> + +struct A +{ +}; + +struct B +{ + void operator=(A); +}; + +int main() +{ + static_assert(( std::is_nothrow_assignable<int&, int&>::value), ""); + static_assert(( std::is_nothrow_assignable<int&, int>::value), ""); + static_assert((!std::is_nothrow_assignable<int, int&>::value), ""); + static_assert((!std::is_nothrow_assignable<int, int>::value), ""); + static_assert(( std::is_nothrow_assignable<int&, double>::value), ""); + static_assert((!std::is_nothrow_assignable<B, A>::value), ""); + static_assert((!std::is_nothrow_assignable<A, B>::value), ""); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp index 24c9eceaabb..3dc73cef1eb 100644 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_constructible.pass.cpp @@ -14,8 +14,6 @@ #include <type_traits> -#ifndef _LIBCPP_HAS_NO_VARIADICS - class Empty { }; @@ -42,11 +40,11 @@ struct A A(const A&); }; -#endif // _LIBCPP_HAS_NO_VARIADICS - int main() { -#ifndef _LIBCPP_HAS_NO_VARIADICS - static_assert((std::is_nothrow_constructible<int, const int>::value), ""); -#endif + static_assert(( std::is_nothrow_constructible<int>::value), ""); + static_assert(( std::is_nothrow_constructible<int, const int&>::value), ""); + static_assert((!std::is_nothrow_constructible<A, int>::value), ""); + static_assert((!std::is_nothrow_constructible<A, int, double>::value), ""); + static_assert((!std::is_nothrow_constructible<A>::value), ""); } diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp index f9947b887b4..b0fe0638559 100644 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_nothrow_copy_assign.pass.cpp +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_assignable.pass.cpp @@ -9,14 +9,14 @@ // type_traits -// has_nothrow_copy_assign +// is_nothrow_copy_assignable #include <type_traits> template <class T, bool Result> void test_has_nothrow_assign() { - static_assert(std::has_nothrow_copy_assign<T>::value == Result, ""); + static_assert(std::is_nothrow_copy_assignable<T>::value == Result, ""); } class Empty @@ -35,11 +35,6 @@ struct bit_zero int : 0; }; -struct Abstract -{ - virtual ~Abstract() = 0; -}; - struct A { A& operator=(const A&); @@ -49,10 +44,7 @@ int main() { test_has_nothrow_assign<void, false>(); test_has_nothrow_assign<A, false>(); - test_has_nothrow_assign<int&, false>(); - test_has_nothrow_assign<Abstract, false>(); - test_has_nothrow_assign<char[3], false>(); - test_has_nothrow_assign<char[], false>(); + test_has_nothrow_assign<int&, true>(); test_has_nothrow_assign<Union, true>(); test_has_nothrow_assign<Empty, true>(); diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp new file mode 100644 index 00000000000..6bb510441bc --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_copy_constructible.pass.cpp @@ -0,0 +1,70 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_nothrow_copy_constructible + +#include <type_traits> + +template <class T> +void test_is_nothrow_copy_constructible() +{ + static_assert( std::is_nothrow_copy_constructible<T>::value, ""); + static_assert( std::is_nothrow_copy_constructible<const T>::value, ""); + static_assert( std::is_nothrow_copy_constructible<volatile T>::value, ""); + static_assert( std::is_nothrow_copy_constructible<const volatile T>::value, ""); +} + +template <class T> +void test_has_not_nothrow_copy_constructor() +{ + static_assert(!std::is_nothrow_copy_constructible<T>::value, ""); + static_assert(!std::is_nothrow_copy_constructible<const T>::value, ""); + static_assert(!std::is_nothrow_copy_constructible<volatile T>::value, ""); + static_assert(!std::is_nothrow_copy_constructible<const volatile T>::value, ""); +} + +class Empty +{ +}; + +class NotEmpty +{ +public: + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +struct A +{ + A(const A&); +}; + +int main() +{ + test_has_not_nothrow_copy_constructor<void>(); + test_has_not_nothrow_copy_constructor<A>(); + + test_is_nothrow_copy_constructible<int&>(); + test_is_nothrow_copy_constructible<Union>(); + test_is_nothrow_copy_constructible<Empty>(); + test_is_nothrow_copy_constructible<int>(); + test_is_nothrow_copy_constructible<double>(); + test_is_nothrow_copy_constructible<int*>(); + test_is_nothrow_copy_constructible<const int*>(); + test_is_nothrow_copy_constructible<NotEmpty>(); + test_is_nothrow_copy_constructible<bit_zero>(); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp new file mode 100644 index 00000000000..84fb5f41bf1 --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_default_constructible.pass.cpp @@ -0,0 +1,71 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_nothrow_default_constructible + +#include <type_traits> + +template <class T> +void test_is_nothrow_default_constructible() +{ + static_assert( std::is_nothrow_default_constructible<T>::value, ""); + static_assert( std::is_nothrow_default_constructible<const T>::value, ""); + static_assert( std::is_nothrow_default_constructible<volatile T>::value, ""); + static_assert( std::is_nothrow_default_constructible<const volatile T>::value, ""); +} + +template <class T> +void test_has_not_nothrow_default_constructor() +{ + static_assert(!std::is_nothrow_default_constructible<T>::value, ""); + static_assert(!std::is_nothrow_default_constructible<const T>::value, ""); + static_assert(!std::is_nothrow_default_constructible<volatile T>::value, ""); + static_assert(!std::is_nothrow_default_constructible<const volatile T>::value, ""); +} + +class Empty +{ +}; + +class NotEmpty +{ +public: + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +struct A +{ + A(); +}; + +int main() +{ + test_has_not_nothrow_default_constructor<void>(); + test_has_not_nothrow_default_constructor<int&>(); + test_has_not_nothrow_default_constructor<A>(); + + test_is_nothrow_default_constructible<Union>(); + test_is_nothrow_default_constructible<Empty>(); + test_is_nothrow_default_constructible<int>(); + test_is_nothrow_default_constructible<double>(); + test_is_nothrow_default_constructible<int*>(); + test_is_nothrow_default_constructible<const int*>(); + test_is_nothrow_default_constructible<char[3]>(); + test_is_nothrow_default_constructible<NotEmpty>(); + test_is_nothrow_default_constructible<bit_zero>(); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp new file mode 100644 index 00000000000..dfa1b36cf21 --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp @@ -0,0 +1,77 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_nothrow_destructible + +#include <type_traits> + +template <class T> +void test_is_nothrow_destructible() +{ + static_assert( std::is_nothrow_destructible<T>::value, ""); + static_assert( std::is_nothrow_destructible<const T>::value, ""); + static_assert( std::is_nothrow_destructible<volatile T>::value, ""); + static_assert( std::is_nothrow_destructible<const volatile T>::value, ""); +} + +template <class T> +void test_has_not_nothrow_destructor() +{ + static_assert(!std::is_nothrow_destructible<T>::value, ""); + static_assert(!std::is_nothrow_destructible<const T>::value, ""); + static_assert(!std::is_nothrow_destructible<volatile T>::value, ""); + static_assert(!std::is_nothrow_destructible<const volatile T>::value, ""); +} + +class Empty +{ +}; + +class NotEmpty +{ + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +class Abstract +{ + virtual ~Abstract() = 0; +}; + +struct A +{ + ~A(); +}; + +int main() +{ + test_has_not_nothrow_destructor<void>(); + test_has_not_nothrow_destructor<A>(); + test_has_not_nothrow_destructor<Abstract>(); + test_has_not_nothrow_destructor<NotEmpty>(); + + test_is_nothrow_destructible<int&>(); + test_is_nothrow_destructible<Union>(); + test_is_nothrow_destructible<Empty>(); + test_is_nothrow_destructible<int>(); + test_is_nothrow_destructible<double>(); + test_is_nothrow_destructible<int*>(); + test_is_nothrow_destructible<const int*>(); + test_is_nothrow_destructible<char[3]>(); + test_is_nothrow_destructible<char[3]>(); + test_is_nothrow_destructible<bit_zero>(); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp new file mode 100644 index 00000000000..96a4a32b37d --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_assignable.pass.cpp @@ -0,0 +1,57 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// has_nothrow_move_assign + +#include <type_traits> + +template <class T, bool Result> +void test_has_nothrow_assign() +{ + static_assert(std::is_nothrow_move_assignable<T>::value == Result, ""); +} + +class Empty +{ +}; + +struct NotEmpty +{ + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +struct A +{ + A& operator=(const A&); +}; + +int main() +{ + test_has_nothrow_assign<void, false>(); + test_has_nothrow_assign<A, false>(); + test_has_nothrow_assign<int&, true>(); + + test_has_nothrow_assign<Union, true>(); + test_has_nothrow_assign<Empty, true>(); + test_has_nothrow_assign<int, true>(); + test_has_nothrow_assign<double, true>(); + test_has_nothrow_assign<int*, true>(); + test_has_nothrow_assign<const int*, true>(); + test_has_nothrow_assign<NotEmpty, true>(); + test_has_nothrow_assign<bit_zero, true>(); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp new file mode 100644 index 00000000000..fc5207601e8 --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_move_constructible.pass.cpp @@ -0,0 +1,70 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// has_nothrow_move_constructor + +#include <type_traits> + +template <class T> +void test_is_nothrow_move_constructible() +{ + static_assert( std::is_nothrow_move_constructible<T>::value, ""); + static_assert( std::is_nothrow_move_constructible<const T>::value, ""); + static_assert( std::is_nothrow_move_constructible<volatile T>::value, ""); + static_assert( std::is_nothrow_move_constructible<const volatile T>::value, ""); +} + +template <class T> +void test_has_not_nothrow_move_constructor() +{ + static_assert(!std::is_nothrow_move_constructible<T>::value, ""); + static_assert(!std::is_nothrow_move_constructible<const T>::value, ""); + static_assert(!std::is_nothrow_move_constructible<volatile T>::value, ""); + static_assert(!std::is_nothrow_move_constructible<const volatile T>::value, ""); +} + +class Empty +{ +}; + +class NotEmpty +{ +public: + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +struct A +{ + A(const A&); +}; + +int main() +{ + test_has_not_nothrow_move_constructor<void>(); + test_has_not_nothrow_move_constructor<A>(); + + test_has_not_nothrow_move_constructor<int&>(); + test_is_nothrow_move_constructible<Union>(); + test_is_nothrow_move_constructible<Empty>(); + test_is_nothrow_move_constructible<int>(); + test_is_nothrow_move_constructible<double>(); + test_is_nothrow_move_constructible<int*>(); + test_is_nothrow_move_constructible<const int*>(); + test_is_nothrow_move_constructible<NotEmpty>(); + test_is_nothrow_move_constructible<bit_zero>(); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp new file mode 100644 index 00000000000..cd6d5d277be --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_assignable.pass.cpp @@ -0,0 +1,34 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_trivially_assignable + +#include <type_traits> + +struct A +{ +}; + +struct B +{ + void operator=(A); +}; + +int main() +{ + static_assert(( std::is_trivially_assignable<int&, int&>::value), ""); + static_assert(( std::is_trivially_assignable<int&, int>::value), ""); + static_assert((!std::is_trivially_assignable<int, int&>::value), ""); + static_assert((!std::is_trivially_assignable<int, int>::value), ""); + static_assert(( std::is_trivially_assignable<int&, double>::value), ""); + static_assert((!std::is_trivially_assignable<B, A>::value), ""); + static_assert((!std::is_trivially_assignable<A, B>::value), ""); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp new file mode 100644 index 00000000000..ce0373baf28 --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_constructible.pass.cpp @@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// template <class T, class... Args> +// struct is_trivially_constructible; + +#include <type_traits> + +struct A +{ + explicit A(int); + A(int, double); +}; + +int main() +{ + static_assert(( std::is_trivially_constructible<int>::value), ""); + static_assert(( std::is_trivially_constructible<int, const int&>::value), ""); + static_assert((!std::is_trivially_constructible<A, int>::value), ""); + static_assert((!std::is_trivially_constructible<A, int, double>::value), ""); + static_assert((!std::is_trivially_constructible<A>::value), ""); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_assign.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp index aa604a9f2a8..2ec06a09e74 100644 --- a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/has_trivial_copy_assign.pass.cpp +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_assignable.pass.cpp @@ -9,14 +9,14 @@ // type_traits -// has_trivial_copy_assign +// is_trivially_copy_assignable #include <type_traits> template <class T, bool Result> void test_has_trivial_assign() { - static_assert(std::has_trivial_copy_assign<T>::value == Result, ""); + static_assert(std::is_trivially_copy_assignable<T>::value == Result, ""); } class Empty @@ -49,12 +49,10 @@ int main() { test_has_trivial_assign<void, false>(); test_has_trivial_assign<A, false>(); - test_has_trivial_assign<int&, false>(); + test_has_trivial_assign<int&, true>(); test_has_trivial_assign<NotEmpty, false>(); test_has_trivial_assign<Abstract, false>(); test_has_trivial_assign<const Empty, false>(); - test_has_trivial_assign<char[3], false>(); - test_has_trivial_assign<char[], false>(); test_has_trivial_assign<Union, true>(); test_has_trivial_assign<Empty, true>(); diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp new file mode 100644 index 00000000000..45f63622f85 --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_copy_constructible.pass.cpp @@ -0,0 +1,77 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_trivially_copy_constructible + +#include <type_traits> + +template <class T> +void test_is_trivially_copy_constructible() +{ + static_assert( std::is_trivially_copy_constructible<T>::value, ""); + static_assert( std::is_trivially_copy_constructible<const T>::value, ""); + static_assert( std::is_trivially_copy_constructible<volatile T>::value, ""); + static_assert( std::is_trivially_copy_constructible<const volatile T>::value, ""); +} + +template <class T> +void test_has_not_trivial_copy_constructor() +{ + static_assert(!std::is_trivially_copy_constructible<T>::value, ""); + static_assert(!std::is_trivially_copy_constructible<const T>::value, ""); + static_assert(!std::is_trivially_copy_constructible<volatile T>::value, ""); + static_assert(!std::is_trivially_copy_constructible<const volatile T>::value, ""); +} + +class Empty +{ +}; + +class NotEmpty +{ +public: + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +class Abstract +{ +public: + virtual ~Abstract() = 0; +}; + +struct A +{ + A(const A&); +}; + +int main() +{ + test_has_not_trivial_copy_constructor<void>(); + test_has_not_trivial_copy_constructor<A>(); + test_has_not_trivial_copy_constructor<Abstract>(); + test_has_not_trivial_copy_constructor<NotEmpty>(); + + test_is_trivially_copy_constructible<int&>(); + test_is_trivially_copy_constructible<Union>(); + test_is_trivially_copy_constructible<Empty>(); + test_is_trivially_copy_constructible<int>(); + test_is_trivially_copy_constructible<double>(); + test_is_trivially_copy_constructible<int*>(); + test_is_trivially_copy_constructible<const int*>(); + test_is_trivially_copy_constructible<bit_zero>(); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp new file mode 100644 index 00000000000..1f63401dacb --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_default_constructible.pass.cpp @@ -0,0 +1,76 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_trivially_default_constructible + +#include <type_traits> + +template <class T> +void test_is_trivially_default_constructible() +{ + static_assert( std::is_trivially_default_constructible<T>::value, ""); + static_assert( std::is_trivially_default_constructible<const T>::value, ""); + static_assert( std::is_trivially_default_constructible<volatile T>::value, ""); + static_assert( std::is_trivially_default_constructible<const volatile T>::value, ""); +} + +template <class T> +void test_has_not_trivial_default_constructor() +{ + static_assert(!std::is_trivially_default_constructible<T>::value, ""); + static_assert(!std::is_trivially_default_constructible<const T>::value, ""); + static_assert(!std::is_trivially_default_constructible<volatile T>::value, ""); + static_assert(!std::is_trivially_default_constructible<const volatile T>::value, ""); +} + +class Empty +{ +}; + +class NotEmpty +{ + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +class Abstract +{ + virtual ~Abstract() = 0; +}; + +struct A +{ + A(); +}; + +int main() +{ + test_has_not_trivial_default_constructor<void>(); + test_has_not_trivial_default_constructor<int&>(); + test_has_not_trivial_default_constructor<A>(); + test_has_not_trivial_default_constructor<Abstract>(); + test_has_not_trivial_default_constructor<NotEmpty>(); + + test_is_trivially_default_constructible<Union>(); + test_is_trivially_default_constructible<Empty>(); + test_is_trivially_default_constructible<int>(); + test_is_trivially_default_constructible<double>(); + test_is_trivially_default_constructible<int*>(); + test_is_trivially_default_constructible<const int*>(); + test_is_trivially_default_constructible<char[3]>(); + test_is_trivially_default_constructible<bit_zero>(); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp new file mode 100644 index 00000000000..ebe10e32009 --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp @@ -0,0 +1,77 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_trivially_destructible + +#include <type_traits> + +template <class T> +void test_is_trivially_destructible() +{ + static_assert( std::is_trivially_destructible<T>::value, ""); + static_assert( std::is_trivially_destructible<const T>::value, ""); + static_assert( std::is_trivially_destructible<volatile T>::value, ""); + static_assert( std::is_trivially_destructible<const volatile T>::value, ""); +} + +template <class T> +void test_has_not_trivial_destructor() +{ + static_assert(!std::is_trivially_destructible<T>::value, ""); + static_assert(!std::is_trivially_destructible<const T>::value, ""); + static_assert(!std::is_trivially_destructible<volatile T>::value, ""); + static_assert(!std::is_trivially_destructible<const volatile T>::value, ""); +} + +class Empty +{ +}; + +class NotEmpty +{ + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +class Abstract +{ + virtual ~Abstract() = 0; +}; + +struct A +{ + ~A(); +}; + +int main() +{ + test_has_not_trivial_destructor<void>(); + test_has_not_trivial_destructor<A>(); + test_has_not_trivial_destructor<Abstract>(); + test_has_not_trivial_destructor<NotEmpty>(); + + test_is_trivially_destructible<int&>(); + test_is_trivially_destructible<Union>(); + test_is_trivially_destructible<Empty>(); + test_is_trivially_destructible<int>(); + test_is_trivially_destructible<double>(); + test_is_trivially_destructible<int*>(); + test_is_trivially_destructible<const int*>(); + test_is_trivially_destructible<char[3]>(); + test_is_trivially_destructible<char[3]>(); + test_is_trivially_destructible<bit_zero>(); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp new file mode 100644 index 00000000000..dcdaa25b16a --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_assignable.pass.cpp @@ -0,0 +1,64 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_trivially_move_assignable + +#include <type_traits> + +template <class T, bool Result> +void test_has_trivial_assign() +{ + static_assert(std::is_trivially_move_assignable<T>::value == Result, ""); +} + +class Empty +{ +}; + +class NotEmpty +{ + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +class Abstract +{ + virtual ~Abstract() = 0; +}; + +struct A +{ + A& operator=(const A&); +}; + +int main() +{ + test_has_trivial_assign<void, false>(); + test_has_trivial_assign<A, false>(); + test_has_trivial_assign<int&, true>(); + test_has_trivial_assign<NotEmpty, false>(); + test_has_trivial_assign<Abstract, false>(); + test_has_trivial_assign<const Empty, false>(); + + test_has_trivial_assign<Union, true>(); + test_has_trivial_assign<Empty, true>(); + test_has_trivial_assign<int, true>(); + test_has_trivial_assign<double, true>(); + test_has_trivial_assign<int*, true>(); + test_has_trivial_assign<const int*, true>(); + test_has_trivial_assign<bit_zero, true>(); +} diff --git a/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp new file mode 100644 index 00000000000..a4fcbcb09c5 --- /dev/null +++ b/libcxx/test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_move_constructible.pass.cpp @@ -0,0 +1,77 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// type_traits + +// is_trivially_move_constructible + +#include <type_traits> + +template <class T> +void test_is_trivially_move_constructible() +{ + static_assert( std::is_trivially_move_constructible<T>::value, ""); + static_assert( std::is_trivially_move_constructible<const T>::value, ""); + static_assert( std::is_trivially_move_constructible<volatile T>::value, ""); + static_assert( std::is_trivially_move_constructible<const volatile T>::value, ""); +} + +template <class T> +void test_has_not_trivial_move_constructor() +{ + static_assert(!std::is_trivially_move_constructible<T>::value, ""); + static_assert(!std::is_trivially_move_constructible<const T>::value, ""); + static_assert(!std::is_trivially_move_constructible<volatile T>::value, ""); + static_assert(!std::is_trivially_move_constructible<const volatile T>::value, ""); +} + +class Empty +{ +}; + +class NotEmpty +{ +public: + virtual ~NotEmpty(); +}; + +union Union {}; + +struct bit_zero +{ + int : 0; +}; + +class Abstract +{ +public: + virtual ~Abstract() = 0; +}; + +struct A +{ + A(const A&); +}; + +int main() +{ + test_has_not_trivial_move_constructor<void>(); + test_has_not_trivial_move_constructor<A>(); + test_has_not_trivial_move_constructor<Abstract>(); + test_has_not_trivial_move_constructor<NotEmpty>(); + + test_is_trivially_move_constructible<int&>(); + test_is_trivially_move_constructible<Union>(); + test_is_trivially_move_constructible<Empty>(); + test_is_trivially_move_constructible<int>(); + test_is_trivially_move_constructible<double>(); + test_is_trivially_move_constructible<int*>(); + test_is_trivially_move_constructible<const int*>(); + test_is_trivially_move_constructible<bit_zero>(); +} |
