Remove redundant noexcept specifier

to compile with gcc 4.6
Fixed wrong type of special functions
2018-05-13 16:56:46 +09:00 · 2018-05-13 16:01:57 +09:00 · 2018-05-10 02:08:24 +09:00 · 2018-05-10 00:55:07 +09:00 · 2018-05-09 12:39:06 +09:00 · 2018-05-09 03:09:24 +09:00
54 changed files with 1827 additions and 382 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -1,5 +1,5 @@
 # Copyright 2016, 2017 Peter Dimov
-# Copyright 2017 Kohei Takahashi
+# Copyright 2017-2018 Kohei Takahashi
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)

@ -11,11 +11,6 @@ os:
  - linux
  - osx

-branches:
-  only:
-    - master
-    - develop
-
 env:
  matrix:
    - BOGUS_JOB=true
@ -30,6 +25,20 @@ matrix:
    - os: linux
      env: TOOLSET=gcc CXXSTD=03,11,1y

+    - os: linux
+      env: TOOLSET=gcc-4.4 CXXSTD=98,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.4
+
+    - os: linux
+      env: TOOLSET=gcc-4.6 CXXSTD=03,0x
+      addons:
+        apt:
+          packages:
+            - g++-4.6
+
    - os: linux
      env: TOOLSET=gcc-4.7 CXXSTD=03,11
      addons:
@ -153,6 +162,17 @@ matrix:
            - ubuntu-toolchain-r-test
            - llvm-toolchain-trusty-4.0

+    - os: linux
+      env: TOOLSET=clang-5.0 CXXSTD=03,11,14,1z,2a
+      addons:
+        apt:
+          packages:
+            - clang-5.0
+            - libstdc++-4.9-dev
+          sources:
+            - ubuntu-toolchain-r-test
+            - llvm-toolchain-trusty-5.0
+
    - os: osx
      env: TOOLSET=clang COMPILER=clang++ CXXSTD=03,11,14,1z

@ -167,6 +187,7 @@ install:
  - git submodule init libs/bind
  - git submodule init libs/concept_check
  - git submodule init libs/config
+  - git submodule init libs/container_hash
  - git submodule init libs/conversion
  - git submodule init libs/core
  - git submodule init libs/detail
@ -201,4 +222,4 @@ install:
  - ./b2 headers

 script:
-  - ./b2 libs/fusion/test toolset=$TOOLSET cxxstd=$CXXSTD define=RUNNING_ON_TRAVIS=1
+  - ./b2 -j`(nproc || sysctl -n hw.ncpu) 2> /dev/null` libs/fusion/test toolset=$TOOLSET cxxstd=$CXXSTD
--- a/appveyor.yml
+++ b/appveyor.yml
@ -1,5 +1,5 @@
 # Copyright 2016, 2017 Peter Dimov
-# Copyright 2017 Kohei Takahashi
+# Copyright 2017-2018 Kohei Takahashi
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)

@ -7,25 +7,35 @@ version: 1.0.{build}-{branch}

 shallow_clone: true

-branches:
-  only:
-    - master
-    - develop
-
 environment:
  matrix:
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      TOOLSET: msvc-9.0
+      CXXSTD: latest # fake
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      TOOLSET: msvc-10.0
+      CXXSTD: latest # fake
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      TOOLSET: msvc-11.0
+      CXXSTD: latest # fake
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2013
      TOOLSET: msvc-12.0
+      CXXSTD: latest # fake
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      TOOLSET: msvc-14.0
+      CXXSTD: 14
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
+      TOOLSET: msvc-14.0
+      CXXSTD: latest
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      TOOLSET: msvc-14.1
+      CXXSTD: 14
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      CXXSTD: 17
+    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
+      TOOLSET: msvc-14.1
+      CXXSTD: latest

 install:
  - set BOOST_BRANCH=develop
@ -39,6 +49,7 @@ install:
  - git submodule init libs/bind
  - git submodule init libs/concept_check
  - git submodule init libs/config
+  - git submodule init libs/container_hash
  - git submodule init libs/conversion
  - git submodule init libs/core
  - git submodule init libs/detail
@ -71,4 +82,4 @@ install:
 build: off

 test_script:
-  - b2 libs/fusion/test toolset=%TOOLSET% define=RUNNING_ON_APPVEYOR=1
+  - b2 -j%NUMBER_OF_PROCESSORS% --hash libs/fusion/test toolset=%TOOLSET% cxxstd=%CXXSTD%
--- a/doc/fusion.qbk
+++ b/doc/fusion.qbk
@ -2,6 +2,7 @@
    Copyright (C) 2001-2011 Joel de Guzman
    Copyright (C) 2006 Dan Marsden
    Copyright (C) 2010 Christopher Schmidt
+    Copyright (C) 2018 Kohei Takahashi

    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@ -20,39 +21,37 @@
    ]
 ]

-[def __spirit__                 [@http://spirit.sourceforge.net Spirit]]
-[def __phoenix__                [@http://www.boost.org/libs/phoenix/index.html Phoenix]]
-[def __mpl__                    [@http://www.boost.org/libs/mpl/index.html MPL]]
+[def __spirit__                 [@http://boost-spirit.com/home/ Spirit]]
+[def __phoenix__                [@http://www.boost.org/libs/phoenix Phoenix]]
+[def __mpl__                    [@http://www.boost.org/libs/mpl MPL]]
 [def __stl__                    [@http://en.wikipedia.org/wiki/Standard_Template_Library STL]]
-[def __tuple__                  [@http://www.boost.org/libs/tuple/doc/tuple_users_guide.html Boost.Tuple]]
+[def __tuple__                  [@http://www.boost.org/libs/tuple Boost.Tuple]]
 [def __tr1__tuple__             [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1403.pdf TR1 Tuple]]
 [def __boost_tools__            [@http://www.boost.org/tools/index.html Boost Tools]]
-[def __spirit_list__            [@https://lists.sourceforge.net/lists/listinfo/spirit-general Spirit Mailing List]]
-[def __spirit_general__         [@news://news.gmane.org/gmane.comp.spirit.general Spirit General NNTP news portal]]
-[def __gmane__                  [@http://www.gmane.org Gmane]]
-[def __mlist_archive__          [@http://news.gmane.org/gmane.comp.parsers.spirit.general]]
+[def __spirit_list__            [@https://sourceforge.net/projects/spirit/lists/spirit-general Spirit Mailing List]]
+[def __list_archive__           [@https://sourceforge.net/p/spirit/mailman/spirit-general/ archive]]
 [def __jaakko_jarvi__           [@http://www.boost.org/people/jaakko_jarvi.htm Jaakko Jarvi]]
 [def __david_abrahams__         [@http://www.boost.org/people/dave_abrahams.htm David Abrahams]]
 [def __the_forwarding_problem__ [@http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm The Forwarding Problem]]

-[def __boost_any__              [@http://www.boost.org/doc/html/any.html Boost.Any]]
+[def __boost_any__              [@http://www.boost.org/libs/any Boost.Any Library]]
 [def __new_iterator_concepts__  [@http://www.boost.org/libs/iterator/doc/new-iter-concepts.html New Iterator Concepts]]
-[def __boost_array_library__    [@http://www.boost.org/doc/html/array.html Boost.Array Library]]
-[def __boost_variant_library__  [@http://www.boost.org/doc/html/variant.html Boost.Variant Library]]
-[def __boost_tuple_library__    [@http://www.boost.org/libs/tuple/doc/tuple_users_guide.html Boost.Tuple Library]]
-[def __boost_ref__              [@http://www.boost.org/doc/html/ref.html Boost.Ref]]
-[def __boost_ref_call__         [@http://www.boost.org/doc/html/ref.html `ref`]]
-[def __boost_result_of__        [@http://www.boost.org/libs/utility/utility.htm#result_of Boost.ResultOf]]
+[def __boost_array_library__    [@http://www.boost.org/libs/array Boost.Array Library]]
+[def __boost_variant_library__  [@http://www.boost.org/libs/variant Boost.Variant Library]]
+[def __boost_tuple_library__    [@http://www.boost.org/libs/tuple Boost.Tuple Library]]
+[def __boost_ref__              [@http://www.boost.org/libs/core/ref.html Ref utility]]
+[def __boost_ref_call__         [@http://www.boost.org/libs/core/ref.html `ref`]]
+[def __boost_result_of__        [@http://www.boost.org/libs/utility/utility.htm#result_of ResultOf utility]]
 [def __boost_result_of_call__   [@http://www.boost.org/libs/utility/utility.htm#result_of `boost::result_of`]]
-[def __boost_enable_if__        [@http://www.boost.org/libs/utility/enable_if.html Boost.EnableIf utility]]
-[def __boost_shared_ptr_call__  [@http://www.boost.org/libs/smart_ptr/shared_ptr.htm `boost::shared_ptr`]]
-[def __boost_func_forward__     [@http://www.boost.org/libs/functional/forward/doc/html/index.html Boost.Functional/Forward]]
-[def __boost_func_factory__     [@http://www.boost.org/libs/functional/factory/doc/html/index.html Boost.Functional/Factory]]
-[def __boost_func_hash__        [@http://www.boost.org/doc/html/hash.html Boost.Functional/Hash]]
-[def __std_pair_doc__           [@http://www.sgi.com/tech/stl/pair.html `std::pair`]]
+[def __boost_enable_if__        [@http://www.boost.org/libs/core/doc/html/core/enable_if.html EnableIf utility]]
+[def __boost_shared_ptr_call__  [@http://www.boost.org/libs/smart_ptr#shared_ptr `boost::shared_ptr`]]
+[def __boost_func_forward__     [@http://www.boost.org/libs/functional/forward Boost.Functional/Forward Library]]
+[def __boost_func_factory__     [@http://www.boost.org/libs/functional/factory Boost.Functional/Factory Library]]
+[def __boost_func_hash__        [@http://www.boost.org/doc/html/hash.html Boost.ContainerHash Library]]
+[def __std_pair_doc__           [@http://en.cppreference.com/w/cpp/utility/pair `std::pair`]]
 [def __std_tuple_doc__          [@http://en.cppreference.com/w/cpp/utility/tuple `std::tuple`]]
-[def __std_plus_doc__           [@http://www.sgi.com/tech/stl/plus.html `std::plus`]]
-[def __std_minus_doc__          [@http://www.sgi.com/tech/stl/minus.html `std::minus`]]
+[def __std_plus_doc__           [@http://en.cppreference.com/w/cpp/utility/functional/plus `std::plus`]]
+[def __std_minus_doc__          [@http://en.cppreference.com/w/cpp/utility/functional/minus `std::minus`]]

 [def __mpl_integral_constant__  [@http://www.boost.org/libs/mpl/doc/refmanual/integral-constant.html MPL Integral Constant]]
 [def __mpl_boolean_constant__   [@http://www.boost.org/libs/mpl/doc/refmanual/integral-constant.html MPL Boolean Constant]]
--- a/doc/preface.qbk
+++ b/doc/preface.qbk
@ -61,11 +61,8 @@ tool. QuickBook can be found in the __boost_tools__.
 [heading Support]

 Please direct all questions to Spirit's mailing list. You can subscribe to the
-__spirit_list__. The mailing list has a searchable archive. A search link to
-this archive is provided in __spirit__'s home page. You may also read and post
-messages to the mailing list through __spirit_general__ (thanks to __gmane__).
-The news group mirrors the mailing list. Here is a link to the archives:
-__mlist_archive__.
+__spirit_list__. The mailing list has a searchable archive. Here is a link to
+the archives: __list_archive__.

 [endsect]

--- a/doc/references.qbk
+++ b/doc/references.qbk
@ -1,6 +1,7 @@
 [/==============================================================================
    Copyright (C) 2001-2011 Joel de Guzman
    Copyright (C) 2006 Dan Marsden
+    Copyright (C) 2018 Kohei Takahashi

    Use, modification and distribution is subject to the Boost Software
    License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@ -8,20 +9,20 @@
 ===============================================================================/]
 [section References]

-# [@http://boost.org/libs/iterator/doc/new-iter-concepts.html New Iterator Concepts],
+# [@http://www.boost.org/libs/iterator/doc/new-iter-concepts.html New Iterator Concepts],
  David Abrahams, Jeremy Siek, Thomas Witt, 2004-11-01.
-# [@http://boost.org/libs/tuple/doc/tuple_users_guide.html The Boost Tuple Library],
+# [@http://www.boost.org/libs/tuple The Boost Tuple Library],
  Jaakko Jarvi, 2001.
-# [@http://www.boost.org/libs/spirit/ Spirit Parser Library],
+# [@http://www.boost.org/libs/spirit Spirit Parser Library],
  Joel de Guzman, 2001-2006.
-# [@http://www.boost.org/libs/mpl/ The Boost MPL Library],
+# [@http://www.boost.org/libs/mpl The Boost MPL Library],
  Aleksey Gurtovoy and David Abrahams, 2002-2004.
-# [@http://www.boost.org/doc/html/array.html Boost Array],
+# [@http://www.boost.org/libs/array The Boost Array Library],
  Nicolai Josuttis, 2002-2004.
-# [@http://www.sgi.com/tech/stl/ Standard Template Library Programmer's Guide],
-  Hewlett-Packard Company, 1994.
-# [@http://www.boost.org/doc/html/ref.html Boost.Ref],
+# [@http://www.boost.org/libs/core/ref.html Boost.Core / Ref utility],
  Jaakko Jarvi, Peter Dimov, Douglas Gregor, Dave Abrahams, 1999-2002.
+# [@http://www.boost.org/libs/hana The Boost Hana Library],
+  Louis Dionne, 2017.

 [endsect]

--- a/include/boost/fusion/container/deque/detail/cpp03/as_deque.hpp
+++ b/include/boost/fusion/container/deque/detail/cpp03/as_deque.hpp
@ -26,7 +26,13 @@ namespace boost { namespace fusion { namespace detail
 BOOST_FUSION_BARRIER_BEGIN

    template <int size>
-    struct as_deque;
+    struct as_deque
+    {
+        BOOST_STATIC_ASSERT_MSG(
+            size <= FUSION_MAX_DEQUE_SIZE
+          , "FUSION_MAX_DEQUE_SIZE limit is too low"
+        );
+    };

    template <>
    struct as_deque<0>
--- a/include/boost/fusion/container/deque/detail/keyed_element.hpp
+++ b/include/boost/fusion/container/deque/detail/keyed_element.hpp
@ -13,6 +13,11 @@
 #include <boost/fusion/iterator/deref.hpp>
 #include <boost/fusion/iterator/next.hpp>

+#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)
+#include <boost/core/enable_if.hpp>
+#include <boost/type_traits/is_same.hpp>
+#endif
+
 namespace boost { namespace fusion
 {
    struct fusion_sequence_tag;
@ -114,8 +119,13 @@ namespace boost { namespace fusion { namespace detail
        {}

 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
+#if BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)
+        template <typename Value_, typename = typename enable_if<is_same<Value_, Value> >::type>
+#else
+        typedef Value Value_;
+#endif
        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        keyed_element(Value&& value, Rest&& rest)
+        keyed_element(Value_&& value, Rest&& rest)
            : Rest(std::move(rest))
            , value_(BOOST_FUSION_FWD_ELEM(Value, value))
        {}
--- a/include/boost/fusion/container/list/cons.hpp
+++ b/include/boost/fusion/container/list/cons.hpp
@ -70,6 +70,10 @@ namespace boost { namespace fusion
        cons(cons<Car2, Cdr2> const& rhs)
            : car(rhs.car), cdr(rhs.cdr) {}

+#if BOOST_WORKAROUND(BOOST_GCC, / 100 == 406) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+        // Workaround for `array used as initializer` compile error on gcc 4.6 w/ c++0x.
+        template <typename = void>
+#endif
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
        cons(cons const& rhs)
            : car(rhs.car), cdr(rhs.cdr) {}
--- a/include/boost/fusion/container/map/detail/cpp03/as_map.hpp
+++ b/include/boost/fusion/container/map/detail/cpp03/as_map.hpp
@ -25,7 +25,13 @@ namespace boost { namespace fusion { namespace detail
 BOOST_FUSION_BARRIER_BEGIN

    template <int size, bool is_assoc>
-    struct as_map;
+    struct as_map
+    {
+        BOOST_STATIC_ASSERT_MSG(
+            size <= FUSION_MAX_MAP_SIZE
+          , "FUSION_MAX_MAP_SIZE limit is too low"
+        );
+    };

    template <bool is_assoc>
    struct as_map<0, is_assoc>
--- a/include/boost/fusion/container/map/detail/map_impl.hpp
+++ b/include/boost/fusion/container/map/detail/map_impl.hpp
@ -125,11 +125,7 @@ namespace boost { namespace fusion { namespace detail
        }

        BOOST_FUSION_GPU_ENABLED
-        value_type get_val(mpl::identity<key_type>);
-        BOOST_FUSION_GPU_ENABLED
-        pair_type get_val(mpl::int_<index>);
-        BOOST_FUSION_GPU_ENABLED
-        value_type get_val(mpl::identity<key_type>) const;
+        mpl::identity<value_type> get_val(mpl::identity<key_type>) const;
        BOOST_FUSION_GPU_ENABLED
        pair_type get_val(mpl::int_<index>) const;

--- a/include/boost/fusion/container/map/detail/value_at_key_impl.hpp
+++ b/include/boost/fusion/container/map/detail/value_at_key_impl.hpp
@ -1,5 +1,6 @@
 /*=============================================================================
    Copyright (c) 2001-2013 Joel de Guzman
+    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)
@ -8,10 +9,6 @@
 #define BOOST_FUSION_MAP_DETAIL_VALUE_AT_KEY_IMPL_02042013_0821

 #include <boost/fusion/support/config.hpp>
-#include <boost/fusion/support/detail/access.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/mpl/at.hpp>
-#include <boost/mpl/identity.hpp>
 #include <boost/utility/declval.hpp>

 namespace boost { namespace fusion
@ -29,9 +26,9 @@ namespace boost { namespace fusion
            template <typename Sequence, typename Key>
            struct apply
            {
-                typedef
-                    decltype(boost::declval<Sequence>().get_val(mpl::identity<Key>()))
-                type;
+                typedef typename BOOST_FUSION_IDENTIFIED_TYPE((
+                    boost::declval<Sequence>().get_val(mpl::identity<Key>())
+                )) type;
            };
        };
    }
--- a/include/boost/fusion/container/map/map.hpp
+++ b/include/boost/fusion/container/map/map.hpp
@ -67,24 +67,21 @@ namespace boost { namespace fusion
          : base_type(std::forward<map>(seq))
        {}

-        template <typename Sequence>
+        template <typename Sequence, typename = typename enable_if<traits::is_sequence<Sequence>>::type>
        BOOST_FUSION_GPU_ENABLED
-        map(Sequence const& seq
-          , typename enable_if<traits::is_sequence<Sequence>, detail::enabler_>::type = detail::enabler)
+        map(Sequence const& seq)
          : base_type(begin(seq), detail::map_impl_from_iterator())
        {}

-        template <typename Sequence>
+        template <typename Sequence, typename = typename enable_if<traits::is_sequence<Sequence>>::type>
        BOOST_FUSION_GPU_ENABLED
-        map(Sequence& seq
-          , typename enable_if<traits::is_sequence<Sequence>, detail::enabler_>::type = detail::enabler)
+        map(Sequence& seq)
          : base_type(begin(seq), detail::map_impl_from_iterator())
        {}

-        template <typename Sequence>
+        template <typename Sequence, typename = typename enable_if<traits::is_sequence<Sequence>>::type>
        BOOST_FUSION_GPU_ENABLED
-        map(Sequence&& seq
-          , typename enable_if<traits::is_sequence<Sequence>, detail::enabler_>::type = detail::enabler)
+        map(Sequence&& seq)
          : base_type(begin(seq), detail::map_impl_from_iterator())
        {}

--- a/include/boost/fusion/container/set/detail/cpp03/as_set.hpp
+++ b/include/boost/fusion/container/set/detail/cpp03/as_set.hpp
@ -25,7 +25,13 @@ namespace boost { namespace fusion { namespace detail
 BOOST_FUSION_BARRIER_BEGIN

    template <int size>
-    struct as_set;
+    struct as_set
+    {
+        BOOST_STATIC_ASSERT_MSG(
+            size <= FUSION_MAX_SET_SIZE
+          , "FUSION_MAX_SET_SIZE limit is too low"
+        );
+    };

    template <>
    struct as_set<0>
--- a/include/boost/fusion/container/vector/detail/cpp03/as_vector.hpp
+++ b/include/boost/fusion/container/vector/detail/cpp03/as_vector.hpp
@ -25,7 +25,13 @@ namespace boost { namespace fusion { namespace detail
 BOOST_FUSION_BARRIER_BEGIN

    template <int size>
-    struct as_vector;
+    struct as_vector
+    {
+        BOOST_STATIC_ASSERT_MSG(
+            size <= FUSION_MAX_VECTOR_SIZE
+          , "FUSION_MAX_VECTOR_SIZE limit is too low"
+        );
+    };

    template <>
    struct as_vector<0>
--- a/include/boost/fusion/container/vector/detail/value_at_impl.hpp
+++ b/include/boost/fusion/container/vector/detail/value_at_impl.hpp
@ -1,5 +1,5 @@
 /*=============================================================================
-    Copyright (c) 2014 Kohei Takahashi
+    Copyright (c) 2014,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)
@ -7,7 +7,6 @@
 #ifndef FUSION_VALUE_AT_IMPL_16122014_1641
 #define FUSION_VALUE_AT_IMPL_16122014_1641

-#include <boost/config.hpp>
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/container/vector/detail/config.hpp>

@ -23,6 +22,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 #include <boost/fusion/container/vector/vector_fwd.hpp>
 #include <boost/type_traits/declval.hpp>
+#include <boost/mpl/identity.hpp>

 namespace boost { namespace fusion
 {
@ -35,7 +35,7 @@ namespace boost { namespace fusion

        template <std::size_t N, typename U>
        static inline BOOST_FUSION_GPU_ENABLED
-        U value_at_impl(store<N, U> const volatile*);
+        mpl::identity<U> value_at_impl(store<N, U> const volatile*);
    }

    namespace extension
@ -49,9 +49,9 @@ namespace boost { namespace fusion
            template <typename Sequence, typename N>
            struct apply
            {
-                typedef
-                    decltype(vector_detail::value_at_impl<N::value>(boost::declval<Sequence*>()))
-                type;
+                typedef typename BOOST_FUSION_IDENTIFIED_TYPE((
+                    vector_detail::value_at_impl<N::value>(boost::declval<Sequence*>())
+                )) type;
            };
        };
    }
--- a/include/boost/fusion/container/vector/vector.hpp
+++ b/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))...
            {}

@ -247,14 +221,14 @@ namespace boost { namespace fusion

            template <typename J>
            BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            auto at_impl(J) -> decltype(at_detail<J::value>(this))
+            auto at_impl(J) -> decltype(at_detail<J::value>(&std::declval<vector_data&>()))
            {
                return at_detail<J::value>(this);
            }

            template <typename J>
            BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-            auto at_impl(J) const -> decltype(at_detail<J::value>(this))
+            auto at_impl(J) const -> decltype(at_detail<J::value>(&std::declval<vector_data const&>()))
            {
                return at_detail<J::value>(this);
            }
@ -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>
--- a/include/boost/fusion/support/category_of.hpp
+++ b/include/boost/fusion/support/category_of.hpp
@ -8,7 +8,6 @@
 #define FUSION_CATEGORY_OF_07202005_0308

 #include <boost/fusion/support/config.hpp>
-#include <boost/fusion/support/detail/category_of.hpp>
 #include <boost/fusion/support/tag_of.hpp>
 #include <boost/type_traits/is_base_of.hpp>

@ -44,7 +43,10 @@ namespace boost { namespace fusion
        struct category_of_impl
        {
            template<typename T>
-            struct apply : detail::fusion_category_of<T> {};
+            struct apply
+            {
+                typedef typename T::category type;
+            };
        };

        template <>
--- a/include/boost/fusion/support/config.hpp
+++ b/include/boost/fusion/support/config.hpp
@ -1,6 +1,6 @@
 /*=============================================================================
    Copyright (c) 2014 Eric Niebler
-    Copyright (c) 2014 Kohei Takahashi
+    Copyright (c) 2014,2015,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)
@ -96,4 +96,31 @@ namespace std
 #define BOOST_FUSION_CONSTEXPR_THIS BOOST_CONSTEXPR
 #endif

+
+// Workaround for compiler which doesn't compile decltype(expr)::type.
+// It expects decltype(expr) deduced as mpl::identity<T>.
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1913)) || BOOST_WORKAROUND(BOOST_GCC, < 40700)
+#   include <boost/mpl/identity.hpp>
+#   define BOOST_FUSION_IDENTIFIED_TYPE(parenthesized_expr) \
+        boost::mpl::identity<decltype parenthesized_expr>::type::type
+#else
+#   define BOOST_FUSION_IDENTIFIED_TYPE(parenthesized_expr) \
+        decltype parenthesized_expr ::type
+#endif
+
+
+// Workaround for GCC 4.6 that rejects defaulted function with noexcept.
+#if BOOST_WORKAROUND(BOOST_GCC, / 100 == 406)
+#   define BOOST_FUSION_NOEXCEPT_ON_DEFAULTED
+#else
+#   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
--- a/include/boost/fusion/support/detail/and.hpp
+++ b/include/boost/fusion/support/detail/and.hpp
@ -1,5 +1,6 @@
 /*=============================================================================
    Copyright (c) 2016 Lee Clagett
+    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)
@ -8,6 +9,7 @@
 #define FUSION_AND_07152016_1625

 #include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
 #include <boost/type_traits/integral_constant.hpp>

 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@ -15,6 +17,8 @@
 #endif

 namespace boost { namespace fusion { namespace detail {
+#if defined(BOOST_NO_CXX17_FOLD_EXPRESSIONS) \
+ || BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1913))
    template<typename ...Cond>
    struct and_impl : false_type {};

@ -34,6 +38,10 @@ namespace boost { namespace fusion { namespace detail {
         recursive. */
    template<typename ...Cond>
    struct and_ : and_impl1<Cond::value...> {};
+#else
+    template <typename ...Cond>
+    struct and_ : integral_constant<bool, ((bool)Cond::value && ...)> {};
+#endif
 }}}

 #endif // FUSION_AND_07152016_1625
--- a/include/boost/fusion/support/detail/category_of.hpp
+++ b/include/boost/fusion/support/detail/category_of.hpp
@ -1,19 +0,0 @@
-/*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
-
-    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)
-==============================================================================*/
-#if !defined(FUSION_CATEGORY_OF_07212005_1025)
-#define FUSION_CATEGORY_OF_07212005_1025
-
-namespace boost { namespace fusion { namespace detail
-{
-    template <typename T>
-    struct fusion_category_of
-    {
-        typedef typename T::category type;
-    };
-}}}
-
-#endif
--- a/include/boost/fusion/support/detail/is_mpl_sequence.hpp
+++ b/include/boost/fusion/support/detail/is_mpl_sequence.hpp
@ -9,18 +9,17 @@
 #define FUSION_DETAIL_IS_MPL_SEQUENCE_29122006_1105

 #include <boost/fusion/support/config.hpp>
-#include <boost/fusion/support/sequence_base.hpp>
+#include <boost/fusion/support/detail/is_native_fusion_sequence.hpp>
 #include <boost/mpl/is_sequence.hpp>
 #include <boost/mpl/and.hpp>
 #include <boost/mpl/not.hpp>
-#include <boost/type_traits/is_convertible.hpp>

 namespace boost { namespace fusion { namespace detail
 {
    template <typename T>
    struct is_mpl_sequence
        : mpl::and_<
-            mpl::not_<is_convertible<T, from_sequence_convertible_type> >
+            mpl::not_<is_native_fusion_sequence<T> >
          , mpl::is_sequence<T> >
    {};
 }}}
--- a/include/boost/fusion/support/detail/is_native_fusion_sequence.hpp
+++ b/include/boost/fusion/support/detail/is_native_fusion_sequence.hpp
@ -0,0 +1,27 @@
+/*=============================================================================
+    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_IS_NATIVE_FUSION_SEQUENCE
+#define BOOST_FUSION_IS_NATIVE_FUSION_SEQUENCE
+
+#include <boost/fusion/support/config.hpp>
+#include <boost/fusion/support/sequence_base.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/type_traits/is_complete.hpp>
+#include <boost/type_traits/is_convertible.hpp>
+
+namespace boost { namespace fusion { namespace detail
+{
+    template <typename Sequence>
+    struct is_native_fusion_sequence
+      : mpl::and_<
+          is_complete<Sequence>
+        , is_convertible<Sequence, detail::from_sequence_convertible_type>
+      >
+    {};
+}}}
+
+#endif
--- a/include/boost/fusion/support/detail/is_trivially_copyable.hpp
+++ b/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
+
--- a/include/boost/fusion/support/detail/propagate_trivialness.hpp
+++ b/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
+
--- a/include/boost/fusion/support/is_sequence.hpp
+++ b/include/boost/fusion/support/is_sequence.hpp
@ -10,11 +10,10 @@
 #include <boost/fusion/support/config.hpp>
 #include <boost/fusion/support/sequence_base.hpp>
 #include <boost/fusion/support/tag_of.hpp>
-#include <boost/mpl/is_sequence.hpp>
-#include <boost/mpl/or.hpp>
+#include <boost/fusion/support/detail/is_native_fusion_sequence.hpp>
 #include <boost/mpl/bool.hpp>
+#include <boost/mpl/is_sequence.hpp>
 #include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/is_same.hpp>

 namespace boost { namespace fusion
 {
@ -67,10 +66,7 @@ namespace boost { namespace fusion
            >
        {};

-        template <typename Sequence, typename Enable = void>
-        struct is_native_fusion_sequence
-          : is_convertible<Sequence, fusion::detail::from_sequence_convertible_type>
-        {};
+        using detail::is_native_fusion_sequence;
    }
 }}

--- a/include/boost/fusion/support/is_view.hpp
+++ b/include/boost/fusion/support/is_view.hpp
@ -9,7 +9,6 @@

 #include <boost/fusion/support/config.hpp>
 #include <boost/mpl/bool.hpp>
-#include <boost/fusion/support/detail/is_view.hpp>
 #include <boost/fusion/support/tag_of.hpp>

 namespace boost { namespace fusion
@ -28,8 +27,9 @@ namespace boost { namespace fusion
        {
            template <typename T>
            struct apply
-                : detail::fusion_is_view<T>
-            {};
+            {
+                typedef typename T::is_view type;
+            };
        };

        template <>
--- a/include/boost/fusion/support/unused.hpp
+++ b/include/boost/fusion/support/unused.hpp
@ -1,5 +1,6 @@
 /*=============================================================================
    Copyright (c) 2001-2011 Joel de Guzman
+    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)
@ -10,7 +11,6 @@
 #include <boost/fusion/support/config.hpp>
 #include <iosfwd>

-#include <boost/config.hpp>
 #if defined(BOOST_MSVC)
 # pragma warning(push)
 # pragma warning(disable: 4522) // multiple assignment operators specified warning
@ -23,9 +23,16 @@ namespace boost { namespace fusion
    struct unused_type
    {
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        unused_type() BOOST_NOEXCEPT
+        BOOST_DEFAULTED_FUNCTION(
+        unused_type() BOOST_FUSION_NOEXCEPT_ON_DEFAULTED,
        {
-        }
+        })
+
+        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
+        BOOST_DEFAULTED_FUNCTION(
+        unused_type(unused_type const&) BOOST_FUSION_NOEXCEPT_ON_DEFAULTED,
+        {
+        })

        template <typename T>
        BOOST_CONSTEXPR BOOST_FUSION_GPU_ENABLED
@ -33,35 +40,12 @@ namespace boost { namespace fusion
        {
        }

-        template <typename T>
-        BOOST_FUSION_CONSTEXPR_THIS BOOST_FUSION_GPU_ENABLED
-        unused_type const&
-        operator=(T const&) const BOOST_NOEXCEPT
-        {
-            return *this;
-        }
-
-        template <typename T>
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        unused_type&
-        operator=(T const&) BOOST_NOEXCEPT
-        {
-            return *this;
-        }
-
        BOOST_FUSION_CONSTEXPR_THIS BOOST_FUSION_GPU_ENABLED
        unused_type const&
        operator=(unused_type const&) const BOOST_NOEXCEPT
        {
            return *this;
        }
-
-        BOOST_CXX14_CONSTEXPR BOOST_FUSION_GPU_ENABLED
-        unused_type&
-        operator=(unused_type const&) BOOST_NOEXCEPT
-        {
-            return *this;
-        }
    };

    BOOST_CONSTEXPR_OR_CONST unused_type unused = unused_type();
--- a/include/boost/fusion/tuple/tuple.hpp
+++ b/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
--- a/meta/explicit-failures-markup.xml
+++ b/meta/explicit-failures-markup.xml
@ -9,8 +9,8 @@
            <toolset name="msvc-11.0"/>
            <toolset name="msvc-12.0"/>
            <toolset name="qcc-4.4.2_x86"/>
-            <toolset name="gcc-gnu-4.4~c++0x*"/>
-            <toolset name="gcc-gnu-4.4~gnu0x*"/>
+            <toolset name="gcc-4.4~c++0x*"/>
+            <toolset name="gcc-4.4~gnu0x*"/>
            <note author="Kohei Takahashi">
                The compiler doesn't generate defaulted move ctor/assgin thus
                perform copy construction/assginment. Even though such case,
--- a/test/Jamfile
+++ b/test/Jamfile
@ -1,7 +1,7 @@
 ##==============================================================================
 #    Copyright (c) 2003-2006 Joel de Guzman
 #    Copyright (c) 2013 Mateusz Loskot
-#    Copyright (c) 2014-2017 Kohei Takahashi
+#    Copyright (c) 2014-2018 Kohei Takahashi
 #
 #   Use, modification and distribution is subject to the Boost Software
 #   License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
@ -9,10 +9,17 @@
 #==============================================================================
 # bring in rules for testing
 import testing ;
+import os ;
 import ../../config/checks/config : requires ;

+if [ os.environ CI ]
+{
+    CI_DEFINES = <define>CI_SKIP_KNOWN_FAILURE=1 ;
+}
+
 project
    : requirements
+        $(CI_DEFINES)
    ;

 {
@ -35,7 +42,8 @@ project
    [ run algorithm/insert.cpp ]
    [ run algorithm/insert_range.cpp ]
    [ run algorithm/iter_fold.cpp ]
-    [ run algorithm/move.cpp ]
+    [ run algorithm/move.cpp : :
+        : [ requires cxx11_rvalue_references ] ]
    [ run algorithm/none.cpp ]
    [ run algorithm/pop_back.cpp ]
    [ run algorithm/pop_front.cpp ]
@ -99,7 +107,8 @@ project
    [ compile sequence/deque_is_constructible.cpp ]
    [ run sequence/deque_make.cpp ]
    [ run sequence/deque_misc.cpp ]
-    [ run sequence/deque_move.cpp ]
+    [ run sequence/deque_move.cpp : :
+        : [ requires cxx11_rvalue_references ] ]
    [ run sequence/deque_mutate.cpp ]
    [ run sequence/deque_nest.cpp ]
    [ run sequence/deque_tie.cpp ]
@ -113,7 +122,8 @@ project
    [ run sequence/map_construction.cpp ]
    [ run sequence/map_copy.cpp ]
    [ run sequence/map_misc.cpp ]
-    [ run sequence/map_move.cpp ]
+    [ run sequence/map_move.cpp : :
+        : [ requires cxx11_rvalue_references ] ]
    [ run sequence/map_mutate.cpp ]
    [ run sequence/map_tie.cpp ]
    [ run sequence/nil.cpp ]
@ -144,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 ]
@ -152,7 +164,8 @@ project
    [ run sequence/vector_iterator.cpp ]
    [ run sequence/vector_make.cpp ]
    [ run sequence/vector_misc.cpp ]
-    [ run sequence/vector_move.cpp ]
+    [ run sequence/vector_move.cpp : :
+        : [ requires cxx11_rvalue_references ] ]
    [ run sequence/vector_mutate.cpp ]
    [ run sequence/vector_n.cpp ]
    [ run sequence/vector_nest.cpp ]
@ -164,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 ]
@ -197,22 +212,28 @@ project
    [ run sequence/adt_attribute_proxy.cpp ]
    [ run sequence/define_struct.cpp ]
    [ run sequence/define_struct_empty.cpp ]
-    [ run sequence/define_struct_move.cpp ]
+    [ run sequence/define_struct_move.cpp : :
+        : [ requires cxx11_rvalue_references ] ]
    [ run sequence/define_struct_inline.cpp ]
    [ run sequence/define_struct_inline_empty.cpp ]
-    [ run sequence/define_struct_inline_move.cpp ]
+    [ run sequence/define_struct_inline_move.cpp : :
+        : [ requires cxx11_rvalue_references ] ]
    [ run sequence/define_assoc_struct.cpp ]
    [ run sequence/define_assoc_struct_empty.cpp ]
-    [ run sequence/define_assoc_struct_move.cpp ]
+    [ run sequence/define_assoc_struct_move.cpp : :
+        : [ requires cxx11_rvalue_references ] ]
    [ run sequence/define_tpl_struct.cpp ]
    [ run sequence/define_tpl_struct_empty.cpp ]
-    [ run sequence/define_tpl_struct_move.cpp ]
+    [ run sequence/define_tpl_struct_move.cpp : :
+        : [ requires cxx11_rvalue_references ] ]
    [ run sequence/define_tpl_struct_inline.cpp ]
    [ run sequence/define_tpl_struct_inline_empty.cpp ]
-    [ run sequence/define_tpl_struct_inline_move.cpp ]
+    [ run sequence/define_tpl_struct_inline_move.cpp : :
+        : [ requires cxx11_rvalue_references ] ]
    [ run sequence/define_assoc_tpl_struct.cpp ]
    [ run sequence/define_assoc_tpl_struct_empty.cpp ]
-    [ run sequence/define_assoc_tpl_struct_move.cpp ]
+    [ run sequence/define_assoc_tpl_struct_move.cpp : :
+        : [ requires cxx11_rvalue_references ] ]
    [ run sequence/std_tuple.cpp : :
        : [ requires cxx11_variadic_templates cxx11_hdr_tuple ] ]
    [ run sequence/std_tuple_iterator.cpp : :
@ -220,6 +241,7 @@ project
    [ run sequence/ref_vector.cpp ]
    [ run sequence/flatten_view.cpp ]
    [ compile sequence/github-159.cpp ]
+    [ run sequence/github-176.cpp ]

    [ compile sequence/size.cpp ]

@ -237,14 +259,22 @@ project
    [ run functional/invoke_procedure.cpp ]
    [ run sequence/swap.cpp ]

+    [ compile support/is_sequence.cpp ]
    [ compile support/pair_deque.cpp ]
    [ compile support/pair_list.cpp ]
    [ compile support/pair_map.cpp ]
    [ compile support/pair_set.cpp ]
    [ compile support/pair_vector.cpp ]
    [ compile support/pair_nest.cpp ]
-    [ compile support/index_sequence.cpp ]
-    [ compile support/and.cpp ]
+    [ compile support/index_sequence.cpp
+        : [ requires cxx11_variadic_templates ] ]
+    [ compile support/and.cpp
+        : [ 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  ]

--- a/test/algorithm/move.cpp
+++ b/test/algorithm/move.cpp
@ -1,13 +1,9 @@
 /*=============================================================================
-    Copyright (c) 2014 Kohei Takahashi
+    Copyright (c) 2014,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>
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-
 #include <boost/core/lightweight_test.hpp>
 #include <boost/fusion/container/vector/vector.hpp>
 #include <boost/fusion/container/list/list.hpp>
@ -29,12 +25,3 @@ int main()
    return boost::report_errors();
 }

-#else
-
-int main()
-{
-    // no thing to do
-}
-
-#endif
-
--- a/test/sequence/define_assoc_struct_move.cpp
+++ b/test/sequence/define_assoc_struct_move.cpp
@ -1,13 +1,9 @@
 /*=============================================================================
-    Copyright (c) 2016 Kohei Takahashi
+    Copyright (c) 2016,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>
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/adapted/struct/define_assoc_struct.hpp>
 #include <utility>
@ -69,10 +65,3 @@ int main()
    return boost::report_errors();
 }

-#else
-
-int main()
-{
-}
-
-#endif
--- a/test/sequence/define_struct_inline_move.cpp
+++ b/test/sequence/define_struct_inline_move.cpp
@ -1,13 +1,9 @@
 /*=============================================================================
-    Copyright (c) 2016 Kohei Takahashi
+    Copyright (c) 2016-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>
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/adapted/struct/define_struct_inline.hpp>
 #include <utility>
@ -51,8 +47,8 @@ int main()
        BOOST_TEST(y.w.value == 42);
    }

-    // Older MSVCs don't generate move ctor by default.
-#if !(defined(RUNNING_ON_APPVEYOR) && BOOST_WORKAROUND(BOOST_MSVC, < 1900))
+    // Older MSVCs and gcc 4.4 don't generate move ctor by default.
+#if !(defined(CI_SKIP_KNOWN_FAILURE) && (BOOST_WORKAROUND(BOOST_MSVC, < 1900) || BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)))
    {
        ns::value x;
        ns::value y(std::move(x)); // move
@ -70,15 +66,8 @@ int main()
        BOOST_TEST(x.w.value == 0);
        BOOST_TEST(y.w.value == 0);
    }
-#endif // !(appveyor && msvc < 14.0)
+#endif // !(ci && (msvc < 14.0 || gcc 4.4.x))

    return boost::report_errors();
 }

-#else
-
-int main()
-{
-}
-
-#endif
--- a/test/sequence/define_struct_move.cpp
+++ b/test/sequence/define_struct_move.cpp
@ -1,13 +1,9 @@
 /*=============================================================================
-    Copyright (c) 2016 Kohei Takahashi
+    Copyright (c) 2016,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>
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/adapted/struct/define_struct.hpp>
 #include <utility>
@ -68,10 +64,3 @@ int main()
    return boost::report_errors();
 }

-#else
-
-int main()
-{
-}
-
-#endif
--- a/test/sequence/define_tpl_struct_inline_move.cpp
+++ b/test/sequence/define_tpl_struct_inline_move.cpp
@ -1,13 +1,9 @@
 /*=============================================================================
-    Copyright (c) 2016 Kohei Takahashi
+    Copyright (c) 2016-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>
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/adapted/struct/define_struct_inline.hpp>
 #include <utility>
@ -51,8 +47,8 @@ int main()
        BOOST_TEST(y.w.value == 42);
    }

-    // Older MSVCs don't generate move ctor by default.
-#if !(defined(RUNNING_ON_APPVEYOR) && BOOST_WORKAROUND(BOOST_MSVC, < 1900))
+    // Older MSVCs and gcc 4.4 don't generate move ctor by default.
+#if !(defined(CI_SKIP_KNOWN_FAILURE) && (BOOST_WORKAROUND(BOOST_MSVC, < 1900) || BOOST_WORKAROUND(BOOST_GCC, / 100 == 404)))
    {
        ns::value<wrapper> x;
        ns::value<wrapper> y(std::move(x)); // move
@ -70,15 +66,8 @@ int main()
        BOOST_TEST(x.w.value == 0);
        BOOST_TEST(y.w.value == 0);
    }
-#endif // !(appveyor && msvc < 14.0)
+#endif // !(ci && (msvc < 14.0 || gcc 4.4.x))

    return boost::report_errors();
 }

-#else
-
-int main()
-{
-}
-
-#endif
--- a/test/sequence/define_tpl_struct_move.cpp
+++ b/test/sequence/define_tpl_struct_move.cpp
@ -1,13 +1,9 @@
 /*=============================================================================
-    Copyright (c) 2016 Kohei Takahashi
+    Copyright (c) 2016,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>
-#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
-
 #include <boost/detail/lightweight_test.hpp>
 #include <boost/fusion/adapted/struct/define_struct.hpp>
 #include <utility>
@ -68,10 +64,3 @@ int main()
    return boost::report_errors();
 }

-#else
-
-int main()
-{
-}
-
-#endif
--- a/test/sequence/deque_move.cpp
+++ b/test/sequence/deque_move.cpp
@ -1,16 +1,11 @@
 /*=============================================================================
    Copyright (c) 2012 Joel de Guzman
+    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)
 ==============================================================================*/
-#define BOOST_FUSION_DONT_USE_PREPROCESSED_FILES // $$$ JDG temp $$$
-
-
-#include <boost/config.hpp>
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-
+#define BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
 #include <boost/fusion/container/deque/deque.hpp>

 #define FUSION_SEQUENCE boost::fusion::deque<std::vector<x>>
@ -18,16 +13,9 @@

 #include "move.hpp"

-#else
-#include <boost/detail/lightweight_test.hpp>
-#endif
-
-int
-main()
+int main()
 {
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
    test();
-#endif

    return boost::report_errors();
 }
--- a/test/sequence/github-176.cpp
+++ b/test/sequence/github-176.cpp
@ -0,0 +1,89 @@
+/*=============================================================================
+    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/sequence/intrinsic/at.hpp>
+#include <boost/fusion/sequence/intrinsic/at_key.hpp>
+#include <boost/fusion/container/vector.hpp>
+#include <boost/fusion/container/list.hpp>
+#include <boost/fusion/container/deque.hpp>
+#include <boost/fusion/container/map.hpp>
+#include <boost/fusion/container/set.hpp>
+#include <boost/fusion/tuple/tuple.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+template <typename Sequence>
+void test_at()
+{
+    Sequence seq;
+
+    // zero initialized
+    BOOST_TEST(boost::fusion::at_c<0>(seq)[0] == 0);
+    BOOST_TEST(boost::fusion::at_c<0>(seq)[1] == 0);
+    BOOST_TEST(boost::fusion::at_c<0>(seq)[2] == 0);
+
+    int (&arr)[3] = boost::fusion::deref(boost::fusion::begin(seq));
+
+    arr[0] = 2;
+    arr[1] = 4;
+    arr[2] = 6;
+
+    BOOST_TEST(boost::fusion::at_c<0>(seq)[0] == 2);
+    BOOST_TEST(boost::fusion::at_c<0>(seq)[1] == 4);
+    BOOST_TEST(boost::fusion::at_c<0>(seq)[2] == 6);
+
+    boost::fusion::at_c<0>(seq)[1] = 42;
+
+    BOOST_TEST(boost::fusion::at_c<0>(seq)[0] == 2);
+    BOOST_TEST(boost::fusion::at_c<0>(seq)[1] == 42);
+    BOOST_TEST(boost::fusion::at_c<0>(seq)[2] == 6);
+}
+
+template <typename T> inline T& value(T& v) { return v; }
+template <typename K, typename T> inline T& value(boost::fusion::pair<K, T>& v) { return v.second; }
+
+template <typename Sequence>
+void test_at_key()
+{
+    Sequence seq;
+
+    // zero initialized
+    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[0] == 0);
+    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[1] == 0);
+    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[2] == 0);
+
+    int (&arr)[3] = value(boost::fusion::deref(boost::fusion::begin(seq)));
+
+    arr[0] = 2;
+    arr[1] = 4;
+    arr[2] = 6;
+
+    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[0] == 2);
+    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[1] == 4);
+    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[2] == 6);
+
+    boost::fusion::at_key<int[3]>(seq)[1] = 42;
+
+    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[0] == 2);
+    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[1] == 42);
+    BOOST_TEST(boost::fusion::at_key<int[3]>(seq)[2] == 6);
+}
+
+int main()
+{
+    using namespace boost::fusion;
+
+    test_at<vector<int[3]> >();
+    test_at<deque<int[3]> >();
+    test_at<list<int[3]> >();
+    test_at<tuple<int[3]> >();
+
+#if !BOOST_WORKAROUND(BOOST_GCC, / 100 == 406) || defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS)
+    // FIXME: gcc 4.6 w/ c++0x doesn't like set with array...
+    test_at_key<set<int[3]> >();
+#endif
+    test_at_key<map<pair<int[3], int[3]> > >();
+}
--- a/test/sequence/hash.hpp
+++ b/test/sequence/hash.hpp
@ -1,5 +1,6 @@
 /*=============================================================================
    Copyright (c) 2014 Christoph Weiss
+    Copyright (c) 2017 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)
@ -11,24 +12,24 @@
 #include <boost/fusion/sequence/hash.hpp>
 #include <boost/functional/hash.hpp>

-void
-hash_test()
+void hash_test()
 {
-    using namespace boost::fusion;
+    namespace fusion = boost::fusion;
+    using namespace fusion;

    const FUSION_SEQUENCE<int, char, bool, std::string> v0(42, 'x', false, "Aurea prima");
    const FUSION_SEQUENCE<int, char, bool, std::string> v1(42, 'x', false, "Aurea prima");
-    BOOST_TEST(hash_value(v0) == hash_value(v1));
-    
+    BOOST_TEST(fusion::hash_value(v0) == fusion::hash_value(v1));
+
    const FUSION_SEQUENCE<int, char, bool, std::string> w(41, 'x', false, "Aurea prima");
-    BOOST_TEST(hash_value(w) != hash_value(v0));
-    
+    BOOST_TEST(fusion::hash_value(w) != fusion::hash_value(v0));
+
    const FUSION_SEQUENCE<int, char, bool, std::string> x(42, 'y', false, "Aurea prima");
-    BOOST_TEST(hash_value(x) != hash_value(v0));
-    
+    BOOST_TEST(fusion::hash_value(x) != fusion::hash_value(v0));
+
    const FUSION_SEQUENCE<int, char, bool, std::string> y(42, 'x', true, "Aurea prima");
-    BOOST_TEST(hash_value(y) != hash_value(v0));
-    
+    BOOST_TEST(fusion::hash_value(y) != fusion::hash_value(v0));
+
    const FUSION_SEQUENCE<int, char, bool, std::string> z(42, 'x', false, "quae vindice nullo");
-    BOOST_TEST(hash_value(z) != hash_value(v0));
+    BOOST_TEST(fusion::hash_value(z) != fusion::hash_value(v0));
 }
--- a/test/sequence/map_move.cpp
+++ b/test/sequence/map_move.cpp
@ -1,15 +1,11 @@
 /*=============================================================================
    Copyright (c) 2012 Joel de Guzman
+    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)
 ==============================================================================*/
-#define BOOST_FUSION_DONT_USE_PREPROCESSED_FILES // $$$ JDG temp $$$
-
-#include <boost/config.hpp>
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-
+#define BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
 #include <boost/fusion/container/map/map.hpp>

 struct k1 {};
@ -23,16 +19,9 @@ struct k2 {};

 #include "move.hpp"

-#else
-#include <boost/detail/lightweight_test.hpp>
-#endif
-
-int
-main()
+int main()
 {
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
    test();
-#endif

    return boost::report_errors();
 }
--- a/test/sequence/traits.hpp
+++ b/test/sequence/traits.hpp
@ -1,5 +1,6 @@
 /*=============================================================================
    Copyright (C) 2016 Lee Clagett
+    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)
@ -38,9 +39,7 @@ bool is_convertible(bool has_conversion)
 }

 // is_constructible has a few requirements
-#if !defined(BOOST_NO_CXX11_DECLTYPE) &&   \
-    !defined(BOOST_NO_CXX11_TEMPLATES) &&  \
-    !defined(BOOST_NO_SFINAE_EXPR)
+#ifdef BOOST_TT_IS_CONSTRUCTIBLE_CONFORMING

 #define FUSION_TEST_HAS_CONSTRUCTIBLE

@ -88,7 +87,9 @@ void test_constructible()
    BOOST_TEST((
        is_constructible<FUSION_SEQUENCE<convertible>, convertible>(true)
    ));
-        
+
+    // boost::is_constructible always fail to test ctor which takes 2 or more arguments on GCC 4.7.
+#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
    BOOST_TEST((
        is_constructible<FUSION_SEQUENCE<int, int>, int, int>(true)
    ));
@ -131,6 +132,7 @@ void test_constructible()
            FUSION_SEQUENCE<convertible, convertible>, convertible, convertible
        >(true)
    ));
+#endif // !(gcc < 4.7)
 }

 #endif // is_constructible is available
--- a/test/sequence/trivially_copyable.hpp
+++ b/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
--- a/test/sequence/tuple_traits.cpp
+++ b/test/sequence/tuple_traits.cpp
@ -65,10 +65,13 @@ main()
    BOOST_TEST((is_constructible<tuple<int>, int, int>(false)));

    BOOST_TEST((is_constructible< tuple<int, int> >(true)));
+    // boost::is_constructible always fail to test ctor which takes 2 or more arguments on GCC 4.7.
+#if !BOOST_WORKAROUND(BOOST_GCC, < 40700)
    BOOST_TEST((is_constructible<tuple<int, int>, int, int>(true)));
    BOOST_TEST((
        is_constructible<tuple<convertible, convertible>, int, int>(true)
    ));
+#endif // !(gcc < 4.7)
    BOOST_TEST((is_constructible<tuple<int, not_convertible>, int, int>(false)));
    BOOST_TEST((is_constructible<tuple<not_convertible, int>, int, int>(false)));
    BOOST_TEST((
--- a/include/boost/fusion/support/detail/unknown_key.hpp
+++ b/include/boost/fusion/support/detail/unknown_key.hpp
@ -1,16 +1,17 @@
 /*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
+    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)
 ==============================================================================*/
-#if !defined(FUSION_UNKNOWN_KEY_09242005_1219)
-#define FUSION_UNKNOWN_KEY_09242005_1219
+#include <boost/fusion/tuple/tuple_fwd.hpp>

-namespace boost { namespace fusion { namespace detail
-{
-    template <int index>
-    struct unknown_key {};
-}}}
+#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
+
--- a/test/sequence/vector_move.cpp
+++ b/test/sequence/vector_move.cpp
@ -1,15 +1,11 @@
 /*=============================================================================
    Copyright (c) 2012 Joel de Guzman
+    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)
 ==============================================================================*/
-#define BOOST_FUSION_DONT_USE_PREPROCESSED_FILES // $$$ JDG temp $$$
-
-#include <boost/config.hpp>
-
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-
+#define BOOST_FUSION_DONT_USE_PREPROCESSED_FILES
 #include <boost/fusion/container/vector/vector.hpp>

 #define FUSION_SEQUENCE boost::fusion::vector<std::vector<x>>
@ -17,16 +13,9 @@

 #include "move.hpp"

-#else
-#include <boost/detail/lightweight_test.hpp>
-#endif
-
-int
-main()
+int main()
 {
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
    test();
-#endif

    return boost::report_errors();
 }
--- a/include/boost/fusion/support/detail/is_view.hpp
+++ b/include/boost/fusion/support/detail/is_view.hpp
@ -1,19 +1,17 @@
 /*=============================================================================
-    Copyright (c) 2001-2011 Joel de Guzman
+    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)
 ==============================================================================*/
-#if !defined(FUSION_IS_VIEW_03202006_0018)
-#define FUSION_IS_VIEW_03202006_0018
+#include <boost/fusion/container/vector/detail/config.hpp>

-namespace boost { namespace fusion { namespace detail
-{
-    template <typename T>
-    struct fusion_is_view
-    {
-        typedef typename T::is_view type;
-    };
-}}}
+#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
+
--- a/test/support/and.cpp
+++ b/test/support/and.cpp
@ -1,33 +1,28 @@
 /*=============================================================================
    Copyright (c) 2016 Lee Clagett
+    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>

-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-#include <boost/detail/lightweight_test.hpp>
-#include <boost/fusion/support/detail/and.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/type_traits/integral_constant.hpp>
-
-int main() {
-    using namespace boost;
-    using namespace boost::fusion::detail;
-
-    BOOST_TEST((and_<>::value));
-    BOOST_TEST(!(and_<false_type>::value));
-    BOOST_TEST((and_<true_type>::value));
-    BOOST_TEST(!(and_<true_type, false_type>::value));
-    BOOST_TEST((and_<true_type, true_type>::value));
-    BOOST_TEST(!(and_<true_type, true_type, false_type>::value));
-    BOOST_TEST((and_<true_type, true_type, true_type>::value));
-    BOOST_TEST((and_<true_type, mpl::true_>::value));
-
-    return boost::report_errors();
-}
-
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#   error "does not meet requirements"
 #endif

+#include <boost/fusion/support/detail/and.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/mpl/assert.hpp>
+
+using namespace boost;
+using namespace boost::fusion::detail;
+
+BOOST_MPL_ASSERT((and_<>));
+BOOST_MPL_ASSERT_NOT((and_<false_type>));
+BOOST_MPL_ASSERT((and_<true_type>));
+BOOST_MPL_ASSERT_NOT((and_<true_type, false_type>));
+BOOST_MPL_ASSERT((and_<true_type, true_type>));
+BOOST_MPL_ASSERT_NOT((and_<true_type, true_type, false_type>));
+BOOST_MPL_ASSERT((and_<true_type, true_type, true_type>));
+BOOST_MPL_ASSERT((and_<true_type, mpl::true_>));
--- a/test/support/index_sequence.cpp
+++ b/test/support/index_sequence.cpp
@ -1,12 +1,14 @@
 /*=============================================================================
-    Copyright (c) 2015 Kohei Takahashi
+    Copyright (c) 2015,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>

-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+#ifdef BOOST_NO_CXX11_VARIADIC_TEMPLATES
+#   error "does not meet requirements"
+#endif

 #include <boost/fusion/support/detail/index_sequence.hpp>
 #include <boost/mpl/assert.hpp>
@ -28,5 +30,3 @@ BOOST_MPL_ASSERT((boost::is_same<detail::make_index_sequence<15>::type, detail::
 BOOST_MPL_ASSERT((boost::is_same<detail::make_index_sequence<16>::type, detail::index_sequence<0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15> >));
 BOOST_MPL_ASSERT((boost::is_same<detail::make_index_sequence<17>::type, detail::index_sequence<0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16> >));

-#endif
-
--- a/test/support/is_sequence.cpp
+++ b/test/support/is_sequence.cpp
@ -0,0 +1,17 @@
+/*=============================================================================
+    Copyright (c) 2018 Louis Dionne
+
+    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/support/is_sequence.hpp>
+#include <boost/static_assert.hpp>
+
+
+// Make sure fusion::is_sequence and fusion::is_native_fusion_sequence can be
+// used with an incomplete type.
+struct incomplete;
+BOOST_STATIC_ASSERT(!boost::fusion::traits::is_sequence<incomplete>::value);
+BOOST_STATIC_ASSERT(!boost::fusion::traits::is_native_fusion_sequence<incomplete>::value);
+
+int main() { }
--- a/test/support/is_trivially_copyable.cpp
+++ b/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
--- a/test/support/propagate_trivialness.cpp
+++ b/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>));
--- a/test/support/tag_of.cpp
+++ b/test/support/tag_of.cpp
@ -0,0 +1,17 @@
+/*=============================================================================
+    Copyright (c) 2018 Louis Dionne
+
+    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/support/tag_of.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+
+// Make sure tag_of can be used with an incomplete type.
+struct incomplete;
+typedef boost::fusion::traits::tag_of<incomplete>::type Tag;
+BOOST_STATIC_ASSERT((boost::is_same<Tag, boost::fusion::non_fusion_tag>::value));
+
+int main() { }
--- a/test/support/trivial.hpp
+++ b/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
+
--- a/test/support/unused.cpp
+++ b/test/support/unused.cpp
@ -0,0 +1,95 @@
+/*=============================================================================
+    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/unused.hpp>
+#include <boost/type_traits/detail/yes_no_type.hpp>
+#include <boost/static_assert.hpp>
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+#include <utility>
+#endif
+
+struct T { };
+
+void unused_construction()
+{
+    boost::fusion::unused_type dephault;
+
+    boost::fusion::unused_type BOOST_ATTRIBUTE_UNUSED parenthesis();
+#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+    boost::fusion::unused_type BOOST_ATTRIBUTE_UNUSED brace{};
+    boost::fusion::unused_type BOOST_ATTRIBUTE_UNUSED list_copy = {};
+#endif
+
+    boost::fusion::unused_type copy_copy BOOST_ATTRIBUTE_UNUSED = dephault;
+    boost::fusion::unused_type copy_direct BOOST_ATTRIBUTE_UNUSED (dephault);
+#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+    boost::fusion::unused_type copy_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {dephault};
+    boost::fusion::unused_type copy_direct_brace BOOST_ATTRIBUTE_UNUSED {dephault};
+#endif
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    boost::fusion::unused_type move_copy BOOST_ATTRIBUTE_UNUSED = std::move(dephault);
+    boost::fusion::unused_type move_direct BOOST_ATTRIBUTE_UNUSED (std::move(dephault));
+#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+    boost::fusion::unused_type move_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {std::move(dephault)};
+    boost::fusion::unused_type move_direct_brace BOOST_ATTRIBUTE_UNUSED {std::move(dephault)};
+#endif
+#endif
+
+
+    T value;
+
+    boost::fusion::unused_type T_copy_copy BOOST_ATTRIBUTE_UNUSED = value;
+    boost::fusion::unused_type T_copy_direct BOOST_ATTRIBUTE_UNUSED (value);
+#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+    boost::fusion::unused_type T_copy_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {value};
+    boost::fusion::unused_type T_copy_direct_brace BOOST_ATTRIBUTE_UNUSED {value};
+#endif
+
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    boost::fusion::unused_type T_move_copy BOOST_ATTRIBUTE_UNUSED = std::move(value);
+    boost::fusion::unused_type T_move_direct BOOST_ATTRIBUTE_UNUSED (std::move(value));
+#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+    boost::fusion::unused_type T_move_copy_brace_direct BOOST_ATTRIBUTE_UNUSED = {std::move(value)};
+    boost::fusion::unused_type T_move_direct_brace BOOST_ATTRIBUTE_UNUSED {std::move(value)};
+#endif
+#endif
+}
+
+void unused_assignment()
+{
+    boost::fusion::unused_type val1, val2;
+
+    val1 = val2;
+#ifndef BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX
+    val1 = {};
+#endif
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    val1 = std::move(val2);
+#endif
+
+
+    T value;
+
+    val1 = value;
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    val1 = std::move(value);
+#endif
+}
+
+boost::type_traits::yes_type test_unused(boost::fusion::detail::unused_only const&);
+boost::type_traits::no_type  test_unused(...);
+
+void only_unused()
+{
+    BOOST_STATIC_ASSERT((sizeof(test_unused(boost::fusion::unused)) == sizeof(boost::type_traits::yes_type)));
+    BOOST_STATIC_ASSERT((sizeof(test_unused(0)) == sizeof(boost::type_traits::no_type)));
+
+    boost::fusion::unused_type my_unused;
+    BOOST_STATIC_ASSERT((sizeof(test_unused(my_unused)) == sizeof(boost::type_traits::yes_type)));
+}
Author	SHA1	Message	Date
Kohei Takahashi	a844a55846	Remove redundant noexcept specifier to compile with gcc 4.6	2018-05-13 16:56:46 +09:00
Kohei Takahashi	aae2304699	Fixed wrong type of special functions	2018-05-13 16:01:57 +09:00
Kohei Takahashi	c508ddafea	Disabled cv-qualifierd function type warning on msvc	2018-05-10 02:08:24 +09:00
Kohei Takahashi	37e4fab58b	Added notes for CWG 496 and CWG 2094 rename macros to be more descriptive	2018-05-10 00:55:07 +09:00
Kohei Takahashi	5c3600d277	Fixed the use of unintroduced namespace	2018-05-09 12:39:06 +09:00
Kohei Takahashi	5d5ed0bc8d	Don't test on non conforming platform	2018-05-09 03:09:24 +09:00
Kohei Takahashi	8e25d0ef77	Enabled using compiler builtin	2018-05-09 03:04:03 +09:00
Kohei Takahashi	fb26953fcf	Suppress known warning	2018-05-09 03:03:38 +09:00
Kohei Takahashi	8a2f444761	Fixed fallback traits condition	2018-05-08 23:13:12 +09:00
Kohei Takahashi	dfa3650307	Make sure that are class type	2018-05-08 13:09:46 +09:00
Kohei Takahashi	f9e618d825	Added tests for array type	2018-05-08 13:06:17 +09:00
Kohei Takahashi	687491be85	aligned_storage is not guarantted for trivially copyable	2018-05-08 12:52:40 +09:00
Kohei Takahashi	aa8342d5cb	Added test for trivially copyable sequence	2018-05-08 02:16:16 +09:00
Kohei Takahashi	b4afa1c69b	It's not a trivially copyable unless all elems are	2018-05-08 00:38:10 +09:00
Kohei Takahashi	cb4a4cdde7	It should be default constructible	2018-05-08 00:23:04 +09:00
Kohei Takahashi	b03d1e9458	Added utility for forcing to be non trivial copyable	2018-05-07 23:17:25 +09:00
Kohei Takahashi	c7ba5595fc	Added is_trivially_copyable traits	2018-05-07 22:33:06 +09:00
Kohei Takahashi	b978b47952	Merge upstream branch 'develop' into optimization/vector-and-tuple	2018-05-07 12:27:46 +09:00
Kohei Takahashi	98b96c3b97	Merge pull request #179 from boostorg/support Reorganize support facility to simplify	2018-04-28 00:21:06 +09:00
Kohei Takahashi	68be23a0b9	Merge upstream branch 'develop' into support	2018-04-27 20:32:09 +09:00
Kohei Takahashi	6f8de8d774	Added workaround for fold expr and dependent name	2018-04-27 20:29:06 +09:00
Kohei Takahashi	5221bbbc76	Added workaround for defaulted and noexcept	2018-04-27 14:56:23 +09:00
Kohei Takahashi	0e900bba3f	Specify defaulted and remove unnecessary functions from unused_type	2018-04-27 12:37:37 +09:00
Kohei Takahashi	38aa3705d0	Added test for unused_type	2018-04-27 12:37:00 +09:00
Kohei Takahashi	1854626651	Merge pull request #178 from boostorg/more-ci-targets More ci targets	2018-04-26 06:41:55 +09:00
Kohei Takahashi	e8da43a539	Added workaround for gcc 4.6 with C array	2018-04-26 00:02:57 +09:00
Kohei Takahashi	3b8fb67b52	Update WA condition	2018-04-22 03:44:57 +09:00
Kohei Takahashi	c4881f1862	Merge upstream branch 'develop' into more-ci-targets	2018-04-22 03:41:55 +09:00
Kohei Takahashi	e818089a91	likewise	2018-04-21 19:18:09 +09:00
Kohei Takahashi	a95a838779	Added workaround to test is_constructible on GCC < 4.7 always fail to test non unary ctor	2018-04-21 18:22:24 +09:00
Kohei Takahashi	7443cb1101	Changed availability condition to what Boost.TT providing	2018-04-20 13:04:02 +09:00
Kohei Takahashi	84b1847442	Merge pull request #177 from boostorg/bugfix/c-style-array Fixed compile error with C-style array	2018-04-19 01:44:13 +09:00
Kohei Takahashi	a273cd8131	Added workaround for msvc-14.x	2018-04-19 00:21:41 +09:00
Kohei Takahashi	757541f9d2	Updated c-style array test for associative container	2018-04-18 22:39:55 +09:00
Kohei Takahashi	dd695c1dbd	Fixed a compile error bug similar to previous vector's one	2018-04-18 22:38:09 +09:00
Kohei Takahashi	96b2e51828	Added test for #176	2018-04-18 22:33:36 +09:00
Kohei Takahashi	e962c1abb5	Fixed vector compile error with C-style array	2018-04-18 22:31:35 +09:00
Kohei Takahashi	e3b053f969	Remove detail metafunctions to simplify template	2018-03-15 20:49:38 +09:00
Kohei Takahashi	11a3f250b8	Remove unused header	2018-03-15 19:56:07 +09:00
Kohei Takahashi	79262831ef	Merge pull request #174 from boostorg/testfix/logical-and Fixed detail::and test	2018-03-15 13:35:23 +09:00
Kohei Takahashi	9536909a3a	Remove redundant argument.	2018-03-14 16:02:07 +09:00
Kohei Takahashi	47070610d0	Remove unnecessary user defined ctor there is no reasons defining those probably. This change allows to be vector trivially copyable iff all elements are trivially copyable, i.e. following static assert now passes. ```cpp static_assert(std::is_trivially_copyable<vector<double, int>>{}); ```	2018-03-14 15:15:33 +09:00
Kohei Takahashi	d8f608c8f1	Move is_native_fusion_sequence to detail in order to reuse it in is_mpl_sequence	2018-03-14 14:53:30 +09:00
Kohei Takahashi	2aea153be0	Use fold expression to improbe compile speed	2018-03-14 14:53:07 +09:00
Kohei Takahashi	4734cf4a13	Fixed detail::and test it should be used mpl/assert instead of runtime facility.	2018-03-14 14:41:43 +09:00
Kohei Takahashi	d5bd71c886	Update dead/moved links	2018-03-14 00:51:48 +09:00
Kohei Takahashi	c3dec40e72	Fixed links to support list. Gmane had been closed and not back yet.	2018-03-13 23:18:03 +09:00
Kohei Takahashi	9de3272174	Added workaround for GCC 4.4/c++0x Teh call of ctor is ambiguous since gcc 4.4 allows binding rvalue to lvalue reference.	2018-03-06 00:40:41 +09:00
Kohei Takahashi	25c6334c58	meta: Update failure toolset name	2018-03-03 16:20:08 +09:00
Kohei Takahashi	101a056a92	Merge pull request #171 from ldionne/develop Allow incomplete types in fusion::tag_of and fusion::is_native_fusion_sequence	2018-03-03 13:31:22 +09:00
Louis Dionne	82f677c169	Allow incomplete types in fusion::tag_of and fusion::is_native_fusion_sequence	2018-03-02 02:03:43 -08:00
Kohei Takahashi	f61bffb21f	Remove $$$ JDG temp $$$	2018-02-24 16:00:57 +09:00
Kohei Takahashi	4c67886cc2	Merge pull request #168 from Kojoley/add-limits-precheck Add limits precheck	2018-02-21 21:45:13 +09:00
Nikita Kniazev	38818fbe3d	Add limits precheck	2018-02-20 22:44:34 +03:00
Kohei Takahashi	eeeee9bfbb	Fixed ambiguous call of hash_value ADL also picks stdext::hash_value which msvc providing.	2018-02-19 22:40:56 +09:00
Kohei Takahashi	eb0cbbc347	CI: trusty doesn't provide gcc 4.5	2018-02-18 21:25:51 +09:00
Kohei Takahashi	d0c17119e7	CI: skip known to fail	2018-02-17 17:46:03 +09:00
Kohei Takahashi	28ea5dacce	CI: Added more build target	2018-02-17 17:45:49 +09:00
Kohei Takahashi	6c96720080	CI: Remove build branch restriction	2018-02-17 17:27:20 +09:00
Kohei Takahashi	0a8f0f49b2	Merge pull request #167 from boostorg/enhancement/ci Improve CI performance, like phoenix	2018-01-29 20:04:18 +09:00
Kohei Takahashi	cdd1408d2b	Update dependency functional/hash was branched off into contaienr_hash	2018-01-29 12:35:30 +09:00
Kohei Takahashi	540ea0ef0c	Use build time configuration	2018-01-29 12:03:19 +09:00
Kohei Takahashi	671f22b013	Use new common CI marker	2018-01-29 10:34:33 +09:00
Kohei Takahashi	dfceaffc58	Update copyright year	2018-01-29 10:30:55 +09:00
Kohei Takahashi	2c86e9d18c	Added hash option to b2 to mitigate max path length exceeding.	2018-01-29 10:17:06 +09:00
Kohei Takahashi	d8e6f406ab	Mark as CI in Jamfile not command line super-project also runs regression test, but they doesn't define that.	2018-01-29 10:15:39 +09:00
Kohei Takahashi	b42314fb02	Enabling parallel option to CI job	2018-01-29 10:10:15 +09:00
Kohei Takahashi	806b621931	Merge pull request #166 from Kojoley/cwg-defect-945 vector: Fix for compilers not compatible with CWG defect 945	2017-12-24 11:40:58 +09:00
Nikita Kniazev	39fb05e40f	vector: Fix for compilers not compatible with CWG defect 945 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#945	2017-12-23 18:17:04 +03:00
Joel de Guzman	dc47261890	Merge pull request #164 from Kojoley/fix-map-vs2017-15.5 map: Switch to SFINAE in template parameters	2017-12-14 06:45:27 +08:00
Nikita Kniazev	099333b61d	map: Switch to SFINAE in template parameters Fixes #163. Since C++11 we can do SFINAE in template parameters. VS2017 15.5 doesn't like the SFINAE on argument here, but do not ask me why, because I have no idea.	2017-12-14 00:05:28 +03:00