Author: ericwf Date: Sat Jul 18 11:43:58 2015 New Revision: 242612 URL: http://llvm.org/viewvc/llvm-project?rev=242612&view=rev Log: [libcxx] Get is_*_destructible tests passing in C++03.
Summary: This patch adds proper guards to the is_destructible tests depending on the standard version so that they pass in c++03. Reviewers: mclow.lists, EricWF Subscribers: cfe-commits Differential Revision: http://reviews.llvm.org/D10047 Modified: libcxx/trunk/include/type_traits libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp Modified: libcxx/trunk/include/type_traits URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/type_traits?rev=242612&r1=242611&r2=242612&view=diff ============================================================================== --- libcxx/trunk/include/type_traits (original) +++ libcxx/trunk/include/type_traits Sat Jul 18 11:43:58 2015 @@ -2917,6 +2917,9 @@ template <class _Tp> struct __libcpp_tri template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_destructible : public __libcpp_trivial_destructor<typename remove_all_extents<_Tp>::type> {}; +template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_trivially_destructible<_Tp[]> + : public false_type {}; + #endif // is_nothrow_constructible @@ -3241,6 +3244,10 @@ template <class _Tp> struct __libcpp_not template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible : public __libcpp_nothrow_destructor<typename remove_all_extents<_Tp>::type> {}; +template <class _Tp> +struct _LIBCPP_TYPE_VIS_ONLY is_nothrow_destructible<_Tp[]> + : public false_type {}; + #endif // is_pod Modified: libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp?rev=242612&r1=242611&r2=242612&view=diff ============================================================================== --- libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp (original) +++ libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp Sat Jul 18 11:43:58 2015 @@ -13,6 +13,8 @@ #include <type_traits> +#include "test_macros.h" + template <class T> void test_is_destructible() { @@ -68,6 +70,7 @@ struct PurePublicDestructor struct PureProtectedDestructor { protected: virtual ~PureProtectedDestructor() = 0; }; struct PurePrivateDestructor { private: virtual ~PurePrivateDestructor() = 0; }; +#if TEST_STD_VER >= 11 struct DeletedPublicDestructor { public: ~DeletedPublicDestructor() = delete; }; struct DeletedProtectedDestructor { protected: ~DeletedProtectedDestructor() = delete; }; struct DeletedPrivateDestructor { private: ~DeletedPrivateDestructor() = delete; }; @@ -75,6 +78,7 @@ struct DeletedPrivateDestructor struct DeletedVirtualPublicDestructor { public: virtual ~DeletedVirtualPublicDestructor() = delete; }; struct DeletedVirtualProtectedDestructor { protected: virtual ~DeletedVirtualProtectedDestructor() = delete; }; struct DeletedVirtualPrivateDestructor { private: virtual ~DeletedVirtualPrivateDestructor() = delete; }; +#endif int main() @@ -99,23 +103,27 @@ int main() test_is_not_destructible<int[]>(); test_is_not_destructible<void>(); + test_is_not_destructible<Function>(); +#if TEST_STD_VER >= 11 + // Test access controlled destructors test_is_not_destructible<ProtectedDestructor>(); test_is_not_destructible<PrivateDestructor>(); test_is_not_destructible<VirtualProtectedDestructor>(); test_is_not_destructible<VirtualPrivateDestructor>(); test_is_not_destructible<PureProtectedDestructor>(); test_is_not_destructible<PurePrivateDestructor>(); + + // Test deleted constructors test_is_not_destructible<DeletedPublicDestructor>(); test_is_not_destructible<DeletedProtectedDestructor>(); test_is_not_destructible<DeletedPrivateDestructor>(); - -// test_is_not_destructible<DeletedVirtualPublicDestructor>(); // currently fails due to clang bug #20268 + //test_is_not_destructible<DeletedVirtualPublicDestructor>(); // previously failed due to clang bug #20268 test_is_not_destructible<DeletedVirtualProtectedDestructor>(); test_is_not_destructible<DeletedVirtualPrivateDestructor>(); -#if __has_feature(cxx_access_control_sfinae) + // Test private destructors test_is_not_destructible<NotEmpty>(); #endif - test_is_not_destructible<Function>(); + } Modified: libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp?rev=242612&r1=242611&r2=242612&view=diff ============================================================================== --- libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp (original) +++ libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp Sat Jul 18 11:43:58 2015 @@ -13,6 +13,8 @@ #include <type_traits> +#include "test_macros.h" + template <class T> void test_is_nothrow_destructible() { @@ -31,14 +33,23 @@ void test_is_not_nothrow_destructible() static_assert(!std::is_nothrow_destructible<const volatile T>::value, ""); } + +struct PublicDestructor { public: ~PublicDestructor() {}}; +struct ProtectedDestructor { protected: ~ProtectedDestructor() {}}; +struct PrivateDestructor { private: ~PrivateDestructor() {}}; + +struct VirtualPublicDestructor { public: virtual ~VirtualPublicDestructor() {}}; +struct VirtualProtectedDestructor { protected: virtual ~VirtualProtectedDestructor() {}}; +struct VirtualPrivateDestructor { private: virtual ~VirtualPrivateDestructor() {}}; + +struct PurePublicDestructor { public: virtual ~PurePublicDestructor() = 0; }; +struct PureProtectedDestructor { protected: virtual ~PureProtectedDestructor() = 0; }; +struct PurePrivateDestructor { private: virtual ~PurePrivateDestructor() = 0; }; + class Empty { }; -class NotEmpty -{ - virtual ~NotEmpty(); -}; union Union {}; @@ -52,40 +63,36 @@ class Abstract virtual void foo() = 0; }; -class AbstractDestructor -{ - virtual ~AbstractDestructor() = 0; -}; - -struct A -{ - ~A(); -}; int main() { test_is_not_nothrow_destructible<void>(); - test_is_not_nothrow_destructible<AbstractDestructor>(); - test_is_not_nothrow_destructible<NotEmpty>(); test_is_not_nothrow_destructible<char[]>(); + test_is_not_nothrow_destructible<char[][3]>(); -#if __has_feature(cxx_noexcept) - test_is_nothrow_destructible<A>(); -#endif test_is_nothrow_destructible<int&>(); -#if __has_feature(cxx_unrestricted_unions) - test_is_nothrow_destructible<Union>(); -#endif -#if __has_feature(cxx_access_control_sfinae) - test_is_nothrow_destructible<Empty>(); -#endif 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<Abstract>(); -#if __has_feature(cxx_noexcept) + +#if TEST_STD_VER >= 11 + // requires noexcept. These are all destructible. + test_is_nothrow_destructible<PublicDestructor>(); + test_is_nothrow_destructible<VirtualPublicDestructor>(); + test_is_nothrow_destructible<PurePublicDestructor>(); test_is_nothrow_destructible<bit_zero>(); + test_is_nothrow_destructible<Abstract>(); + test_is_nothrow_destructible<Empty>(); + test_is_nothrow_destructible<Union>(); + + // requires access control + test_is_not_nothrow_destructible<ProtectedDestructor>(); + test_is_not_nothrow_destructible<PrivateDestructor>(); + test_is_not_nothrow_destructible<VirtualProtectedDestructor>(); + test_is_not_nothrow_destructible<VirtualPrivateDestructor>(); + test_is_not_nothrow_destructible<PureProtectedDestructor>(); + test_is_not_nothrow_destructible<PurePrivateDestructor>(); #endif } Modified: libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp URL: http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp?rev=242612&r1=242611&r2=242612&view=diff ============================================================================== --- libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp (original) +++ libcxx/trunk/test/std/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp Sat Jul 18 11:43:58 2015 @@ -13,6 +13,8 @@ #include <type_traits> +#include "test_macros.h" + template <class T> void test_is_trivially_destructible() { @@ -31,13 +33,21 @@ void test_is_not_trivially_destructible( static_assert(!std::is_trivially_destructible<const volatile T>::value, ""); } -class Empty -{ -}; +struct PublicDestructor { public: ~PublicDestructor() {}}; +struct ProtectedDestructor { protected: ~ProtectedDestructor() {}}; +struct PrivateDestructor { private: ~PrivateDestructor() {}}; + +struct VirtualPublicDestructor { public: virtual ~VirtualPublicDestructor() {}}; +struct VirtualProtectedDestructor { protected: virtual ~VirtualProtectedDestructor() {}}; +struct VirtualPrivateDestructor { private: virtual ~VirtualPrivateDestructor() {}}; + +struct PurePublicDestructor { public: virtual ~PurePublicDestructor() = 0; }; +struct PureProtectedDestructor { protected: virtual ~PureProtectedDestructor() = 0; }; +struct PurePrivateDestructor { private: virtual ~PurePrivateDestructor() = 0; }; + -class NotEmpty +class Empty { - virtual ~NotEmpty(); }; union Union {}; @@ -66,18 +76,28 @@ int main() { test_is_not_trivially_destructible<void>(); test_is_not_trivially_destructible<A>(); - test_is_not_trivially_destructible<AbstractDestructor>(); - test_is_not_trivially_destructible<NotEmpty>(); test_is_not_trivially_destructible<char[]>(); + test_is_not_trivially_destructible<VirtualPublicDestructor>(); + test_is_not_trivially_destructible<PurePublicDestructor>(); test_is_trivially_destructible<Abstract>(); - test_is_trivially_destructible<int&>(); test_is_trivially_destructible<Union>(); test_is_trivially_destructible<Empty>(); + test_is_trivially_destructible<int&>(); 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<bit_zero>(); + +#if TEST_STD_VER >= 11 + // requires access control sfinae + test_is_not_trivially_destructible<ProtectedDestructor>(); + test_is_not_trivially_destructible<PrivateDestructor>(); + test_is_not_trivially_destructible<VirtualProtectedDestructor>(); + test_is_not_trivially_destructible<VirtualPrivateDestructor>(); + test_is_not_trivially_destructible<PureProtectedDestructor>(); + test_is_not_trivially_destructible<PurePrivateDestructor>(); +#endif } _______________________________________________ cfe-commits mailing list cfe-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
