[libcxx] Cleanup and fix is_destructible and tests in C++03.

[EricWF]

Summary

There are a couple of changes in this patch:

1. Fix is_nothrow_destructible<int[]> in C++03 mode to be false.
2. Wrap access control tests in #ifdef block
3. Wrap deleted function tests in #ifdef block.
4. Make the destructor public for the Abstract and AbstractDestructor types.

[mclow.lists]

I'm unsure why we're testing for __has_feature(cxx_noexcept) in is_nothrow_destructible.pass.cpp

test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp

72

I like the idea of adding a test for an array of known bound, but did you mean [3] or [][3] ??

[EricWF]

In D6316#4, @mclow.lists wrote:

I'm unsure why we're testing for __has_feature(cxx_noexcept) in is_nothrow_destructible.pass.cpp

The toggle between the C++11 and C++03 implementation of is_nothrow_destructible is __has_feature(cxx_noexcept). I think it is silly, but that is the way it currently works.

test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp

72

There is a test for an array of a known bound below. I just wanted to make sure a multi-dimensional array with an unknown bound was handled as I expected.

test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp

40

I think this change sneaked in. Is this dtor meant to be private?

[EricWF]

This is a duplicate of an already closed review. Abandoning. Sorry for the noise.

include/type_traits

 
 template <class _Tp> struct __libcpp_nothrow_destructor
     : public integral_constant<bool, is_scalar<_Tp>::value ||
                                      is_reference<_Tp>::value> {};
 
 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 integral_constant<bool, false> {};
 #endif
 
 // is_pod
 
 #if __has_feature(is_pod) || (_GNUC_VER >= 403)
 
 template <class _Tp> struct _LIBCPP_TYPE_VIS_ONLY is_pod
     : public integral_constant<bool, __is_pod(_Tp)> {};

test/utilities/meta/meta.unary/meta.unary.prop/is_destructible.pass.cpp

 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; };
 
+#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
 struct DeletedPublicDestructor           { public:    ~DeletedPublicDestructor() = delete; };
 struct DeletedProtectedDestructor        { protected: ~DeletedProtectedDestructor() = delete; };
 struct DeletedPrivateDestructor          { private:   ~DeletedPrivateDestructor() = delete; };
 
 struct DeletedVirtualPublicDestructor    { public:    virtual ~DeletedVirtualPublicDestructor() = delete; };
 struct DeletedVirtualProtectedDestructor { protected: virtual ~DeletedVirtualProtectedDestructor() = delete; };
 struct DeletedVirtualPrivateDestructor   { private:   virtual ~DeletedVirtualPrivateDestructor() = delete; };
-
+#endif
 
 int main()
 {
     test_is_destructible<A>();
     test_is_destructible<int&>();
     test_is_destructible<Union>();
     test_is_destructible<Empty>();
     test_is_destructible<int>();
     test_is_destructible<double>();
     test_is_destructible<int*>();
     test_is_destructible<const int*>();
     test_is_destructible<char[3]>();
     test_is_destructible<bit_zero>();
     test_is_destructible<int[3]>();
     test_is_destructible<ProtectedAbstract>();
     test_is_destructible<PublicAbstract>();
     test_is_destructible<PrivateAbstract>();
     test_is_destructible<PublicDestructor>();
     test_is_destructible<VirtualPublicDestructor>();
     test_is_destructible<PurePublicDestructor>();
 
     test_is_not_destructible<int[]>();
     test_is_not_destructible<void>();
 
+#if __has_feature(cxx_access_control_sfinae)
     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>();
+#endif
+#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
     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<DeletedVirtualProtectedDestructor>();
     test_is_not_destructible<DeletedVirtualPrivateDestructor>();
-
+#endif
 #if __has_feature(cxx_access_control_sfinae) 
     test_is_not_destructible<NotEmpty>();
 #endif
     test_is_not_destructible<Function>();
 }

test/utilities/meta/meta.unary/meta.unary.prop/is_nothrow_destructible.pass.cpp

 
 struct bit_zero
 {
     int :  0;
 };
 
 class Abstract
 {
+public:
     virtual void foo() = 0;
 };
 
 class AbstractDestructor
 {
+public:
     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]>();
+#if __has_feature(cxx_noexcept)
     test_is_nothrow_destructible<Abstract>();
+    test_is_nothrow_destructible<AbstractDestructor>();
+#endif
 #if __has_feature(cxx_noexcept)
     test_is_nothrow_destructible<bit_zero>();
 #endif
 }

test/utilities/meta/meta.unary/meta.unary.prop/is_trivially_destructible.pass.cpp

 }
 
 class Empty
 {
 };
 
 class NotEmpty
 {
+public:
     virtual ~NotEmpty();
 };
 
 union Union {};
 
 struct bit_zero
 {
     int :  0;
 };
 
 class Abstract
 {
+public:
     virtual void foo() = 0;
 };
 
 class AbstractDestructor
 {
+public:
     virtual ~AbstractDestructor() = 0;
 };
 
 struct A
 {
     ~A();
 };