diff --git a/include/boost/type_traits/alignment_of.hpp b/include/boost/type_traits/alignment_of.hpp
index 51357ce..e1735dc 100644
--- a/include/boost/type_traits/alignment_of.hpp
+++ b/include/boost/type_traits/alignment_of.hpp
@@ -93,7 +93,7 @@ BOOST_TT_AUX_SIZE_T_TRAIT_DEF1(alignment_of,T,::boost::detail::alignment_of_impl
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 template <typename T>
 struct alignment_of<T&>
-    : alignment_of<T*>
+    : public alignment_of<T*>
 {
 };
 #endif
diff --git a/include/boost/type_traits/common_type.hpp b/include/boost/type_traits/common_type.hpp
index 25c877f..2739688 100644
--- a/include/boost/type_traits/common_type.hpp
+++ b/include/boost/type_traits/common_type.hpp
@@ -141,7 +141,7 @@ namespace type_traits_detail {
     template <class T, class U>
     struct common_type<T, U, void>
 #endif
-    : type_traits_detail::common_type_2<T,U>
+    : public type_traits_detail::common_type_2<T,U>
     { };
 
 
diff --git a/include/boost/type_traits/detail/bool_trait_def.hpp b/include/boost/type_traits/detail/bool_trait_def.hpp
index a54c910..05e7218 100644
--- a/include/boost/type_traits/detail/bool_trait_def.hpp
+++ b/include/boost/type_traits/detail/bool_trait_def.hpp
@@ -60,7 +60,7 @@
 #endif
 
 #ifndef BOOST_TT_AUX_BOOL_C_BASE
-#   define BOOST_TT_AUX_BOOL_C_BASE(C) : ::boost::integral_constant<bool,C>
+#   define BOOST_TT_AUX_BOOL_C_BASE(C) : public ::boost::integral_constant<bool,C>
 #endif 
 
 
@@ -68,6 +68,7 @@
 template< typename T > struct trait \
     BOOST_TT_AUX_BOOL_C_BASE(C) \
 { \
+public:\
     BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
 }; \
@@ -80,6 +81,7 @@ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
 template< typename T1, typename T2 > struct trait \
     BOOST_TT_AUX_BOOL_C_BASE(C) \
 { \
+public:\
     BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
     BOOST_MPL_AUX_LAMBDA_SUPPORT(2,trait,(T1,T2)) \
 }; \
@@ -91,6 +93,7 @@ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(2,trait) \
 template<> struct trait< sp > \
     BOOST_TT_AUX_BOOL_C_BASE(C) \
 { \
+public:\
     BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
     BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(sp)) \
 }; \
@@ -100,6 +103,7 @@ template<> struct trait< sp > \
 template<> struct trait< sp1,sp2 > \
     BOOST_TT_AUX_BOOL_C_BASE(C) \
 { \
+public:\
     BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
     BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \
 }; \
@@ -108,6 +112,7 @@ template<> struct trait< sp1,sp2 > \
 #define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC1(trait,sp,C) \
 template<> struct trait##_impl< sp > \
 { \
+public:\
     BOOST_STATIC_CONSTANT(bool, value = (C)); \
 }; \
 /**/
@@ -115,6 +120,7 @@ template<> struct trait##_impl< sp > \
 #define BOOST_TT_AUX_BOOL_TRAIT_IMPL_SPEC2(trait,sp1,sp2,C) \
 template<> struct trait##_impl< sp1,sp2 > \
 { \
+public:\
     BOOST_STATIC_CONSTANT(bool, value = (C)); \
 }; \
 /**/
@@ -123,6 +129,7 @@ template<> struct trait##_impl< sp1,sp2 > \
 template< param > struct trait< sp > \
     BOOST_TT_AUX_BOOL_C_BASE(C) \
 { \
+public:\
     BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
 }; \
 /**/
@@ -131,6 +138,7 @@ template< param > struct trait< sp > \
 template< param1, param2 > struct trait< sp > \
     BOOST_TT_AUX_BOOL_C_BASE(C) \
 { \
+public:\
     BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
 }; \
 /**/
@@ -139,6 +147,7 @@ template< param1, param2 > struct trait< sp > \
 template< param > struct trait< sp1,sp2 > \
     BOOST_TT_AUX_BOOL_C_BASE(C) \
 { \
+public:\
     BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
     BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(2,trait,(sp1,sp2)) \
 }; \
@@ -148,6 +157,7 @@ template< param > struct trait< sp1,sp2 > \
 template< param1, param2 > struct trait< sp1,sp2 > \
     BOOST_TT_AUX_BOOL_C_BASE(C) \
 { \
+public:\
     BOOST_TT_AUX_BOOL_TRAIT_VALUE_DECL(C) \
 }; \
 /**/
@@ -155,6 +165,7 @@ template< param1, param2 > struct trait< sp1,sp2 > \
 #define BOOST_TT_AUX_BOOL_TRAIT_IMPL_PARTIAL_SPEC2_1(param,trait,sp1,sp2,C) \
 template< param > struct trait##_impl< sp1,sp2 > \
 { \
+public:\
     BOOST_STATIC_CONSTANT(bool, value = (C)); \
 }; \
 /**/
diff --git a/include/boost/type_traits/detail/common_type_imp.hpp b/include/boost/type_traits/detail/common_type_imp.hpp
index 59c7743..dd530ca 100644
--- a/include/boost/type_traits/detail/common_type_imp.hpp
+++ b/include/boost/type_traits/detail/common_type_imp.hpp
@@ -80,11 +80,11 @@ struct propagate_cv< const volatile From, To >
 
 template< class T >
 struct is_integral_or_enum
-    : mpl::or_< is_integral<T>, is_enum<T> >
+    : public mpl::or_< is_integral<T>, is_enum<T> >
 { };
 template<>
 struct is_integral_or_enum< bool >
-    : false_type
+    : public false_type
 { };
 
 /*******************************************************************************
@@ -97,7 +97,7 @@ struct is_integral_or_enum< bool >
 
 template< class T >
 struct make_unsigned_soft
-    : make_unsigned<T>
+    : public make_unsigned<T>
 { };
 template<>
 struct make_unsigned_soft< bool >
@@ -105,7 +105,7 @@ struct make_unsigned_soft< bool >
 
 template< class T >
 struct make_signed_soft
-    : make_signed<T>
+    : public make_signed<T>
 { };
 template<>
 struct make_signed_soft< bool >
@@ -151,7 +151,7 @@ yes_type rvalue_test(...);
 
 template< class First, class Last, std::size_t Index >
 struct conversion_test_overloads_iterate
-    : conversion_test_overloads_iterate<
+    : public conversion_test_overloads_iterate<
           typename mpl::next< First >::type, Last, Index + 1
       >
 {
@@ -168,7 +168,7 @@ struct conversion_test_overloads_iterate< Last, Last, Index >
 
 template< class Sequence >
 struct conversion_test_overloads
-    : conversion_test_overloads_iterate<
+    : public conversion_test_overloads_iterate<
           typename mpl::begin< Sequence >::type,
           typename mpl::end< Sequence >::type,
           0
@@ -187,7 +187,7 @@ template<
     int N = mpl::size< Sequence >::value
 >
 struct select
-    : mpl::at_c< Sequence, Index >
+    : public mpl::at_c< Sequence, Index >
 { };
 template< class Sequence, int N >
 struct select< Sequence, N, N >
@@ -293,7 +293,7 @@ struct nominal_candidates< T, U, V*, W*, false >
 
 template<class T, class U, bool b>
 struct common_type_dispatch_on_rvalueness
-    : deduce_common_type< T, U, typename nominal_candidates<T,U>::type >
+    : public deduce_common_type< T, U, typename nominal_candidates<T,U>::type >
 { };
 
 template< class T, class U >
@@ -316,7 +316,7 @@ public:
 
 template< class T, class U >
 struct common_type_impl
-    : common_type_dispatch_on_rvalueness<T,U, sizeof( ::boost::detail_type_traits_common_type::rvalue_test(
+    : public common_type_dispatch_on_rvalueness<T,U, sizeof( ::boost::detail_type_traits_common_type::rvalue_test(
         declval< bool >() ? declval<T>() : declval<U>() ) ) == sizeof( yes_type ) >
 { };
 
diff --git a/include/boost/type_traits/detail/cv_traits_impl.hpp b/include/boost/type_traits/detail/cv_traits_impl.hpp
index b3fa595..ed20c9d 100644
--- a/include/boost/type_traits/detail/cv_traits_impl.hpp
+++ b/include/boost/type_traits/detail/cv_traits_impl.hpp
@@ -77,7 +77,7 @@ namespace detail {
 // Use the implementation above for non function pointers
 template <typename T, unsigned Select 
   = (unsigned)sizeof(::boost::type_traits::gcc8503::mini_funcptr_tester((T)0)) >
-struct cv_traits_imp : ::boost::type_traits::gcc8503::cv_traits_imp<T> { };
+struct cv_traits_imp : public ::boost::type_traits::gcc8503::cv_traits_imp<T> { };
 
 // Functions are never cv-qualified
 template <typename T> struct cv_traits_imp<T*,1>
diff --git a/include/boost/type_traits/detail/size_t_trait_def.hpp b/include/boost/type_traits/detail/size_t_trait_def.hpp
index af479f5..ff471a0 100644
--- a/include/boost/type_traits/detail/size_t_trait_def.hpp
+++ b/include/boost/type_traits/detail/size_t_trait_def.hpp
@@ -19,10 +19,10 @@
 #include <cstddef>
 
 #if !defined(BOOST_MSVC) || BOOST_MSVC >= 1300
-#   define BOOST_TT_AUX_SIZE_T_BASE(C) ::boost::integral_constant<std::size_t,C>
+#   define BOOST_TT_AUX_SIZE_T_BASE(C) public ::boost::integral_constant<std::size_t,C>
 #   define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) /**/
 #else
-#   define BOOST_TT_AUX_SIZE_T_BASE(C) ::boost::mpl::size_t<C>
+#   define BOOST_TT_AUX_SIZE_T_BASE(C) public ::boost::mpl::size_t<C>
 #   define BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
     typedef ::boost::mpl::size_t<C> base_; \
     using base_::value; \
@@ -34,6 +34,7 @@
 template< typename T > struct trait \
     : BOOST_TT_AUX_SIZE_T_BASE(C) \
 { \
+public:\
     BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
 }; \
@@ -45,6 +46,7 @@ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
 template<> struct trait<spec> \
     : BOOST_TT_AUX_SIZE_T_BASE(C) \
 { \
+public:\
     BOOST_TT_AUX_SIZE_T_TRAIT_VALUE_DECL(C) \
     BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \
 }; \
diff --git a/include/boost/type_traits/detail/type_trait_def.hpp b/include/boost/type_traits/detail/type_trait_def.hpp
index 7438267..bc54696 100644
--- a/include/boost/type_traits/detail/type_trait_def.hpp
+++ b/include/boost/type_traits/detail/type_trait_def.hpp
@@ -17,6 +17,7 @@
 #define BOOST_TT_AUX_TYPE_TRAIT_DEF1(trait,T,result) \
 template< typename T > struct trait \
 { \
+public:\
     typedef result type; \
     BOOST_MPL_AUX_LAMBDA_SUPPORT(1,trait,(T)) \
 }; \
@@ -27,6 +28,7 @@ BOOST_TT_AUX_TEMPLATE_ARITY_SPEC(1,trait) \
 #define BOOST_TT_AUX_TYPE_TRAIT_SPEC1(trait,spec,result) \
 template<> struct trait<spec> \
 { \
+public:\
     typedef result type; \
     BOOST_MPL_AUX_LAMBDA_SUPPORT_SPEC(1,trait,(spec)) \
 }; \
@@ -35,6 +37,7 @@ template<> struct trait<spec> \
 #define BOOST_TT_AUX_TYPE_TRAIT_IMPL_SPEC1(trait,spec,result) \
 template<> struct trait##_impl<spec> \
 { \
+public:\
     typedef result type; \
 }; \
 /**/
@@ -42,6 +45,7 @@ template<> struct trait##_impl<spec> \
 #define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_1(param,trait,spec,result) \
 template< param > struct trait<spec> \
 { \
+public:\
     typedef result type; \
 }; \
 /**/
@@ -49,6 +53,7 @@ template< param > struct trait<spec> \
 #define BOOST_TT_AUX_TYPE_TRAIT_PARTIAL_SPEC1_2(param1,param2,trait,spec,result) \
 template< param1, param2 > struct trait<spec> \
 { \
+public:\
     typedef result; \
 }; \
 /**/
@@ -56,6 +61,7 @@ template< param1, param2 > struct trait<spec> \
 #define BOOST_TT_AUX_TYPE_TRAIT_IMPL_PARTIAL_SPEC1_1(param,trait,spec,result) \
 template< param > struct trait##_impl<spec> \
 { \
+public:\
     typedef result type; \
 }; \
 /**/
diff --git a/include/boost/type_traits/integral_promotion.hpp b/include/boost/type_traits/integral_promotion.hpp
index a85e243..2109b9c 100644
--- a/include/boost/type_traits/integral_promotion.hpp
+++ b/include/boost/type_traits/integral_promotion.hpp
@@ -24,14 +24,14 @@ namespace boost {
 namespace type_traits { namespace detail {
 
 // 4.5/2
-template <class T> struct need_promotion : boost::is_enum<T> {};
+template <class T> struct need_promotion : public boost::is_enum<T> {};
 
 // 4.5/1
-template<> struct need_promotion<char              > : true_type {};
-template<> struct need_promotion<signed char       > : true_type {};
-template<> struct need_promotion<unsigned char     > : true_type {};
-template<> struct need_promotion<signed short int  > : true_type {};
-template<> struct need_promotion<unsigned short int> : true_type {};
+template<> struct need_promotion<char              > : public true_type {};
+template<> struct need_promotion<signed char       > : public true_type {};
+template<> struct need_promotion<unsigned char     > : public true_type {};
+template<> struct need_promotion<signed short int  > : public true_type {};
+template<> struct need_promotion<unsigned short int> : public true_type {};
 
 
 // Specializations for non-standard types.
@@ -39,7 +39,7 @@ template<> struct need_promotion<unsigned short int> : true_type {};
 
 #define BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(T) \
     template<> struct need_promotion<T>          \
-        : integral_constant<bool, (sizeof(T) < sizeof(int))> {};
+        : public integral_constant<bool, (sizeof(T) < sizeof(int))> {};
 
 // Same set of integral types as in boost/type_traits/is_integral.hpp.
 // Please, keep in sync.
@@ -72,13 +72,13 @@ BOOST_TT_AUX_PROMOTE_NONSTANDARD_TYPE(         __int64)
 
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
 // 4.5/2
-template<> struct need_promotion<wchar_t> : true_type {};
+template<> struct need_promotion<wchar_t> : public true_type {};
 #endif
 
 // 4.5/3 (integral bit-field) is not supported.
 
 // 4.5/4
-template<> struct need_promotion<bool> : true_type {};
+template<> struct need_promotion<bool> : public true_type {};
 
 
 // Get promoted type by index and cv qualifiers.
@@ -171,7 +171,7 @@ struct integral_promotion_impl
 
 template<class T>
 struct integral_promotion
-  : boost::mpl::eval_if<
+  : public boost::mpl::eval_if<
         need_promotion<BOOST_DEDUCED_TYPENAME remove_cv<T>::type>
       , integral_promotion_impl<T>
       , boost::mpl::identity<T>
diff --git a/include/boost/type_traits/intrinsics.hpp b/include/boost/type_traits/intrinsics.hpp
index dcf5e43..6057249 100644
--- a/include/boost/type_traits/intrinsics.hpp
+++ b/include/boost/type_traits/intrinsics.hpp
@@ -129,16 +129,22 @@
 #   include <boost/type_traits/is_reference.hpp>
 #   include <boost/type_traits/is_volatile.hpp>
 
+#ifdef BOOST_INTEL
+#  define BOOST_INTEL_TT_OPTS || is_pod<T>::value
+#else
+#  define BOOST_INTEL_TT_OPTS
+#endif
+
 #   define BOOST_IS_UNION(T) __is_union(T)
 #   define BOOST_IS_POD(T) __is_pod(T)
 #   define BOOST_IS_EMPTY(T) __is_empty(T)
-#   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) (__has_trivial_constructor(T) && ! ::boost::is_volatile<T>::value)
-#   define BOOST_HAS_TRIVIAL_COPY(T) (__has_trivial_copy(T) && !is_reference<T>::value && ! ::boost::is_volatile<T>::value)
-#   define BOOST_HAS_TRIVIAL_ASSIGN(T) (__has_trivial_assign(T) && ! ::boost::is_volatile<T>::value)
-#   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) __has_trivial_destructor(T)
-#   define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) __has_nothrow_constructor(T)
-#   define BOOST_HAS_NOTHROW_COPY(T) (__has_nothrow_copy(T) && !is_volatile<T>::value && !is_reference<T>::value)
-#   define BOOST_HAS_NOTHROW_ASSIGN(T) (__has_nothrow_assign(T) && !is_volatile<T>::value)
+#   define BOOST_HAS_TRIVIAL_CONSTRUCTOR(T) ((__has_trivial_constructor(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value)
+#   define BOOST_HAS_TRIVIAL_COPY(T) ((__has_trivial_copy(T) BOOST_INTEL_TT_OPTS) && !is_reference<T>::value && ! ::boost::is_volatile<T>::value)
+#   define BOOST_HAS_TRIVIAL_ASSIGN(T) ((__has_trivial_assign(T) BOOST_INTEL_TT_OPTS) && ! ::boost::is_volatile<T>::value && ! ::boost::is_const<T>::value)
+#   define BOOST_HAS_TRIVIAL_DESTRUCTOR(T) (__has_trivial_destructor(T) BOOST_INTEL_TT_OPTS)
+#   define BOOST_HAS_NOTHROW_CONSTRUCTOR(T) (__has_nothrow_constructor(T) BOOST_INTEL_TT_OPTS)
+#   define BOOST_HAS_NOTHROW_COPY(T) ((__has_nothrow_copy(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_reference<T>::value)
+#   define BOOST_HAS_NOTHROW_ASSIGN(T) ((__has_nothrow_assign(T) BOOST_INTEL_TT_OPTS) && !is_volatile<T>::value && !is_const<T>::value)
 #   define BOOST_HAS_VIRTUAL_DESTRUCTOR(T) __has_virtual_destructor(T)
 
 #   define BOOST_IS_ABSTRACT(T) __is_abstract(T)
diff --git a/include/boost/type_traits/is_const.hpp b/include/boost/type_traits/is_const.hpp
index 99b0f36..f24b71a 100644
--- a/include/boost/type_traits/is_const.hpp
+++ b/include/boost/type_traits/is_const.hpp
@@ -106,7 +106,7 @@ no_type is_const_tester(volatile void *);
 
 template <bool is_ref, bool array>
 struct is_const_helper
-    : ::boost::type_traits::false_result
+    : public ::boost::type_traits::false_result
 {
 };
 
@@ -136,7 +136,7 @@ struct is_const_helper<false,true>
 
 template <typename T>
 struct is_const_impl
-    : is_const_helper<
+    : public is_const_helper<
           is_reference<T>::value
         , is_array<T>::value
         >::template result_<T>
diff --git a/include/boost/type_traits/is_convertible.hpp b/include/boost/type_traits/is_convertible.hpp
index e2b9b87..0d42c46 100644
--- a/include/boost/type_traits/is_convertible.hpp
+++ b/include/boost/type_traits/is_convertible.hpp
@@ -85,7 +85,7 @@ struct does_conversion_exist<void>
 
 template <typename From, typename To>
 struct is_convertible_basic_impl
-    : does_conversion_exist<From>::template result_<To>
+    : public does_conversion_exist<From>::template result_<To>
 {
 };
 
diff --git a/include/boost/type_traits/is_enum.hpp b/include/boost/type_traits/is_enum.hpp
index 86fa66d..e35548c 100644
--- a/include/boost/type_traits/is_enum.hpp
+++ b/include/boost/type_traits/is_enum.hpp
@@ -95,7 +95,7 @@ template <>
 struct is_enum_helper<false>
 {
     template <typename T> struct type
-       : ::boost::is_convertible<typename boost::add_reference<T>::type,::boost::detail::int_convertible>
+       : public ::boost::is_convertible<typename boost::add_reference<T>::type,::boost::detail::int_convertible>
     {
     };
 };
diff --git a/include/boost/type_traits/is_function.hpp b/include/boost/type_traits/is_function.hpp
index 55c05c1..2cb1bb9 100644
--- a/include/boost/type_traits/is_function.hpp
+++ b/include/boost/type_traits/is_function.hpp
@@ -40,7 +40,7 @@ namespace detail {
 #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) && !defined(BOOST_TT_TEST_MS_FUNC_SIGS)
 template<bool is_ref = true>
 struct is_function_chooser
-    : ::boost::type_traits::false_result
+    : public ::boost::type_traits::false_result
 {
 };
 
@@ -48,14 +48,14 @@ template <>
 struct is_function_chooser<false>
 {
     template< typename T > struct result_
-        : ::boost::type_traits::is_function_ptr_helper<T*>
+        : public ::boost::type_traits::is_function_ptr_helper<T*>
     {
     };
 };
 
 template <typename T>
 struct is_function_impl
-    : is_function_chooser< ::boost::is_reference<T>::value >
+    : public is_function_chooser< ::boost::is_reference<T>::value >
         ::BOOST_NESTED_TEMPLATE result_<T>
 {
 };
diff --git a/include/boost/type_traits/is_fundamental.hpp b/include/boost/type_traits/is_fundamental.hpp
index 6aff7dd..138e296 100644
--- a/include/boost/type_traits/is_fundamental.hpp
+++ b/include/boost/type_traits/is_fundamental.hpp
@@ -22,7 +22,7 @@ namespace detail {
 
 template <typename T> 
 struct is_fundamental_impl
-    : ::boost::type_traits::ice_or< 
+    : public ::boost::type_traits::ice_or< 
           ::boost::is_arithmetic<T>::value
         , ::boost::is_void<T>::value
         >
diff --git a/include/boost/type_traits/is_member_function_pointer.hpp b/include/boost/type_traits/is_member_function_pointer.hpp
index 81f1eac..38babf4 100644
--- a/include/boost/type_traits/is_member_function_pointer.hpp
+++ b/include/boost/type_traits/is_member_function_pointer.hpp
@@ -55,7 +55,7 @@ namespace detail {
 
 template <bool>
 struct is_mem_fun_pointer_select
-    : ::boost::type_traits::false_result
+    : public ::boost::type_traits::false_result
 {
 };
 
@@ -83,7 +83,7 @@ struct is_mem_fun_pointer_select<false>
 
 template <typename T>
 struct is_member_function_pointer_impl
-    : is_mem_fun_pointer_select<
+    : public is_mem_fun_pointer_select<
           ::boost::type_traits::ice_or<
               ::boost::is_reference<T>::value
             , ::boost::is_array<T>::value
diff --git a/include/boost/type_traits/is_member_pointer.hpp b/include/boost/type_traits/is_member_pointer.hpp
index ba02b89..a4a6d25 100644
--- a/include/boost/type_traits/is_member_pointer.hpp
+++ b/include/boost/type_traits/is_member_pointer.hpp
@@ -66,7 +66,7 @@ template <typename R, typename T>
 
 template <bool>
 struct is_member_pointer_select
-    : ::boost::type_traits::false_result
+    : public ::boost::type_traits::false_result
 {
 };
 
@@ -87,7 +87,7 @@ struct is_member_pointer_select<false>
 
 template <typename T>
 struct is_member_pointer_impl
-    : is_member_pointer_select<
+    : public is_member_pointer_select<
           ::boost::type_traits::ice_or<
               ::boost::is_reference<T>::value
             , ::boost::is_array<T>::value
diff --git a/include/boost/type_traits/is_pod.hpp b/include/boost/type_traits/is_pod.hpp
index 355218f..4691e66 100644
--- a/include/boost/type_traits/is_pod.hpp
+++ b/include/boost/type_traits/is_pod.hpp
@@ -49,7 +49,7 @@ template <typename T> struct is_pod_impl
 #if !defined(BOOST_NO_ARRAY_TYPE_SPECIALIZATIONS)
 template <typename T, std::size_t sz>
 struct is_pod_impl<T[sz]>
-    : is_pod_impl<T>
+    : public is_pod_impl<T>
 {
 };
 #endif
diff --git a/include/boost/type_traits/is_pointer.hpp b/include/boost/type_traits/is_pointer.hpp
index f6ecf33..4e29bb3 100644
--- a/include/boost/type_traits/is_pointer.hpp
+++ b/include/boost/type_traits/is_pointer.hpp
@@ -113,7 +113,7 @@ no_type BOOST_TT_DECL is_pointer_tester(...);
 
 template <bool>
 struct is_pointer_select
-    : ::boost::type_traits::false_result
+    : public ::boost::type_traits::false_result
 {
 };
 
@@ -133,7 +133,7 @@ struct is_pointer_select<false>
 
 template <typename T>
 struct is_pointer_impl
-    : is_pointer_select<
+    : public is_pointer_select<
           ::boost::type_traits::ice_or<
               ::boost::is_reference<T>::value
             , ::boost::is_array<T>::value
diff --git a/include/boost/type_traits/is_virtual_base_of.hpp b/include/boost/type_traits/is_virtual_base_of.hpp
index 8dcd988..ffb021e 100644
--- a/include/boost/type_traits/is_virtual_base_of.hpp
+++ b/include/boost/type_traits/is_virtual_base_of.hpp
@@ -52,14 +52,14 @@ struct is_virtual_base_of_impl<Base, Derived, mpl::true_>
        ~boost_type_traits_internal_struct_Y()throw();
     };
 #else
-    struct boost_type_traits_internal_struct_X : Derived, virtual Base 
+    struct boost_type_traits_internal_struct_X : public Derived, virtual Base 
     {
        boost_type_traits_internal_struct_X();
        boost_type_traits_internal_struct_X(const boost_type_traits_internal_struct_X&);
        boost_type_traits_internal_struct_X& operator=(const boost_type_traits_internal_struct_X&);
        ~boost_type_traits_internal_struct_X()throw();
     };
-    struct boost_type_traits_internal_struct_Y : Derived 
+    struct boost_type_traits_internal_struct_Y : public Derived 
     {
        boost_type_traits_internal_struct_Y();
        boost_type_traits_internal_struct_Y(const boost_type_traits_internal_struct_Y&);
diff --git a/include/boost/type_traits/is_volatile.hpp b/include/boost/type_traits/is_volatile.hpp
index 43c3a8b..863747d 100644
--- a/include/boost/type_traits/is_volatile.hpp
+++ b/include/boost/type_traits/is_volatile.hpp
@@ -94,7 +94,7 @@ no_type is_volatile_tester(void const*);
 
 template <bool is_ref, bool array>
 struct is_volatile_helper
-    : ::boost::type_traits::false_result
+    : public ::boost::type_traits::false_result
 {
 };
 
@@ -124,7 +124,7 @@ struct is_volatile_helper<false,true>
 
 template <typename T>
 struct is_volatile_impl
-    : is_volatile_helper<
+    : public is_volatile_helper<
           is_reference<T>::value
         , is_array<T>::value
         >::template result_<T>
diff --git a/include/boost/type_traits/msvc/typeof.hpp b/include/boost/type_traits/msvc/typeof.hpp
index ebb0e80..b95785d 100644
--- a/include/boost/type_traits/msvc/typeof.hpp
+++ b/include/boost/type_traits/msvc/typeof.hpp
@@ -20,7 +20,7 @@ namespace boost { namespace detail {
         };
 
         template<typename T, typename ID>
-        struct msvc_register_type : msvc_extract_type<ID>
+        struct msvc_register_type : public msvc_extract_type<ID>
         {
             template<>
             struct id2type_impl<true>  //VC7.0 specific bugfeature
@@ -36,7 +36,7 @@ namespace boost { namespace detail {
         };
 
         template<typename T, typename ID>
-        struct msvc_register_type : msvc_extract_type<ID>
+        struct msvc_register_type : public msvc_extract_type<ID>
         {
             typedef msvc_extract_type<ID> base_type;
             struct base_type::id2type // This uses nice VC6.5 and VC7.1 bugfeature
diff --git a/include/boost/type_traits/promote.hpp b/include/boost/type_traits/promote.hpp
index 14efad4..60f6278 100644
--- a/include/boost/type_traits/promote.hpp
+++ b/include/boost/type_traits/promote.hpp
@@ -19,7 +19,7 @@ namespace detail {
 
 template<class T>
 struct promote_impl
-  : integral_promotion<
+  : public integral_promotion<
         BOOST_DEDUCED_TYPENAME floating_point_promotion<T>::type
       >
 {
diff --git a/include/boost/type_traits/type_with_alignment.hpp b/include/boost/type_traits/type_with_alignment.hpp
index ac31055..5de3bce 100644
--- a/include/boost/type_traits/type_with_alignment.hpp
+++ b/include/boost/type_traits/type_with_alignment.hpp
@@ -86,7 +86,7 @@ struct lower_alignment_helper_impl<false>
 {
     template <std::size_t target, class TestType>
     struct apply
-      : mpl::if_c<(alignment_of<TestType>::value == target), TestType, char>
+      : public mpl::if_c<(alignment_of<TestType>::value == target), TestType, char>
     {
         enum { value = (alignment_of<TestType>::value == target) };
     };
@@ -94,7 +94,7 @@ struct lower_alignment_helper_impl<false>
 
 template <bool found, std::size_t target, class TestType>
 struct lower_alignment_helper
-  : lower_alignment_helper_impl<found>::template apply<target,TestType>
+  : public lower_alignment_helper_impl<found>::template apply<target,TestType>
 {
 };
 #else
diff --git a/test/test.hpp b/test/test.hpp
index d1facd2..6fbf156 100644
--- a/test/test.hpp
+++ b/test/test.hpp
@@ -206,7 +206,12 @@ typedef int (UDT::*cmf)(int) const;
 // on some compilers):
 //
 typedef int& r_type;
+#ifndef BOOST_INTEL
 typedef const r_type cr_type;
+#else
+// recent Intel compilers generate a hard error on the above:
+typedef r_type cr_type;
+#endif
 # ifdef BOOST_MSVC
 #  pragma warning(pop)
 # elif defined(BOOST_INTEL)