Remove redundant noexcept specifier

to compile with gcc 4.6

include/boost/fusion/container/vector/vector.hpp

@@ -26,6 +26,7 @@
 #include <boost/fusion/support/is_sequence.hpp>
 #include <boost/fusion/support/detail/and.hpp>
 #include <boost/fusion/support/detail/index_sequence.hpp>
+#include <boost/fusion/support/detail/propagate_trivialness.hpp>
 #include <boost/fusion/container/vector/detail/at_impl.hpp>
 #include <boost/fusion/container/vector/detail/value_at_impl.hpp>
 #include <boost/fusion/container/vector/detail/begin_impl.hpp>
@@ -50,8 +51,6 @@ namespace boost { namespace fusion
 
     namespace vector_detail
     {
-        struct each_elem {};
-
         template <
             typename This, typename T, typename T_, std::size_t Size, bool IsSeq
         >
@@ -131,32 +130,6 @@ namespace boost { namespace fusion
                 : elem() // value-initialized explicitly
             {}
 
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            store(store const& rhs)
-                : elem(rhs.elem)
-            {}
-
-            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            store&
-            operator=(store const& rhs)
-            {
-                elem = rhs.elem;
-                return *this;
-            }
-
-            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            store(store&& rhs)
-                : elem(static_cast<T&&>(rhs.elem))
-            {}
-
-            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            store&
-            operator=(store&& rhs)
-            {
-                elem = static_cast<T&&>(rhs.elem);
-                return *this;
-            }
-
             template <
                 typename U
               , typename = typename boost::disable_if<
@@ -178,6 +151,7 @@ namespace boost { namespace fusion
         struct vector_data<detail::index_sequence<I...>, T...>
             : store<I, T>...
             , sequence_base<vector_data<detail::index_sequence<I...>, T...> >
+            , private detail::propagate_trivialness<T...>
         {
             typedef vector_tag                  fusion_tag;
             typedef fusion_sequence_tag         tag; // this gets picked up by MPL
@@ -198,14 +172,14 @@ namespace boost { namespace fusion
             >
             BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             explicit
-            vector_data(each_elem, Sequence&& rhs)
+            vector_data(Sequence&& rhs)
                 : store<I, T>(forward_at_c<I>(std::forward<Sequence>(rhs)))...
             {}
 
             template <typename ...U>
             BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
             explicit
-            vector_data(each_elem, U&&... var)
+            vector_data(U&&... var)
                 : store<I, T>(std::forward<U>(var))...
             {}
 
@@ -290,7 +264,7 @@ namespace boost { namespace fusion
         //      In the (near) future release, should be fixed.
         /* BOOST_CONSTEXPR */ BOOST_FUSION_GPU_ENABLED
         explicit vector(U&&... u)
-            : base(vector_detail::each_elem(), std::forward<U>(u)...)
+            : base(std::forward<U>(u)...)
         {}
 
         template <
@@ -303,7 +277,7 @@ namespace boost { namespace fusion
         >
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         vector(Sequence&& seq)
-            : base(vector_detail::each_elem(), std::forward<Sequence>(seq))
+            : base(std::forward<Sequence>(seq))
         {}
 
         template <typename Sequence>

include/boost/fusion/support/config.hpp

@@ -116,4 +116,11 @@ namespace std
 #   define BOOST_FUSION_NOEXCEPT_ON_DEFAULTED BOOST_NOEXCEPT
 #endif
 
+
+#ifdef __has_extension
+#   define BOOST_FUSION_HAS_EXTENSION __has_extension
+#else
+#   define BOOST_FUSION_HAS_EXTENSION(_) 0
+#endif
+
 #endif

include/boost/fusion/support/detail/is_trivially_copyable.hpp

@@ -0,0 +1,113 @@
+/*=============================================================================
+    Copyright (c) 2018 Kohei Takahashi
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_FUSION_SUPPORT_DETAIL_IS_TRIVIALLY_COPYABLE
+#define BOOST_FUSION_SUPPORT_DETAIL_IS_TRIVIALLY_COPYABLE
+
+#include <boost/fusion/support/config.hpp>
+
+#if BOOST_WORKAROUND(BOOST_GCC, BOOST_TESTED_AT(90000))
+    // GCC treats volatile qualified scalar type as non trivially copyable,
+    // so to be fail safe, we also treat it as non trivially copyable type.
+    // http://wg21.link/cwg2094
+    // https://gcc.gnu.org/PR85679
+    //
+    // Some version of clang also tweats volatile qualified scalar type as
+    // non trivially copyable type, but all of known the versions what
+    // behaves as CWG 496 but not CWG 2094 implement builtin.
+    // So we don't have to emulate CWG 496 on clang.
+#   define BOOST_FUSION_DETAIL_VOLATILE_SCALAR_IS_NON_TRIVIALLY_COPYABLE
+#endif
+
+#if BOOST_FUSION_HAS_EXTENSION(is_trivially_copyable) || \
+    (50000 <= BOOST_GCC) || (1700 <= BOOST_MSVC)
+#   define BOOST_FUSION_IS_TRIVIALLY_COPYABLE __is_trivially_copyable
+#endif
+
+#if defined(BOOST_FUSION_IS_TRIVIALLY_COPYABLE)
+#   define BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING 2
+#   include <boost/mpl/bool.hpp>
+#elif !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+#   define BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING 2
+#   include <type_traits>
+#else
+#   include <boost/config/workaround.hpp>
+#   include <boost/mpl/bool.hpp>
+#   include <boost/mpl/if.hpp>
+#   include <boost/type_traits/remove_cv.hpp>
+#   include <boost/type_traits/remove_all_extents.hpp>
+#   include <boost/type_traits/is_scalar.hpp>
+#   include <boost/type_traits/is_class.hpp>
+#   include <boost/type_traits/is_union.hpp>
+#   include <boost/type_traits/is_constructible.hpp>
+#   include <boost/type_traits/is_assignable.hpp>
+#   include <boost/type_traits/is_copy_constructible.hpp>
+#   include <boost/type_traits/is_copy_assignable.hpp>
+#   include <boost/type_traits/has_trivial_assign.hpp>
+#   include <boost/type_traits/has_trivial_copy.hpp>
+#   include <boost/type_traits/has_trivial_destructor.hpp>
+#   include <boost/type_traits/has_trivial_move_assign.hpp>
+#   include <boost/type_traits/has_trivial_move_constructor.hpp>
+#ifdef BOOST_FUSION_DETAIL_VOLATILE_SCALAR_IS_NON_TRIVIALLY_COPYABLE
+#   include <boost/mpl/not.hpp>
+#   include <boost/type_traits/is_volatile.hpp>
+#endif
+#endif // <type_traits>
+
+namespace boost { namespace fusion { namespace detail
+{
+
+#ifndef BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING
+#if defined(BOOST_SFINAE_EXPR) && !defined(BOOST_NO_CXX11_DECLTYPE) && \
+    defined(BOOST_IS_UNION) && defined(BOOST_TT_HAS_CONFORMING_IS_CLASS_IMPLEMENTATION) && \
+    defined(BOOST_HAS_TRIVIAL_ASSIGN) && defined(BOOST_HAS_TRIVIAL_COPY) && \
+    defined(BOOST_HAS_TRIVIAL_MOVE_ASSIGN) && defined(BOOST_HAS_TRIVIAL_MOVE_CONSTRUCTOR) && \
+    defined(BOOST_HAS_TRIVIAL_DESTRUCTOR) && defined(BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING)
+#   define BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING 1
+#endif
+
+template <typename T>
+struct is_trivially_copyable_class
+  : mpl::bool_<
+        (has_trivial_copy<T>::value   || !is_copy_constructible<T>::value) &&
+        (has_trivial_assign<T>::value || !is_copy_assignable<T>::value) &&
+        (has_trivial_move_constructor<T>::value || !is_constructible<T, T>::value) &&
+        (has_trivial_move_assign<T>::value      || !is_assignable<T, T>::value) &&
+        (is_copy_constructible<T>::value || is_copy_assignable<T>::value ||
+         is_constructible<T, T>::value   || is_assignable<T, T>::value) &&
+        has_trivial_destructor<T>::value
+    > { };
+
+template <typename T>
+struct is_trivially_copyable_impl
+  : mpl::if_c<is_scalar<T>::value
+#ifdef BOOST_FUSION_DETAIL_VOLATILE_SCALAR_IS_NON_TRIVIALLY_COPYABLE
+    , mpl::not_<is_volatile<T> >
+#else
+    , mpl::true_
+#endif
+    , typename mpl::if_c<is_class<T>::value || is_union<T>::value
+      , is_trivially_copyable_class<typename remove_cv<T>::type>
+      , mpl::false_
+      >::type
+    >::type { };
+#endif // <type_traits>
+
+template <typename T>
+struct is_trivially_copyable
+#if defined(BOOST_FUSION_IS_TRIVIALLY_COPYABLE)
+  : mpl::bool_<BOOST_FUSION_IS_TRIVIALLY_COPYABLE(T)>
+#elif !defined(BOOST_NO_CXX11_HDR_TYPE_TRAITS)
+  : std::is_trivially_copyable<T>
+#else
+  : is_trivially_copyable_impl<typename remove_all_extents<T>::type>
+#endif // <type_traits>
+{ };
+
+}}} // namespace boost::fusion::detail
+
+#endif
+

include/boost/fusion/support/detail/propagate_trivialness.hpp

@@ -0,0 +1,40 @@
+/*=============================================================================
+    Copyright (c) 2018 Kohei Takahashi
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef BOOST_FUSION_SUPPORT_DETAIL_PROPAGATE_TRIVIALNESS
+#define BOOST_FUSION_SUPPORT_DETAIL_PROPAGATE_TRIVIALNESS
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/detail/and.hpp>
+#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
+#include <boost/mpl/if.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+
+struct trivial_base { };
+
+struct non_trivial_base
+{
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    BOOST_DEFAULTED_FUNCTION(non_trivial_base(), {})
+
+    BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+    non_trivial_base(non_trivial_base const&) BOOST_NOEXCEPT { }
+};
+
+template <typename... T>
+struct propagate_trivialness
+  : mpl::if_c<and_<is_trivially_copyable<T>...>::value
+      , trivial_base
+      , non_trivial_base
+    >::type
+{ };
+
+}}} // namespace boost::fusion::detail
+
+#endif
+

include/boost/fusion/tuple/tuple.hpp

@@ -56,7 +56,7 @@ namespace boost { namespace fusion
         >
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         tuple(tuple<U...> const& other)
-            : base(vector_detail::each_elem(), other) {}
+            : base(other) {}
 
         template <
             typename ...U
@@ -66,7 +66,7 @@ namespace boost { namespace fusion
         >
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         tuple(tuple<U...>&& other)
-            : base(vector_detail::each_elem(), std::move(other)) {}
+            : base(std::move(other)) {}
 
         template <
             typename ...U
@@ -78,17 +78,17 @@ namespace boost { namespace fusion
         /*BOOST_CONSTEXPR*/ BOOST_FUSION_GPU_ENABLED
         explicit
         tuple(U&&... args)
-            : base(vector_detail::each_elem(), std::forward<U>(args)...) {}
+            : base(std::forward<U>(args)...) {}
 
         template<typename U1, typename U2>
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         tuple(std::pair<U1, U2> const& other)
-            : base(vector_detail::each_elem(), other.first, other.second) {}
+            : base(other.first, other.second) {}
 
         template<typename U1, typename U2>
         BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
         tuple(std::pair<U1, U2>&& other)
-            : base(vector_detail::each_elem(), std::move(other.first), std::move(other.second)) {}
+            : base(std::move(other.first), std::move(other.second)) {}
 
         template<typename U>
         BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED

test/Jamfile

@@ -154,6 +154,8 @@ project
     [ run sequence/tuple_traits.cpp : :
         : <define>BOOST_FUSION_DISABLE_VARIADIC_VECTOR
         : tuple_traits__no_variadic ]
+    [ run sequence/tuple_trivially_copyable.cpp : :
+        : [ requires cxx11_variadic_templates ] ]
     [ run sequence/transform_view.cpp ]
     [ run sequence/vector_comparison.cpp ]
     [ run sequence/vector_construction.cpp ]
@@ -175,6 +177,8 @@ project
     [ run sequence/vector_traits.cpp : :
         : <define>BOOST_FUSION_DISABLE_VARIADIC_VECTOR
         : vector_traits__no_variadic ]
+    [ run sequence/vector_trivially_copyable.cpp : :
+        : [ requires cxx11_variadic_templates ] ]
     [ run sequence/vector_value_at.cpp ]
     [ run sequence/zip_view.cpp ]
     [ run sequence/zip_view2.cpp ]
@@ -268,6 +272,9 @@ project
         : [ requires cxx11_variadic_templates ] ]
     [ compile support/tag_of.cpp ]
     [ compile support/unused.cpp ]
+    [ compile support/is_trivially_copyable.cpp ]
+    [ compile support/propagate_trivialness.cpp
+        : [ requires cxx11_variadic_templates ] ]
 
 #   [ compile-fail xxx.cpp  ]
 

test/sequence/trivially_copyable.hpp

@@ -0,0 +1,76 @@
+/*=============================================================================
+    Copyright (c) 2018 Kohei Takahashi
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef TRIVIALLY_COPYABLE_HPP
+#define TRIVIALLY_COPYABLE_HPP
+
+#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
+
+#include <boost/mpl/assert.hpp>
+#include "../support/trivial.hpp"
+
+using namespace boost::fusion;
+
+BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<> >));
+BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<int> >));
+BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int> >));
+BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int, int> >));
+BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int&> >));
+BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int&> >));
+BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int, int&> >));
+
+BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<> > >));
+BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<int> > >));
+BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<int>, FUSION_SEQUENCE<int, int> > >));
+BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<int>, FUSION_SEQUENCE<int, int>, FUSION_SEQUENCE<int, int, int> > >));
+
+BOOST_FUSION_ASSERT_CWG496((detail::is_trivially_copyable<FUSION_SEQUENCE<int, trivial> >));
+BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, user_provided_copy> >));
+BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, user_provided_move> >));
+BOOST_MPL_ASSERT_NOT((detail::is_trivially_copyable<FUSION_SEQUENCE<int, user_provided_dtor> >));
+
+#ifdef BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/addressof.hpp>
+#include <boost/fusion/sequence/intrinsic/at_c.hpp>
+#include <boost/fusion/sequence/comparison/equal_to.hpp>
+#include <cstring>
+
+int main()
+{
+    typedef FUSION_SEQUENCE<char, double, const int*> seq_t;
+    BOOST_MPL_ASSERT((detail::is_trivially_copyable<seq_t>));
+
+    char* storage = new char[sizeof(seq_t)];
+
+    int i = 42;
+
+    const seq_t* src = new seq_t('\t', 3.14159265359, &i);
+    std::memcpy(static_cast<void*>(storage), src, sizeof(seq_t));
+
+    seq_t* dst = new seq_t;
+    std::memcpy(dst, static_cast<void const*>(storage), sizeof(seq_t));
+
+    BOOST_TEST((*src) == (*dst));
+    BOOST_TEST(boost::fusion::at_c<0>(*src) == '\t');
+    BOOST_TEST(boost::fusion::at_c<1>(*src) == 3.14159265359);
+    BOOST_TEST(boost::fusion::at_c<2>(*src) == &i);
+    BOOST_TEST(*boost::fusion::at_c<2>(*src) == 42);
+    BOOST_TEST(boost::fusion::at_c<0>(*dst) == '\t');
+    BOOST_TEST(boost::fusion::at_c<1>(*dst) == 3.14159265359);
+    BOOST_TEST(boost::fusion::at_c<2>(*dst) == &i);
+    BOOST_TEST(*boost::fusion::at_c<2>(*dst) == 42);
+
+    delete dst;
+    delete src;
+    delete [] storage;
+
+    return boost::report_errors();
+}
+#else
+int main() { }
+#endif
+#endif

test/sequence/tuple_trivially_copyable.cpp

@@ -0,0 +1,17 @@
+/*=============================================================================
+    Copyright (c) 2018 Kohei Takahashi
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/fusion/tuple/tuple_fwd.hpp>
+
+#ifndef BOOST_FUSION_HAS_VARIADIC_TUPLE
+int main() { }
+#else
+
+#include <boost/fusion/tuple/tuple.hpp>
+#define FUSION_SEQUENCE boost::fusion::tuple
+#include "trivially_copyable.hpp"
+#endif
+

test/sequence/vector_trivially_copyable.cpp

@@ -0,0 +1,17 @@
+/*=============================================================================
+    Copyright (c) 2018 Kohei Takahashi
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying 
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#include <boost/fusion/container/vector/detail/config.hpp>
+
+#ifndef BOOST_FUSION_HAS_VARIADIC_VECTOR
+int main() { }
+#else
+
+#include <boost/fusion/container/vector/vector.hpp>
+#define FUSION_SEQUENCE boost::fusion::vector
+#include "trivially_copyable.hpp"
+#endif
+

test/support/is_trivially_copyable.cpp

@@ -0,0 +1,766 @@
+/*=============================================================================
+    Copyright (c) 2018 Kohei Takahashi
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/config.hpp>
+
+#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
+#include <boost/mpl/assert.hpp>
+#include "trivial.hpp"
+
+using namespace boost;
+using namespace boost::fusion::detail;
+
+// disable cv-qialifer on function type warning
+#if defined(BOOST_CLANG)
+#   pragma clang diagnostic ignored "-Wignored-qualifiers"
+#elif defined(BOOST_MSVC)
+#   pragma warning(disable: 4180)
+#endif
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<void>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<void const>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<void volatile>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<void const volatile>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<int>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int const>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int volatile>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int const volatile>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<int*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int const*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int volatile*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int const volatile*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int* const>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int* volatile>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int* const volatile>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile&>));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile&&>));
+#endif
+
+BOOST_MPL_ASSERT((is_trivially_copyable<int[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int const[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int volatile[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int const volatile[]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<int[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int const[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int volatile[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int const volatile[3]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<int[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int const[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int volatile[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int const volatile[][3][4][5]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<int(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int const(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int const volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int(*const)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*volatile)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*const volatile)[]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<int(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int const(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int const volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int(*const)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*volatile)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*const volatile)[3]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<int(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int const(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int const volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<int(*const)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*volatile)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<int(*const volatile)[][3][4][5]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&)[][3][4][5]>));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int volatile(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile(&&)[][3][4][5]>));
+#endif
+
+typedef int function_type();
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type* const>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* volatile>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* const volatile>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile&>));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile&&>));
+#endif
+
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type*[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type* const[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* volatile[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* const volatile[]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type*[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type* const[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* volatile[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* const volatile[3]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type*[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type* const[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* volatile[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type* const volatile[][3][4][5]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*const)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*volatile)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*const volatile)[]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*const)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*volatile)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*const volatile)[3]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const*(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type volatile*(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type const volatile*(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<function_type*(*const)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*volatile)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<function_type*(*const volatile)[][3][4][5]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&)[][3][4][5]>));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type*(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const*(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type volatile*(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&&)[][3][4][5]>));
+#endif
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type const>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type volatile>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type const volatile>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type const[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type volatile[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type const volatile[]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type const[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type volatile[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type const volatile[3]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type const[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type volatile[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type const volatile[][3][4][5]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type const(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type const volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*const)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*volatile)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*const volatile)[]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type const(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type const volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*const)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*volatile)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*const volatile)[3]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type const(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type const volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_type(*const)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*volatile)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_type(*const volatile)[][3][4][5]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&)[][3][4][5]>));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type volatile(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&&)[][3][4][5]>));
+#endif
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type volatile>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type const volatile>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type volatile[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type const volatile[]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type volatile[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type const volatile[3]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type volatile[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type const volatile[][3][4][5]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*const)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*volatile)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*const volatile)[]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*const)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*volatile)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*const volatile)[3]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type(*const)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*volatile)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<member_function_type(*const volatile)[][3][4][5]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&)[][3][4][5]>));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type volatile(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(&&)[][3][4][5]>));
+#endif
+
+
+BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial>));
+BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial const>));
+BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial volatile>));
+BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial const volatile>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial const*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial volatile*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial const volatile*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial* const>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial* volatile>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial* const volatile>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile&>));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile&&>));
+#endif
+
+BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial[]>));
+BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial const[]>));
+BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial volatile[]>));
+BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial const volatile[]>));
+
+BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial[3]>));
+BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial const[3]>));
+BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial volatile[3]>));
+BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial const volatile[3]>));
+
+BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial const[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial volatile[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG2094((is_trivially_copyable<trivial const volatile[][3][4][5]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial const(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial const volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*const)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*volatile)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*const volatile)[]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial const(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial const volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*const)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*volatile)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*const volatile)[3]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial const(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial const volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<trivial(*const)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*volatile)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<trivial(*const volatile)[][3][4][5]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&)[][3][4][5]>));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile(&&)[][3][4][5]>));
+#endif
+
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy volatile*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const volatile*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy* const>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy* volatile>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy* const volatile>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile&>));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile&&>));
+#endif
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile[][3][4][5]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*const)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*volatile)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*const volatile)[]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*const)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*volatile)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*const volatile)[3]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy const volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_copy(*const)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*volatile)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_copy(*const volatile)[][3][4][5]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&)[][3][4][5]>));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy volatile(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_copy const volatile(&&)[][3][4][5]>));
+#endif
+
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move volatile*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const volatile*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move* const>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move* volatile>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move* const volatile>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile&>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile&&>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile[][3][4][5]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*const)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*volatile)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*const volatile)[]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*const)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*volatile)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*const volatile)[3]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move const volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_move(*const)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*volatile)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_move(*const volatile)[][3][4][5]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&)[][3][4][5]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move volatile(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_move const volatile(&&)[][3][4][5]>));
+#endif
+
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor volatile*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const volatile*>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor* const>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor* volatile>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor* const volatile>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile&>));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile&&>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile&&>));
+#endif
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile[][3][4][5]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const volatile(*)[]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*const)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*volatile)[]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*const volatile)[]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const volatile(*)[3]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*const)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*volatile)[3]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*const volatile)[3]>));
+
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor const volatile(*)[][3][4][5]>));
+BOOST_MPL_ASSERT((is_trivially_copyable<user_provided_dtor(*const)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*volatile)[][3][4][5]>));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_trivially_copyable<user_provided_dtor(*const volatile)[][3][4][5]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&)[][3][4][5]>));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&&)[]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&&)[]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&&)[3]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&&)[3]>));
+
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor volatile(&&)[][3][4][5]>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<user_provided_dtor const volatile(&&)[][3][4][5]>));
+#endif

test/support/propagate_trivialness.cpp

@@ -0,0 +1,183 @@
+/*=============================================================================
+    Copyright (c) 2018 Kohei Takahashi
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+
+#include <boost/config.hpp>
+#include <boost/fusion/support/detail/propagate_trivialness.hpp>
+#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+#include <boost/type_traits/is_base_of.hpp>
+#include <boost/type_traits/is_default_constructible.hpp>
+#include "trivial.hpp"
+
+using namespace boost;
+using namespace boost::fusion::detail;
+
+
+BOOST_MPL_ASSERT((is_default_constructible<trivial_base>));
+BOOST_MPL_ASSERT((is_default_constructible<non_trivial_base>));
+
+BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<trivial_base>));
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<non_trivial_base>));
+
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<> >));
+
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int const> >));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<int volatile> >));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<int const volatile> >));
+
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int const*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int volatile*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int const volatile*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int* const> >));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<int* volatile> >));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<int* const volatile> >));
+
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int const&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int volatile&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int const volatile&> >));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int const&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int volatile&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int const volatile&&> >));
+#endif
+
+
+BOOST_FUSION_ASSERT_CWG496((is_base_of<trivial_base, propagate_trivialness<trivial> >));
+BOOST_FUSION_ASSERT_CWG496((is_base_of<trivial_base, propagate_trivialness<trivial const> >));
+BOOST_FUSION_ASSERT_CWG2094((is_base_of<trivial_base, propagate_trivialness<trivial volatile> >));
+BOOST_FUSION_ASSERT_CWG2094((is_base_of<trivial_base, propagate_trivialness<trivial const volatile> >));
+
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial const*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial volatile*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial const volatile*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<trivial* const> >));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<trivial* volatile> >));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<trivial* const volatile> >));
+
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial const&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial volatile&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial const volatile&> >));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial const&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial volatile&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<trivial const volatile&&> >));
+#endif
+
+
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy volatile> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const volatile> >));
+
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy const*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy volatile*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy const volatile*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_copy* const> >));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_copy* volatile> >));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_copy* const volatile> >));
+
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy volatile&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const volatile&> >));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy volatile&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_copy const volatile&&> >));
+#endif
+
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move volatile> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const volatile> >));
+
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move const*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move volatile*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move const volatile*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_move* const> >));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_move* volatile> >));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_move* const volatile> >));
+
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move volatile&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const volatile&> >));
+
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move volatile&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_move const volatile&&> >));
+#endif
+
+
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor volatile> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const volatile> >));
+
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor const*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor volatile*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor const volatile*> >));
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor* const> >));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor* volatile> >));
+BOOST_FUSION_ASSERT_CWG496_SCALAR((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor* const volatile> >));
+
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor volatile&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const volatile&> >));
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor volatile&&> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provided_dtor const volatile&&> >));
+#endif
+
+
+BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<int, float, void*> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int, float&, void*> >));
+BOOST_FUSION_ASSERT_CWG496((is_base_of<trivial_base, propagate_trivialness<int, float, trivial> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int, float, user_provided_copy> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int, float, user_provided_move> >));
+BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int, float, user_provided_dtor> >));
+
+
+struct S1 : private propagate_trivialness<int, float, void*> { };
+BOOST_MPL_ASSERT((is_trivially_copyable<S1>));
+
+struct S2 : private propagate_trivialness<int, float&, void*> { };
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<S2>));
+
+struct S3 : private propagate_trivialness<int, float, trivial> { };
+BOOST_FUSION_ASSERT_CWG496((is_trivially_copyable<S3>));
+
+struct S4 : private propagate_trivialness<int, float, user_provided_copy> { };
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<S4>));
+
+struct S5 : private propagate_trivialness<int, float, user_provided_move> { };
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<S5>));
+
+struct S6 : private propagate_trivialness<int, float, user_provided_dtor> { };
+BOOST_MPL_ASSERT_NOT((is_trivially_copyable<S6>));

test/support/trivial.hpp

@@ -0,0 +1,66 @@
+/*=============================================================================
+    Copyright (c) 2018 Kohei Takahashi
+
+    Distributed under the Boost Software License, Version 1.0. (See accompanying
+    file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+==============================================================================*/
+#ifndef TRIVIAL_HPP
+#define TRIVIAL_HPP
+
+#include <boost/fusion/support/detail/is_trivially_copyable.hpp>
+#include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
+
+#if defined(BOOST_FUSION_DETAIL_VOLATILE_SCALAR_IS_NON_TRIVIALLY_COPYABLE)
+#   define BOOST_FUSION_ASSERT_CWG496_SCALAR BOOST_MPL_ASSERT_NOT
+#elif defined(BOOST_FUSION_IS_TRIVIALLY_COPYABLE)
+#   define BOOST_FUSION_ASSERT_CWG496_SCALAR_I(...) BOOST_STATIC_ASSERT((__VA_ARGS__::value) == BOOST_FUSION_IS_TRIVIALLY_COPYABLE(int volatile))
+#   define BOOST_FUSION_ASSERT_CWG496_SCALAR(pred) BOOST_FUSION_ASSERT_CWG496_SCALAR_I pred
+#else
+#   define BOOST_FUSION_ASSERT_CWG496_SCALAR BOOST_MPL_ASSERT
+#endif
+
+#if defined(BOOST_FUSION_IS_TRIVIALLY_COPYABLE)
+#   define BOOST_FUSION_ASSERT_CWG496 BOOST_MPL_ASSERT
+#   define BOOST_FUSION_ASSERT_CWG2094_I(...) BOOST_STATIC_ASSERT((__VA_ARGS__::value) == BOOST_FUSION_IS_TRIVIALLY_COPYABLE(trivial volatile))
+#   define BOOST_FUSION_ASSERT_CWG2094(pred) BOOST_FUSION_ASSERT_CWG2094_I pred
+#elif defined(BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING)
+#   define BOOST_FUSION_ASSERT_CWG496 BOOST_MPL_ASSERT
+#   define BOOST_FUSION_ASSERT_CWG2094 BOOST_MPL_ASSERT
+#else
+#   define BOOST_FUSION_ASSERT_CWG496(pred) struct skip_assertion
+#   define BOOST_FUSION_ASSERT_CWG2094(pred) struct skip_assertion
+#endif
+
+
+struct S;
+typedef int (S::*member_type);
+typedef int (S::*member_function_type)();
+
+
+struct trivial { };
+
+
+struct user_provided_copy
+{
+    user_provided_copy(user_provided_copy const&);
+    user_provided_copy& operator=(user_provided_copy const&);
+};
+
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+struct user_provided_move
+{
+    user_provided_move(user_provided_move&&);
+    user_provided_move& operator=(user_provided_move&&);
+};
+#endif
+
+
+struct user_provided_dtor
+{
+    ~user_provided_dtor();
+};
+
+#endif
+