diff --git a/include/boost/fusion/support/detail/is_trivially_copyable.hpp b/include/boost/fusion/support/detail/is_trivially_copyable.hpp
index 51863e93..d2d2813e 100644
--- a/include/boost/fusion/support/detail/is_trivially_copyable.hpp
+++ b/include/boost/fusion/support/detail/is_trivially_copyable.hpp
@@ -14,6 +14,11 @@
     // 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
 
diff --git a/test/sequence/trivially_copyable.hpp b/test/sequence/trivially_copyable.hpp
index d091f530..13a1ea93 100644
--- a/test/sequence/trivially_copyable.hpp
+++ b/test/sequence/trivially_copyable.hpp
@@ -14,20 +14,20 @@
 
 using namespace boost::fusion;
 
-BOOST_FUSION_ASSERT_FALLBACK((detail::is_trivially_copyable<FUSION_SEQUENCE<> >));
-BOOST_FUSION_ASSERT_FALLBACK((detail::is_trivially_copyable<FUSION_SEQUENCE<int> >));
-BOOST_FUSION_ASSERT_FALLBACK((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int> >));
-BOOST_FUSION_ASSERT_FALLBACK((detail::is_trivially_copyable<FUSION_SEQUENCE<int, int, int> >));
+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_FALLBACK((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<> > >));
-BOOST_FUSION_ASSERT_FALLBACK((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<int> > >));
-BOOST_FUSION_ASSERT_FALLBACK((detail::is_trivially_copyable<FUSION_SEQUENCE<FUSION_SEQUENCE<int>, FUSION_SEQUENCE<int, int> > >));
-BOOST_FUSION_ASSERT_FALLBACK((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<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_FALLBACK((detail::is_trivially_copyable<FUSION_SEQUENCE<int, trivial> >));
+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> >));
diff --git a/test/support/is_trivially_copyable.cpp b/test/support/is_trivially_copyable.cpp
index 59b83c9f..201b8a7b 100644
--- a/test/support/is_trivially_copyable.cpp
+++ b/test/support/is_trivially_copyable.cpp
@@ -25,16 +25,16 @@ 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_WA((is_trivially_copyable<int volatile>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<int const volatile>));
+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_WA((is_trivially_copyable<int* volatile>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<int* const volatile>));
+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&>));
@@ -50,42 +50,42 @@ BOOST_MPL_ASSERT_NOT((is_trivially_copyable<int const volatile&&>));
 
 BOOST_MPL_ASSERT((is_trivially_copyable<int[]>));
 BOOST_MPL_ASSERT((is_trivially_copyable<int const[]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<int volatile[]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<int const volatile[]>));
+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_WA((is_trivially_copyable<int volatile[3]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<int const volatile[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_WA((is_trivially_copyable<int volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<int const volatile[][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_WA((is_trivially_copyable<int(*volatile)[]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<int(*const volatile)[]>));
+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_WA((is_trivially_copyable<int(*volatile)[3]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<int(*const volatile)[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_WA((is_trivially_copyable<int(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<int(*const volatile)[][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(&)[]>));
@@ -130,8 +130,8 @@ 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_WA((is_trivially_copyable<function_type* volatile>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<function_type* const volatile>));
+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&>));
@@ -150,48 +150,48 @@ 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_WA((is_trivially_copyable<function_type* volatile[]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<function_type* const volatile[]>));
+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_WA((is_trivially_copyable<function_type* volatile[3]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<function_type* const volatile[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_WA((is_trivially_copyable<function_type* volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<function_type* const volatile[][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_WA((is_trivially_copyable<function_type*(*volatile)[]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<function_type*(*const volatile)[]>));
+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_WA((is_trivially_copyable<function_type*(*volatile)[3]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<function_type*(*const volatile)[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_WA((is_trivially_copyable<function_type*(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<function_type*(*const volatile)[][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*(&)[]>));
@@ -227,47 +227,47 @@ BOOST_MPL_ASSERT_NOT((is_trivially_copyable<function_type const volatile*(&&)[][
 
 BOOST_MPL_ASSERT((is_trivially_copyable<member_type>));
 BOOST_MPL_ASSERT((is_trivially_copyable<member_type const>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_type volatile>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_type const volatile>));
+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_WA((is_trivially_copyable<member_type volatile[]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_type const volatile[]>));
+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_WA((is_trivially_copyable<member_type volatile[3]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_type const volatile[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_WA((is_trivially_copyable<member_type volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_type const volatile[][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_WA((is_trivially_copyable<member_type(*volatile)[]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_type(*const volatile)[]>));
+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_WA((is_trivially_copyable<member_type(*volatile)[3]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_type(*const volatile)[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_WA((is_trivially_copyable<member_type(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_type(*const volatile)[][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(&)[]>));
@@ -303,47 +303,47 @@ BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_type const volatile(&&)[][3][
 
 BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type>));
 BOOST_MPL_ASSERT((is_trivially_copyable<member_function_type const>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_function_type volatile>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_function_type const volatile>));
+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_WA((is_trivially_copyable<member_function_type volatile[]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_function_type const volatile[]>));
+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_WA((is_trivially_copyable<member_function_type volatile[3]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_function_type const volatile[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_WA((is_trivially_copyable<member_function_type volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_function_type const volatile[][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_WA((is_trivially_copyable<member_function_type(*volatile)[]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_function_type(*const volatile)[]>));
+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_WA((is_trivially_copyable<member_function_type(*volatile)[3]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_function_type(*const volatile)[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_WA((is_trivially_copyable<member_function_type(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<member_function_type(*const volatile)[][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(&)[]>));
@@ -378,18 +378,18 @@ BOOST_MPL_ASSERT_NOT((is_trivially_copyable<member_function_type const volatile(
 #endif
 
 
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial>));
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial const>));
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial volatile>));
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial const volatile>));
+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_WA((is_trivially_copyable<trivial* volatile>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<trivial* const volatile>));
+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&>));
@@ -403,44 +403,44 @@ BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial volatile&&>));
 BOOST_MPL_ASSERT_NOT((is_trivially_copyable<trivial const volatile&&>));
 #endif
 
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial[]>));
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial const[]>));
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial volatile[]>));
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial const volatile[]>));
+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_FALLBACK((is_trivially_copyable<trivial[3]>));
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial const[3]>));
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial volatile[3]>));
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial const volatile[3]>));
+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_FALLBACK((is_trivially_copyable<trivial[][3][4][5]>));
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial const[][3][4][5]>));
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial volatile[][3][4][5]>));
-BOOST_FUSION_ASSERT_FALLBACK((is_trivially_copyable<trivial const volatile[][3][4][5]>));
+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_WA((is_trivially_copyable<trivial(*volatile)[]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<trivial(*const volatile)[]>));
+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_WA((is_trivially_copyable<trivial(*volatile)[3]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<trivial(*const volatile)[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_WA((is_trivially_copyable<trivial(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<trivial(*const volatile)[][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(&)[]>));
@@ -485,8 +485,8 @@ 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_WA((is_trivially_copyable<user_provided_copy* volatile>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<user_provided_copy* const volatile>));
+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&>));
@@ -520,24 +520,24 @@ 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_WA((is_trivially_copyable<user_provided_copy(*volatile)[]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<user_provided_copy(*const volatile)[]>));
+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_WA((is_trivially_copyable<user_provided_copy(*volatile)[3]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<user_provided_copy(*const volatile)[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_WA((is_trivially_copyable<user_provided_copy(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<user_provided_copy(*const volatile)[][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(&)[]>));
@@ -583,8 +583,8 @@ 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_WA((is_trivially_copyable<user_provided_move* volatile>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<user_provided_move* const volatile>));
+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&>));
@@ -616,24 +616,24 @@ 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_WA((is_trivially_copyable<user_provided_move(*volatile)[]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<user_provided_move(*const volatile)[]>));
+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_WA((is_trivially_copyable<user_provided_move(*volatile)[3]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<user_provided_move(*const volatile)[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_WA((is_trivially_copyable<user_provided_move(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<user_provided_move(*const volatile)[][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(&)[]>));
@@ -677,8 +677,8 @@ 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_WA((is_trivially_copyable<user_provided_dtor* volatile>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<user_provided_dtor* const volatile>));
+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&>));
@@ -712,24 +712,24 @@ 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_WA((is_trivially_copyable<user_provided_dtor(*volatile)[]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<user_provided_dtor(*const volatile)[]>));
+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_WA((is_trivially_copyable<user_provided_dtor(*volatile)[3]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<user_provided_dtor(*const volatile)[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_WA((is_trivially_copyable<user_provided_dtor(*volatile)[][3][4][5]>));
-BOOST_FUSION_ASSERT_WA((is_trivially_copyable<user_provided_dtor(*const volatile)[][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(&)[]>));
diff --git a/test/support/propagate_trivialness.cpp b/test/support/propagate_trivialness.cpp
index 17050ca4..be386512 100644
--- a/test/support/propagate_trivialness.cpp
+++ b/test/support/propagate_trivialness.cpp
@@ -21,23 +21,23 @@ 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_FALLBACK((is_trivially_copyable<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_WA((is_base_of<trivial_base, propagate_trivialness<int volatile> >));
-BOOST_FUSION_ASSERT_WA((is_base_of<trivial_base, propagate_trivialness<int const volatile> >));
+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_WA((is_base_of<trivial_base, propagate_trivialness<int* volatile> >));
-BOOST_FUSION_ASSERT_WA((is_base_of<trivial_base, propagate_trivialness<int* const volatile> >));
+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&> >));
@@ -52,18 +52,18 @@ BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<int const v
 #endif
 
 
-BOOST_FUSION_ASSERT_FALLBACK((is_base_of<trivial_base, propagate_trivialness<trivial> >));
-BOOST_FUSION_ASSERT_FALLBACK((is_base_of<trivial_base, propagate_trivialness<trivial const> >));
-BOOST_FUSION_ASSERT_FALLBACK((is_base_of<trivial_base, propagate_trivialness<trivial volatile> >));
-BOOST_FUSION_ASSERT_FALLBACK((is_base_of<trivial_base, propagate_trivialness<trivial const volatile> >));
+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_WA((is_base_of<trivial_base, propagate_trivialness<trivial* volatile> >));
-BOOST_FUSION_ASSERT_WA((is_base_of<trivial_base, propagate_trivialness<trivial* const volatile> >));
+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&> >));
@@ -88,8 +88,8 @@ BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_c
 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_WA((is_base_of<trivial_base, propagate_trivialness<user_provided_copy* volatile> >));
-BOOST_FUSION_ASSERT_WA((is_base_of<trivial_base, propagate_trivialness<user_provided_copy* const volatile> >));
+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&> >));
@@ -115,8 +115,8 @@ BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_m
 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_WA((is_base_of<trivial_base, propagate_trivialness<user_provided_move* volatile> >));
-BOOST_FUSION_ASSERT_WA((is_base_of<trivial_base, propagate_trivialness<user_provided_move* const volatile> >));
+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&> >));
@@ -140,8 +140,8 @@ BOOST_MPL_ASSERT((is_base_of<trivial_base, propagate_trivialness<user_provided_d
 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_WA((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor* volatile> >));
-BOOST_FUSION_ASSERT_WA((is_base_of<trivial_base, propagate_trivialness<user_provided_dtor* const volatile> >));
+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&> >));
@@ -158,7 +158,7 @@ BOOST_MPL_ASSERT((is_base_of<non_trivial_base, propagate_trivialness<user_provid
 
 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_FALLBACK((is_base_of<trivial_base, propagate_trivialness<int, float, trivial> >));
+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> >));
@@ -171,7 +171,7 @@ 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_FALLBACK((is_trivially_copyable<S3>));
+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>));
diff --git a/test/support/trivial.hpp b/test/support/trivial.hpp
index 7b74597a..66eb6011 100644
--- a/test/support/trivial.hpp
+++ b/test/support/trivial.hpp
@@ -9,17 +9,27 @@
 
 #include <boost/fusion/support/detail/is_trivially_copyable.hpp>
 #include <boost/mpl/assert.hpp>
+#include <boost/static_assert.hpp>
 
-#ifndef BOOST_FUSION_DETAIL_VOLATILE_SCALAR_IS_NON_TRIVIALLY_COPYABLE
-#   define BOOST_FUSION_ASSERT_WA BOOST_MPL_ASSERT
+#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_WA BOOST_MPL_ASSERT_NOT
+#   define BOOST_FUSION_ASSERT_CWG496_SCALAR BOOST_MPL_ASSERT
 #endif
 
-#ifdef BOOST_FUSION_DETAIL_IS_TRIVIALLY_COPYABLE_CONFORMING
-#   define BOOST_FUSION_ASSERT_FALLBACK BOOST_MPL_ASSERT
+#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_FALLBACK(cond) BOOST_MPL_ASSERT((boost::mpl::true_))
+#   define BOOST_FUSION_ASSERT_CWG496(pred) struct skip_assertion
+#   define BOOST_FUSION_ASSERT_CWG2094(pred) struct skip_assertion
 #endif