Update revision history

.travis.yml

@@ -92,6 +92,17 @@ matrix:
           sources:
             - ubuntu-toolchain-r-test
 
+    - os: linux
+      dist: bionic
+      compiler: g++-10
+      env: TOOLSET=gcc COMPILER=g++-10 CXXSTD=11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - g++-10
+          sources:
+            - ubuntu-toolchain-r-test
+
     - os: linux
       compiler: g++-8
       env: UBSAN=1 TOOLSET=gcc COMPILER=g++-8 CXXSTD=11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
@@ -223,6 +234,19 @@ matrix:
             - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
               key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
 
+    - os: linux
+      dist: xenial
+      compiler: clang++-10
+      env: TOOLSET=clang COMPILER=clang++-10 CXXSTD=11,14,17,2a
+      addons:
+        apt:
+          packages:
+            - clang-10
+          sources:
+            - ubuntu-toolchain-r-test
+            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main'
+              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+
     - os: linux
       compiler: clang++-8
       env: UBSAN=1 TOOLSET=clang COMPILER=clang++-8 CXXSTD=11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1

doc/variant2/changelog.adoc

@@ -11,6 +11,10 @@ http://www.boost.org/LICENSE_1_0.txt
 # Revision History
 :idprefix: changelog_
 
+## Changes in 1.74.0
+
+* Improve compilation performance for many (hundreds of) alternatives.
+
 ## Changes in 1.73.0
 
 * Added support for `std::hash`, `boost::hash`.

include/boost/variant2/variant.hpp

@@ -549,6 +549,88 @@ template<class T1, class... T> union variant_storage_impl<mp11::mp_false, T1, T.
     template<std::size_t I> constexpr mp11::mp_at_c<mp11::mp_list<T...>, I-1> const& get( mp11::mp_size_t<I> ) const noexcept { return rest_.get( mp11::mp_size_t<I-1>() ); }
 };
 
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class... T> union variant_storage_impl<mp11::mp_false, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T...>
+{
+    T0 t0_;
+    T1 t1_;
+    T2 t2_;
+    T3 t3_;
+    T4 t4_;
+    T5 t5_;
+    T6 t6_;
+    T7 t7_;
+    T8 t8_;
+    T9 t9_;
+
+    variant_storage<T...> rest_;
+
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<0>, A&&... a ): t0_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<1>, A&&... a ): t1_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<2>, A&&... a ): t2_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<3>, A&&... a ): t3_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<4>, A&&... a ): t4_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<5>, A&&... a ): t5_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<6>, A&&... a ): t6_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<7>, A&&... a ): t7_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<8>, A&&... a ): t8_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<9>, A&&... a ): t9_( std::forward<A>(a)... ) {}
+
+    template<std::size_t I, class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<I>, A&&... a ): rest_( mp11::mp_size_t<I-10>(), std::forward<A>(a)... ) {}
+
+    ~variant_storage_impl()
+    {
+    }
+
+    template<class... A> void emplace( mp11::mp_size_t<0>, A&&... a ) { ::new( &t0_ ) T0( std::forward<A>(a)... ); }
+    template<class... A> void emplace( mp11::mp_size_t<1>, A&&... a ) { ::new( &t1_ ) T1( std::forward<A>(a)... ); }
+    template<class... A> void emplace( mp11::mp_size_t<2>, A&&... a ) { ::new( &t2_ ) T2( std::forward<A>(a)... ); }
+    template<class... A> void emplace( mp11::mp_size_t<3>, A&&... a ) { ::new( &t3_ ) T3( std::forward<A>(a)... ); }
+    template<class... A> void emplace( mp11::mp_size_t<4>, A&&... a ) { ::new( &t4_ ) T4( std::forward<A>(a)... ); }
+    template<class... A> void emplace( mp11::mp_size_t<5>, A&&... a ) { ::new( &t5_ ) T5( std::forward<A>(a)... ); }
+    template<class... A> void emplace( mp11::mp_size_t<6>, A&&... a ) { ::new( &t6_ ) T6( std::forward<A>(a)... ); }
+    template<class... A> void emplace( mp11::mp_size_t<7>, A&&... a ) { ::new( &t7_ ) T7( std::forward<A>(a)... ); }
+    template<class... A> void emplace( mp11::mp_size_t<8>, A&&... a ) { ::new( &t8_ ) T8( std::forward<A>(a)... ); }
+    template<class... A> void emplace( mp11::mp_size_t<9>, A&&... a ) { ::new( &t9_ ) T9( std::forward<A>(a)... ); }
+
+    template<std::size_t I, class... A> void emplace( mp11::mp_size_t<I>, A&&... a )
+    {
+        rest_.emplace( mp11::mp_size_t<I-10>(), std::forward<A>(a)... );
+    }
+
+    BOOST_CXX14_CONSTEXPR T0& get( mp11::mp_size_t<0> ) noexcept { return t0_; }
+    constexpr T0 const& get( mp11::mp_size_t<0> ) const noexcept { return t0_; }
+
+    BOOST_CXX14_CONSTEXPR T1& get( mp11::mp_size_t<1> ) noexcept { return t1_; }
+    constexpr T1 const& get( mp11::mp_size_t<1> ) const noexcept { return t1_; }
+
+    BOOST_CXX14_CONSTEXPR T2& get( mp11::mp_size_t<2> ) noexcept { return t2_; }
+    constexpr T2 const& get( mp11::mp_size_t<2> ) const noexcept { return t2_; }
+
+    BOOST_CXX14_CONSTEXPR T3& get( mp11::mp_size_t<3> ) noexcept { return t3_; }
+    constexpr T3 const& get( mp11::mp_size_t<3> ) const noexcept { return t3_; }
+
+    BOOST_CXX14_CONSTEXPR T4& get( mp11::mp_size_t<4> ) noexcept { return t4_; }
+    constexpr T4 const& get( mp11::mp_size_t<4> ) const noexcept { return t4_; }
+
+    BOOST_CXX14_CONSTEXPR T5& get( mp11::mp_size_t<5> ) noexcept { return t5_; }
+    constexpr T5 const& get( mp11::mp_size_t<5> ) const noexcept { return t5_; }
+
+    BOOST_CXX14_CONSTEXPR T6& get( mp11::mp_size_t<6> ) noexcept { return t6_; }
+    constexpr T6 const& get( mp11::mp_size_t<6> ) const noexcept { return t6_; }
+
+    BOOST_CXX14_CONSTEXPR T7& get( mp11::mp_size_t<7> ) noexcept { return t7_; }
+    constexpr T7 const& get( mp11::mp_size_t<7> ) const noexcept { return t7_; }
+
+    BOOST_CXX14_CONSTEXPR T8& get( mp11::mp_size_t<8> ) noexcept { return t8_; }
+    constexpr T8 const& get( mp11::mp_size_t<8> ) const noexcept { return t8_; }
+
+    BOOST_CXX14_CONSTEXPR T9& get( mp11::mp_size_t<9> ) noexcept { return t9_; }
+    constexpr T9 const& get( mp11::mp_size_t<9> ) const noexcept { return t9_; }
+
+    template<std::size_t I> BOOST_CXX14_CONSTEXPR mp11::mp_at_c<mp11::mp_list<T...>, I-10>& get( mp11::mp_size_t<I> ) noexcept { return rest_.get( mp11::mp_size_t<I-10>() ); }
+    template<std::size_t I> constexpr mp11::mp_at_c<mp11::mp_list<T...>, I-10> const& get( mp11::mp_size_t<I> ) const noexcept { return rest_.get( mp11::mp_size_t<I-10>() ); }
+};
+
 // all trivially destructible
 template<class T1, class... T> union variant_storage_impl<mp11::mp_true, T1, T...>
 {
@@ -590,6 +672,105 @@ template<class T1, class... T> union variant_storage_impl<mp11::mp_true, T1, T..
     template<std::size_t I> constexpr mp11::mp_at_c<mp11::mp_list<T...>, I-1> const& get( mp11::mp_size_t<I> ) const noexcept { return rest_.get( mp11::mp_size_t<I-1>() ); }
 };
 
+template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class... T> union variant_storage_impl<mp11::mp_true, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T...>
+{
+    T0 t0_;
+    T1 t1_;
+    T2 t2_;
+    T3 t3_;
+    T4 t4_;
+    T5 t5_;
+    T6 t6_;
+    T7 t7_;
+    T8 t8_;
+    T9 t9_;
+
+    variant_storage<T...> rest_;
+
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<0>, A&&... a ): t0_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<1>, A&&... a ): t1_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<2>, A&&... a ): t2_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<3>, A&&... a ): t3_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<4>, A&&... a ): t4_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<5>, A&&... a ): t5_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<6>, A&&... a ): t6_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<7>, A&&... a ): t7_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<8>, A&&... a ): t8_( std::forward<A>(a)... ) {}
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<9>, A&&... a ): t9_( std::forward<A>(a)... ) {}
+
+    template<std::size_t I, class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<I>, A&&... a ): rest_( mp11::mp_size_t<I-10>(), std::forward<A>(a)... ) {}
+
+    template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<0>, A&&... a ) { ::new( &t0_ ) T0( std::forward<A>(a)... ); }
+    template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<1>, A&&... a ) { ::new( &t1_ ) T1( std::forward<A>(a)... ); }
+    template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<2>, A&&... a ) { ::new( &t2_ ) T2( std::forward<A>(a)... ); }
+    template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<3>, A&&... a ) { ::new( &t3_ ) T3( std::forward<A>(a)... ); }
+    template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<4>, A&&... a ) { ::new( &t4_ ) T4( std::forward<A>(a)... ); }
+    template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<5>, A&&... a ) { ::new( &t5_ ) T5( std::forward<A>(a)... ); }
+    template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<6>, A&&... a ) { ::new( &t6_ ) T6( std::forward<A>(a)... ); }
+    template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<7>, A&&... a ) { ::new( &t7_ ) T7( std::forward<A>(a)... ); }
+    template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<8>, A&&... a ) { ::new( &t8_ ) T8( std::forward<A>(a)... ); }
+    template<class... A> void emplace_impl( mp11::mp_false, mp11::mp_size_t<9>, A&&... a ) { ::new( &t9_ ) T9( std::forward<A>(a)... ); }
+
+    template<std::size_t I, class... A> BOOST_CXX14_CONSTEXPR void emplace_impl( mp11::mp_false, mp11::mp_size_t<I>, A&&... a )
+    {
+        rest_.emplace( mp11::mp_size_t<I-10>(), std::forward<A>(a)... );
+    }
+
+    template<std::size_t I, class... A> BOOST_CXX14_CONSTEXPR void emplace_impl( mp11::mp_true, mp11::mp_size_t<I>, A&&... a )
+    {
+        *this = variant_storage_impl( mp11::mp_size_t<I>(), std::forward<A>(a)... );
+    }
+
+    template<std::size_t I, class... A> BOOST_CXX14_CONSTEXPR void emplace( mp11::mp_size_t<I>, A&&... a )
+    {
+        this->emplace_impl( mp11::mp_all<
+            detail::is_trivially_move_assignable<T0>,
+            detail::is_trivially_move_assignable<T1>,
+            detail::is_trivially_move_assignable<T2>,
+            detail::is_trivially_move_assignable<T3>,
+            detail::is_trivially_move_assignable<T4>,
+            detail::is_trivially_move_assignable<T5>,
+            detail::is_trivially_move_assignable<T6>,
+            detail::is_trivially_move_assignable<T7>,
+            detail::is_trivially_move_assignable<T8>,
+            detail::is_trivially_move_assignable<T9>,
+            detail::is_trivially_move_assignable<T>...>(), mp11::mp_size_t<I>(), std::forward<A>(a)... );
+    }
+
+    BOOST_CXX14_CONSTEXPR T0& get( mp11::mp_size_t<0> ) noexcept { return t0_; }
+    constexpr T0 const& get( mp11::mp_size_t<0> ) const noexcept { return t0_; }
+
+    BOOST_CXX14_CONSTEXPR T1& get( mp11::mp_size_t<1> ) noexcept { return t1_; }
+    constexpr T1 const& get( mp11::mp_size_t<1> ) const noexcept { return t1_; }
+
+    BOOST_CXX14_CONSTEXPR T2& get( mp11::mp_size_t<2> ) noexcept { return t2_; }
+    constexpr T2 const& get( mp11::mp_size_t<2> ) const noexcept { return t2_; }
+
+    BOOST_CXX14_CONSTEXPR T3& get( mp11::mp_size_t<3> ) noexcept { return t3_; }
+    constexpr T3 const& get( mp11::mp_size_t<3> ) const noexcept { return t3_; }
+
+    BOOST_CXX14_CONSTEXPR T4& get( mp11::mp_size_t<4> ) noexcept { return t4_; }
+    constexpr T4 const& get( mp11::mp_size_t<4> ) const noexcept { return t4_; }
+
+    BOOST_CXX14_CONSTEXPR T5& get( mp11::mp_size_t<5> ) noexcept { return t5_; }
+    constexpr T5 const& get( mp11::mp_size_t<5> ) const noexcept { return t5_; }
+
+    BOOST_CXX14_CONSTEXPR T6& get( mp11::mp_size_t<6> ) noexcept { return t6_; }
+    constexpr T6 const& get( mp11::mp_size_t<6> ) const noexcept { return t6_; }
+
+    BOOST_CXX14_CONSTEXPR T7& get( mp11::mp_size_t<7> ) noexcept { return t7_; }
+    constexpr T7 const& get( mp11::mp_size_t<7> ) const noexcept { return t7_; }
+
+    BOOST_CXX14_CONSTEXPR T8& get( mp11::mp_size_t<8> ) noexcept { return t8_; }
+    constexpr T8 const& get( mp11::mp_size_t<8> ) const noexcept { return t8_; }
+
+    BOOST_CXX14_CONSTEXPR T9& get( mp11::mp_size_t<9> ) noexcept { return t9_; }
+    constexpr T9 const& get( mp11::mp_size_t<9> ) const noexcept { return t9_; }
+
+    template<std::size_t I> BOOST_CXX14_CONSTEXPR mp11::mp_at_c<mp11::mp_list<T...>, I-10>& get( mp11::mp_size_t<I> ) noexcept { return rest_.get( mp11::mp_size_t<I-10>() ); }
+    template<std::size_t I> constexpr mp11::mp_at_c<mp11::mp_list<T...>, I-10> const& get( mp11::mp_size_t<I> ) const noexcept { return rest_.get( mp11::mp_size_t<I-10>() ); }
+};
+
 // resolve_overload_*
 
 template<class... T> struct overload;
@@ -1768,6 +1949,25 @@ namespace detail
 
 template<class T> using remove_cv_ref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 
+template<class... T> variant<T...> const & extract_variant_base_( variant<T...> const & );
+
+#if BOOST_WORKAROUND( BOOST_MSVC, < 1930 )
+
+template<class V> struct extract_vbase_impl
+{
+    using type = decltype( extract_variant_base_( std::declval<V>() ) );
+};
+
+template<class V> using extract_variant_base = remove_cv_ref_t< typename extract_vbase_impl<V>::type >;
+
+#else
+
+template<class V> using extract_variant_base = remove_cv_ref_t< decltype( extract_variant_base_( std::declval<V>() ) ) >;
+
+#endif
+
+template<class V> using variant_base_size = variant_size< extract_variant_base<V> >;
+
 template<class T, class U> struct copy_cv_ref
 {
     using type = T;
@@ -1807,7 +2007,7 @@ template<class F> struct Qret
 
 template<class L> using front_if_same = mp11::mp_if<mp11::mp_apply<mp11::mp_same, L>, mp11::mp_front<L>>;
 
-template<class V> using apply_cv_ref = mp11::mp_product<copy_cv_ref_t, remove_cv_ref_t<V>, mp11::mp_list<V>>;
+template<class V> using apply_cv_ref = mp11::mp_product<copy_cv_ref_t, extract_variant_base<V>, mp11::mp_list<V>>;
 
 template<class F, class... V> using Vret = front_if_same<mp11::mp_product_q<Qret<F>, apply_cv_ref<V>...>>;
 
@@ -1836,7 +2036,7 @@ template<class F, class V1> struct visit_L1
 
 template<class F, class V1> constexpr auto visit( F&& f, V1&& v1 ) -> detail::Vret<F, V1>
 {
-    return mp11::mp_with_index<variant_size<V1>>( v1.index(), detail::visit_L1<F, V1>{ std::forward<F>(f), std::forward<V1>(v1) } );
+    return mp11::mp_with_index<detail::variant_base_size<V1>>( v1.index(), detail::visit_L1<F, V1>{ std::forward<F>(f), std::forward<V1>(v1) } );
 }
 
 #if defined(BOOST_NO_CXX14_GENERIC_LAMBDAS) || BOOST_WORKAROUND( BOOST_MSVC, < 1920 )
@@ -1878,7 +2078,7 @@ template<class F, class V1, class V2> struct visit_L2
 
 template<class F, class V1, class V2> constexpr auto visit( F&& f, V1&& v1, V2&& v2 ) -> detail::Vret<F, V1, V2>
 {
-    return mp11::mp_with_index<variant_size<V1>>( v1.index(), detail::visit_L2<F, V1, V2>{ std::forward<F>(f), std::forward<V1>(v1), std::forward<V2>(v2) } );
+    return mp11::mp_with_index<detail::variant_base_size<V1>>( v1.index(), detail::visit_L2<F, V1, V2>{ std::forward<F>(f), std::forward<V1>(v1), std::forward<V2>(v2) } );
 }
 
 namespace detail
@@ -1903,7 +2103,7 @@ template<class F, class V1, class V2, class V3> struct visit_L3
 
 template<class F, class V1, class V2, class V3> constexpr auto visit( F&& f, V1&& v1, V2&& v2, V3&& v3 ) -> detail::Vret<F, V1, V2, V3>
 {
-    return mp11::mp_with_index<variant_size<V1>>( v1.index(), detail::visit_L3<F, V1, V2, V3>{ std::forward<F>(f), std::forward<V1>(v1), std::forward<V2>(v2), std::forward<V3>(v3) } );
+    return mp11::mp_with_index<detail::variant_base_size<V1>>( v1.index(), detail::visit_L3<F, V1, V2, V3>{ std::forward<F>(f), std::forward<V1>(v1), std::forward<V2>(v2), std::forward<V3>(v3) } );
 }
 
 namespace detail
@@ -1929,14 +2129,14 @@ template<class F, class V1, class V2, class V3, class V4> struct visit_L4
 
 template<class F, class V1, class V2, class V3, class V4> constexpr auto visit( F&& f, V1&& v1, V2&& v2, V3&& v3, V4&& v4 ) -> detail::Vret<F, V1, V2, V3, V4>
 {
-    return mp11::mp_with_index<variant_size<V1>>( v1.index(), detail::visit_L4<F, V1, V2, V3, V4>{ std::forward<F>(f), std::forward<V1>(v1), std::forward<V2>(v2), std::forward<V3>(v3), std::forward<V4>(v4) } );
+    return mp11::mp_with_index<detail::variant_base_size<V1>>( v1.index(), detail::visit_L4<F, V1, V2, V3, V4>{ std::forward<F>(f), std::forward<V1>(v1), std::forward<V2>(v2), std::forward<V3>(v3), std::forward<V4>(v4) } );
 }
 
 #else
 
 template<class F, class V1, class V2, class... V> constexpr auto visit( F&& f, V1&& v1, V2&& v2, V&&... v ) -> detail::Vret<F, V1, V2, V...>
 {
-    return mp11::mp_with_index<variant_size<V1>>( v1.index(), [&]( auto I ){
+    return mp11::mp_with_index<detail::variant_base_size<V1>>( v1.index(), [&]( auto I ){
 
         auto f2 = [&]( auto&&... a ){ return std::forward<F>(f)( detail::unsafe_get<I.value>( std::forward<V1>(v1) ), std::forward<decltype(a)>(a)... ); };
         return visit( f2, std::forward<V2>(v2), std::forward<V>(v)... );

test/Jamfile

@@ -110,3 +110,7 @@ run variant_hash.cpp ;
 
 run variant_trivial.cpp ;
 run variant_special.cpp ;
+
+run variant_visit_derived.cpp ;
+
+run variant_many_types.cpp ;

test/variant_get_by_index.cpp

@@ -6,6 +6,12 @@
 // See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt
 
+#if defined( __clang__ ) && defined( __has_warning )
+# if __has_warning( "-Wdeprecated-volatile" )
+#  pragma clang diagnostic ignored "-Wdeprecated-volatile"
+# endif
+#endif
+
 #include <boost/variant2/variant.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/core/lightweight_test_trait.hpp>

test/variant_get_by_type.cpp

@@ -6,6 +6,12 @@
 // See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt
 
+#if defined( __clang__ ) && defined( __has_warning )
+# if __has_warning( "-Wdeprecated-volatile" )
+#  pragma clang diagnostic ignored "-Wdeprecated-volatile"
+# endif
+#endif
+
 #include <boost/variant2/variant.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/core/lightweight_test_trait.hpp>

test/variant_in_place_index_construct_cx.cpp

@@ -7,11 +7,8 @@
 // http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/variant2/variant.hpp>
-#include <boost/core/lightweight_test.hpp>
-#include <boost/core/lightweight_test_trait.hpp>
-#include <type_traits>
-#include <utility>
-#include <string>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
 
 using namespace boost::variant2;
 
@@ -108,9 +105,17 @@ int main()
         STATIC_ASSERT( v.index() == 4 );
     }
 
+#if BOOST_WORKAROUND(BOOST_GCC, >= 100000 && BOOST_GCC < 100200)
+
+    // no idea why this fails on g++ 10
+
+#else
+
     {
         constexpr variant<int, int, float, float, X, X> v( in_place_index_t<5>{}, 0, 0 );
 
         STATIC_ASSERT( v.index() == 5 );
     }
+
+#endif
 }

test/variant_in_place_type_construct_cx.cpp

@@ -7,6 +7,8 @@
 // http://www.boost.org/LICENSE_1_0.txt
 
 #include <boost/variant2/variant.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
 
 using namespace boost::variant2;
 
@@ -100,6 +102,12 @@ int main()
         STATIC_ASSERT( holds_alternative<X>(v) );
     }
 
+#if BOOST_WORKAROUND(BOOST_GCC, >= 100000 && BOOST_GCC < 100200)
+
+    // no idea why this fails on g++ 10
+
+#else
+
     {
         constexpr variant<int, int, float, float, X> v( in_place_type_t<X>{}, 0, 0 );
 
@@ -107,4 +115,6 @@ int main()
 
         STATIC_ASSERT( holds_alternative<X>(v) );
     }
+
+#endif
 }

test/variant_many_types.cpp

@@ -0,0 +1,109 @@
+
+// Copyright 2020 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(_MSC_VER)
+# pragma warning( disable: 4503 ) // decorated name length exceeded
+#endif
+
+#include <boost/variant2/variant.hpp>
+#include <boost/mp11.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::mp11;
+
+template<class I> struct X
+{
+    static int const value = I::value;
+    int v_;
+};
+
+template<class I> int const X<I>::value;
+
+template<class I> struct Y
+{
+    static int const value = I::value;
+    int v_;
+
+    Y() = default;
+    Y( Y const& ) = default;
+
+    explicit Y( int v ): v_( v ) {}
+
+    Y& operator=( Y const& ) noexcept = default;
+
+    Y& operator=( Y&& r ) noexcept
+    {
+        v_ = r.v_;
+        return *this;
+    }
+};
+
+template<class I> int const Y<I>::value;
+
+template<class I> struct Z
+{
+    static int const value = I::value;
+    int v_;
+
+    ~Z() {}
+};
+
+template<class I> int const Z<I>::value;
+
+template<class V> struct F1
+{
+    template<class T> void operator()( T ) const
+    {
+        int const i = T::value;
+
+        T t{ i * 2 };
+
+        using boost::variant2::get;
+
+        {
+            V v( t );
+
+            BOOST_TEST_EQ( v.index(), i );
+            BOOST_TEST_EQ( get<i>( v ).v_, t.v_ );
+            BOOST_TEST_EQ( get<T>( v ).v_, t.v_ );
+        }
+
+        {
+            V const v( t );
+
+            BOOST_TEST_EQ( v.index(), i );
+            BOOST_TEST_EQ( get<i>( v ).v_, t.v_ );
+            BOOST_TEST_EQ( get<T>( v ).v_, t.v_ );
+        }
+
+        {
+            V v;
+
+            v = t;
+
+            BOOST_TEST_EQ( v.index(), i );
+            BOOST_TEST_EQ( get<i>( v ).v_, t.v_ );
+            BOOST_TEST_EQ( get<T>( v ).v_, t.v_ );
+        }
+    }
+};
+
+template<class V> void test()
+{
+    mp_for_each<V>( F1<V>() );
+}
+
+int main()
+{
+    int const N = 32;
+
+    using V = mp_rename<mp_iota_c<N>, boost::variant2::variant>;
+
+    test< mp_transform<X, V> >();
+    test< mp_transform<Y, V> >();
+    test< mp_transform<Z, V> >();
+
+    return boost::report_errors();
+}

test/variant_visit_derived.cpp

@@ -0,0 +1,57 @@
+
+// Copyright 2017, 2020 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(_MSC_VER)
+# pragma warning( disable: 4244 ) // conversion from float to int, possible loss of data
+#endif
+
+#include <boost/variant2/variant.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+#include <utility>
+
+struct X: boost::variant2::variant<int, float>
+{
+#if BOOST_WORKAROUND( BOOST_MSVC, < 1930 )
+
+    template<class T> explicit X( T&& t ): variant( std::forward<T>( t ) ) {};
+
+#else
+
+    using variant::variant;
+
+#endif
+};
+
+template<class... T> struct Y: boost::variant2::variant<T...>
+{
+    using boost::variant2::variant<T...>::variant;
+};
+
+int main()
+{
+    {
+        X v1( 1 );
+        X const v2( 3.14f );
+
+        BOOST_TEST_EQ( (visit( []( int x1, float x2 ){ return (int)(x1 * 1000) + (int)(x2 * 100); }, v1, v2 )), 1314 );
+
+        visit( []( int x1, float x2 ){ BOOST_TEST_EQ( x1, 1 ); BOOST_TEST_EQ( x2, 3.14f ); }, v1, v2 );
+        visit( []( int x1, float x2 ){ BOOST_TEST_EQ( x1, 1 ); BOOST_TEST_EQ( x2, 3.14f ); }, std::move(v1), std::move(v2) );
+    }
+
+    {
+        Y<int, float> v1( 1 );
+        Y<int, float> const v2( 3.14f );
+
+        BOOST_TEST_EQ( (visit( []( int x1, float x2 ){ return (int)(x1 * 1000) + (int)(x2 * 100); }, v1, v2 )), 1314 );
+
+        visit( []( int x1, float x2 ){ BOOST_TEST_EQ( x1, 1 ); BOOST_TEST_EQ( x2, 3.14f ); }, v1, v2 );
+        visit( []( int x1, float x2 ){ BOOST_TEST_EQ( x1, 1 ); BOOST_TEST_EQ( x2, 3.14f ); }, std::move(v1), std::move(v2) );
+    }
+
+    return boost::report_errors();
+}