g++ 4.7 doesn't have std::is_trivially_destructible

.github/workflows/ci.yml

@@ -17,6 +17,10 @@ jobs:
       fail-fast: false
       matrix:
         include:
+          - toolset: gcc-4.7
+            cxxstd: "03,11"
+            os: ubuntu-16.04
+            install: g++-4.7
           - toolset: gcc-4.8
             cxxstd: "03,11"
             os: ubuntu-16.04

.travis.yml

@@ -1,4 +1,4 @@
-# Copyright 2016-2021 Peter Dimov
+# Copyright 2016-2019 Peter Dimov
 # Distributed under the Boost Software License, Version 1.0.
 # (See accompanying file LICENSE_1_0.txt or copy at http://boost.org/LICENSE_1_0.txt)
 
@@ -95,7 +95,7 @@ matrix:
     - os: linux
       dist: bionic
       compiler: g++-10
-      env: UBSAN=1 TOOLSET=gcc COMPILER=g++-10 CXXSTD=11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1 LINKFLAGS=-fuse-ld=gold
+      env: TOOLSET=gcc COMPILER=g++-10 CXXSTD=11,14,17,2a
       addons:
         apt:
           packages:
@@ -103,6 +103,21 @@ matrix:
           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
+      addons:
+        apt:
+          packages:
+            - g++-8
+          sources:
+            - ubuntu-toolchain-r-test
+
+    - os: linux
+      dist: trusty
+      compiler: clang++
+      env: DIST=trusty TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
+
     - os: linux
       compiler: clang++-3.5
       env: TOOLSET=clang COMPILER=clang++-3.5 CXXSTD=11,14,1z
@@ -165,7 +180,6 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      dist: bionic
       compiler: clang++-5.0
       env: TOOLSET=clang COMPILER=clang++-5.0 CXXSTD=11,14,1z
       addons:
@@ -176,7 +190,6 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      dist: bionic
       compiler: clang++-6.0
       env: TOOLSET=clang COMPILER=clang++-6.0 CXXSTD=11,14,17
       addons:
@@ -187,7 +200,6 @@ matrix:
             - ubuntu-toolchain-r-test
 
     - os: linux
-      dist: bionic
       compiler: clang++-7
       env: TOOLSET=clang COMPILER=clang++-7 CXXSTD=11,14,17,2a
       addons:
@@ -196,10 +208,9 @@ matrix:
             - clang-7
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-bionic-7
+            - llvm-toolchain-xenial-7
 
     - os: linux
-      dist: bionic
       compiler: clang++-8
       env: TOOLSET=clang COMPILER=clang++-8 CXXSTD=11,14,17,2a
       addons:
@@ -208,10 +219,10 @@ matrix:
             - clang-8
           sources:
             - ubuntu-toolchain-r-test
-            - llvm-toolchain-bionic-8
+            - llvm-toolchain-xenial-8
 
     - os: linux
-      dist: bionic
+      dist: xenial
       compiler: clang++-9
       env: TOOLSET=clang COMPILER=clang++-9 CXXSTD=11,14,17,2a
       addons:
@@ -220,11 +231,11 @@ matrix:
             - clang-9
           sources:
             - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-9 main'
+            - 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: bionic
+      dist: xenial
       compiler: clang++-10
       env: TOOLSET=clang COMPILER=clang++-10 CXXSTD=11,14,17,2a
       addons:
@@ -233,34 +244,19 @@ matrix:
             - clang-10
           sources:
             - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-10 main'
+            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-10 main'
               key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
 
     - os: linux
-      dist: bionic
-      compiler: clang++-11
-      env: TOOLSET=clang COMPILER=clang++-11 CXXSTD=11,14,17,2a
+      compiler: clang++-8
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-8 CXXSTD=11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
       addons:
         apt:
           packages:
-            - clang-11
+            - clang-8
           sources:
             - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-11 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-
-    - os: linux
-      dist: bionic
-      compiler: clang++-12
-      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-12 CXXSTD=11,14,17,2a UBSAN_OPTIONS=print_stacktrace=1
-      addons:
-        apt:
-          packages:
-            - clang-12
-          sources:
-            - ubuntu-toolchain-r-test
-            - sourceline: 'deb https://apt.llvm.org/bionic/ llvm-toolchain-bionic-12 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
+            - llvm-toolchain-xenial-8
 
     - os: linux
       dist: trusty
@@ -272,14 +268,18 @@ matrix:
             - libc++-dev
 
     - os: linux
-      dist: bionic
+      dist: trusty
       compiler: clang++-libc++
-      env: TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=11,14,17,2a
+      env: UBSAN=1 TOOLSET=clang COMPILER=clang++-libc++ CXXSTD=11,14,1z UBSAN_OPTIONS=print_stacktrace=1
       addons:
         apt:
           packages:
             - libc++-dev
 
+    - os: osx
+      compiler: clang++
+      env: TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z
+
     - os: osx
       compiler: clang++
       env: UBSAN=1 TOOLSET=clang COMPILER=clang++ CXXSTD=11,14,1z UBSAN_OPTIONS=print_stacktrace=1

appveyor.yml

@@ -20,15 +20,15 @@ environment:
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
       TOOLSET: msvc-14.1
       ADDRMD: 32,64
-      CXXSTD: 14,17,latest
+      CXXSTD: 14,17
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
       TOOLSET: clang-win
       ADDRMD: 64
-      CXXSTD: 14,17,latest
+      CXXSTD: 14,17
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
       TOOLSET: msvc-14.2
       ADDRMD: 32,64
-      CXXSTD: 14,17,latest
+      CXXSTD: 14,17
 
 install:
   - set BOOST_BRANCH=develop

doc/variant2/changelog.adoc

@@ -1,5 +1,5 @@
 ////
-Copyright 2019-2021 Peter Dimov
+Copyright 2019, 2020 Peter Dimov
 
 Distributed under the Boost Software License, Version 1.0.
 
@@ -11,10 +11,6 @@ http://www.boost.org/LICENSE_1_0.txt
 # Revision History
 :idprefix: changelog_
 
-## Changes in 1.76.0
-
-* Improved generated code for the double buffered case.
-
 ## Changes in 1.74.0
 
 * Added support for derived types in `visit`

doc/variant2/reference.adoc

@@ -490,8 +490,8 @@ template<size_t I, class... A>
 +
 Requires: :: `I < sizeof...(T)`.
 Effects:  ::
-  Initializes a new contained value as if using the expression
-  `Ti(std::forward<A>(a)...)`, then destroys the currently contained value.
+  Destroys the currently contained value, then initializes a new contained
+  value as if using the expression `Ti(std::forward<A>(a)...)`.
 Ensures:  :: `index() == I`.
 Returns:  :: A reference to the new contained value.
 Throws:   ::
@@ -511,8 +511,8 @@ template<size_t I, class V, class... A>
 +
 Requires: :: `I < sizeof...(T)`.
 Effects:  ::
-  Initializes a new contained value as if using the expression
-  `Ti(il, std::forward<A>(a)...)`, then destroys the currently contained value.
+  Destroys the currently contained value, then initializes a new contained
+  value as if using the expression `Ti(il, std::forward<A>(a)...)`.
 Ensures:  :: `index() == I`.
 Returns:  :: A reference to the new contained value.
 Throws:   ::

include/boost/variant2/variant.hpp

@@ -81,8 +81,6 @@ struct monostate
 {
 };
 
-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1940)
-
 constexpr bool operator<(monostate, monostate) noexcept { return false; }
 constexpr bool operator>(monostate, monostate) noexcept { return false; }
 constexpr bool operator<=(monostate, monostate) noexcept { return true; }
@@ -90,17 +88,6 @@ constexpr bool operator>=(monostate, monostate) noexcept { return true; }
 constexpr bool operator==(monostate, monostate) noexcept { return true; }
 constexpr bool operator!=(monostate, monostate) noexcept { return false; }
 
-#else
-
-constexpr bool operator<(monostate const&, monostate const&) noexcept { return false; }
-constexpr bool operator>(monostate const&, monostate const&) noexcept { return false; }
-constexpr bool operator<=(monostate const&, monostate const&) noexcept { return true; }
-constexpr bool operator>=(monostate const&, monostate const&) noexcept { return true; }
-constexpr bool operator==(monostate const&, monostate const&) noexcept { return true; }
-constexpr bool operator!=(monostate const&, monostate const&) noexcept { return false; }
-
-#endif
-
 // variant forward declaration
 
 template<class... T> class variant;
@@ -517,11 +504,23 @@ using std::is_trivially_move_assignable;
 
 #endif
 
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 40800
+
+template<class T> struct is_trivially_destructible: std::has_trivial_destructor<T>
+{
+};
+
+#else
+
+using std::is_trivially_destructible;
+
+#endif
+
 // variant_storage
 
 template<class D, class... T> union variant_storage_impl;
 
-template<class... T> using variant_storage = variant_storage_impl<mp11::mp_all<std::is_trivially_destructible<T>...>, T...>;
+template<class... T> using variant_storage = variant_storage_impl<mp11::mp_all<detail::is_trivially_destructible<T>...>, T...>;
 
 template<class D> union variant_storage_impl<D>
 {
@@ -533,11 +532,11 @@ template<class T1, class... T> union variant_storage_impl<mp11::mp_false, T1, T.
     T1 first_;
     variant_storage<T...> rest_;
 
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<0>, A&&... a ): first_( std::forward<A>(a)... )
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<0>, A&&... a ): first_( std::forward<A>(a)... )
     {
     }
 
-    template<std::size_t I, class... A> constexpr variant_storage_impl( mp11::mp_size_t<I>, A&&... a ): rest_( mp11::mp_size_t<I-1>(), 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-1>(), std::forward<A>(a)... )
     {
     }
 
@@ -577,18 +576,18 @@ template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, c
 
     variant_storage<T...> rest_;
 
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<0>, A&&... a ): t0_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<1>, A&&... a ): t1_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<2>, A&&... a ): t2_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<3>, A&&... a ): t3_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<4>, A&&... a ): t4_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<5>, A&&... a ): t5_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<6>, A&&... a ): t6_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<7>, A&&... a ): t7_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<8>, A&&... a ): t8_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<9>, A&&... a ): t9_( std::forward<A>(a)... ) {}
+    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 variant_storage_impl( mp11::mp_size_t<I>, A&&... a ): rest_( mp11::mp_size_t<I-10>(), 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()
     {
@@ -650,11 +649,11 @@ template<class T1, class... T> union variant_storage_impl<mp11::mp_true, T1, T..
     T1 first_;
     variant_storage<T...> rest_;
 
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<0>, A&&... a ): first_( std::forward<A>(a)... )
+    template<class... A> constexpr explicit variant_storage_impl( mp11::mp_size_t<0>, A&&... a ): first_( std::forward<A>(a)... )
     {
     }
 
-    template<std::size_t I, class... A> constexpr variant_storage_impl( mp11::mp_size_t<I>, A&&... a ): rest_( mp11::mp_size_t<I-1>(), 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-1>(), std::forward<A>(a)... )
     {
     }
 
@@ -700,18 +699,18 @@ template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, c
 
     variant_storage<T...> rest_;
 
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<0>, A&&... a ): t0_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<1>, A&&... a ): t1_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<2>, A&&... a ): t2_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<3>, A&&... a ): t3_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<4>, A&&... a ): t4_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<5>, A&&... a ): t5_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<6>, A&&... a ): t6_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<7>, A&&... a ): t7_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<8>, A&&... a ): t8_( std::forward<A>(a)... ) {}
-    template<class... A> constexpr variant_storage_impl( mp11::mp_size_t<9>, A&&... a ): t9_( std::forward<A>(a)... ) {}
+    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 variant_storage_impl( mp11::mp_size_t<I>, A&&... a ): rest_( mp11::mp_size_t<I-10>(), 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)... ); }
@@ -820,28 +819,28 @@ template<class U, class... T> using resolve_overload_index = mp11::mp_find<mp11:
 // variant_base
 
 template<bool is_trivially_destructible, bool is_single_buffered, class... T> struct variant_base_impl;
-template<class... T> using variant_base = variant_base_impl<mp11::mp_all<std::is_trivially_destructible<T>...>::value, mp11::mp_all<std::is_nothrow_move_constructible<T>...>::value, T...>;
+template<class... T> using variant_base = variant_base_impl<mp11::mp_all<detail::is_trivially_destructible<T>...>::value, mp11::mp_all<std::is_nothrow_move_constructible<T>...>::value, T...>;
 
 struct none {};
 
 // trivially destructible, single buffered
 template<class... T> struct variant_base_impl<true, true, T...>
 {
-    unsigned ix_;
-    variant_storage<none, T...> st_;
+    int ix_;
+    variant_storage<none, T...> st1_;
 
-    constexpr variant_base_impl(): ix_( 0 ), st_( mp11::mp_size_t<0>() )
+    constexpr variant_base_impl(): ix_( 0 ), st1_( mp11::mp_size_t<0>() )
     {
     }
 
-    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( I::value + 1 ), st_( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... )
+    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( I::value + 1 ), st1_( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... )
     {
     }
 
     // requires: ix_ == 0
     template<class I, class... A> void _replace( I, A&&... a )
     {
-        ::new( &st_ ) variant_storage<none, T...>( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... );
+        ::new( &st1_ ) variant_storage<none, T...>( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... );
         ix_ = I::value + 1;
     }
 
@@ -856,7 +855,7 @@ template<class... T> struct variant_base_impl<true, true, T...>
 
         assert( ix_ == J );
 
-        return st_.get( mp11::mp_size_t<J>() );
+        return st1_.get( mp11::mp_size_t<J>() );
     }
 
     template<std::size_t I> constexpr mp11::mp_at_c<variant<T...>, I> const& _get_impl( mp11::mp_size_t<I> ) const noexcept
@@ -864,14 +863,14 @@ template<class... T> struct variant_base_impl<true, true, T...>
         // size_t const J = I+1;
         // assert( ix_ == I+1 );
 
-        return st_.get( mp11::mp_size_t<I+1>() );
+        return st1_.get( mp11::mp_size_t<I+1>() );
     }
 
     template<std::size_t J, class U, class... A> BOOST_CXX14_CONSTEXPR void emplace_impl( mp11::mp_true, A&&... a )
     {
         static_assert( std::is_nothrow_constructible<U, A&&...>::value, "Logic error: U must be nothrow constructible from A&&..." );
 
-        st_.emplace( mp11::mp_size_t<J>(), std::forward<A>(a)... );
+        st1_.emplace( mp11::mp_size_t<J>(), std::forward<A>(a)... );
         ix_ = J;
     }
 
@@ -881,7 +880,7 @@ template<class... T> struct variant_base_impl<true, true, T...>
 
         U tmp( std::forward<A>(a)... );
 
-        st_.emplace( mp11::mp_size_t<J>(), std::move(tmp) );
+        st1_.emplace( mp11::mp_size_t<J>(), std::move(tmp) );
         ix_ = J;
     }
 
@@ -897,78 +896,84 @@ template<class... T> struct variant_base_impl<true, true, T...>
 // trivially destructible, double buffered
 template<class... T> struct variant_base_impl<true, false, T...>
 {
-    unsigned ix_;
-    variant_storage<none, T...> st_[ 2 ];
+    int ix_;
+    variant_storage<none, T...> st1_;
+    variant_storage<none, T...> st2_;
 
-    constexpr variant_base_impl(): ix_( 0 ), st_{ { mp11::mp_size_t<0>() }, { mp11::mp_size_t<0>() } }
+    constexpr variant_base_impl(): ix_( 0 ), st1_( mp11::mp_size_t<0>() ), st2_( mp11::mp_size_t<0>() )
     {
     }
 
-    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( ( I::value + 1 ) * 2 ), st_{ { mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... }, { mp11::mp_size_t<0>() } }
+    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( I::value + 1 ), st1_( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... ), st2_( mp11::mp_size_t<0>() )
     {
     }
 
     // requires: ix_ == 0
     template<class I, class... A> void _replace( I, A&&... a )
     {
-        ::new( &st_[ 0 ] ) variant_storage<none, T...>( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... );
-        ix_ = ( I::value + 1 ) * 2;
+        ::new( &st1_ ) variant_storage<none, T...>( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... );
+        ix_ = I::value + 1;
     }
 
     constexpr std::size_t index() const noexcept
     {
-        return ix_ / 2 - 1;
+        return ix_ >= 0? ix_ - 1: -ix_ - 1;
     }
 
     template<std::size_t I> BOOST_CXX14_CONSTEXPR mp11::mp_at_c<variant<T...>, I>& _get_impl( mp11::mp_size_t<I> ) noexcept
     {
-        assert( index() == I );
-
         size_t const J = I+1;
 
+        assert( ix_ == J || -ix_ == J );
+
         constexpr mp11::mp_size_t<J> j{};
-        return st_[ ix_ & 1 ].get( j );
+        return ix_ >= 0? st1_.get( j ): st2_.get( j );
     }
 
     template<std::size_t I> constexpr mp11::mp_at_c<variant<T...>, I> const& _get_impl( mp11::mp_size_t<I> ) const noexcept
     {
-        // assert( index() == I );
         // size_t const J = I+1;
+        // assert( ix_ == J || -ix_ == J );
         // constexpr mp_size_t<J> j{};
 
-        return st_[ ix_ & 1 ].get( mp11::mp_size_t<I+1>() );
+        return ix_ >= 0? st1_.get( mp11::mp_size_t<I+1>() ): st2_.get( mp11::mp_size_t<I+1>() );
     }
 
     template<std::size_t I, class... A> BOOST_CXX14_CONSTEXPR void emplace( A&&... a )
     {
         size_t const J = I+1;
 
-        unsigned i2 = 1 - ( ix_ & 1 );
-
-        st_[ i2 ].emplace( mp11::mp_size_t<J>(), std::forward<A>(a)... );
-
-        ix_ = J * 2 + i2;
+        if( ix_ >= 0 )
+        {
+            st2_.emplace( mp11::mp_size_t<J>(), std::forward<A>(a)... );
+            ix_ = -static_cast<int>( J );
+        }
+        else
+        {
+            st1_.emplace( mp11::mp_size_t<J>(), std::forward<A>(a)... );
+            ix_ = J;
+        }
     }
 };
 
 // not trivially destructible, single buffered
 template<class... T> struct variant_base_impl<false, true, T...>
 {
-    unsigned ix_;
-    variant_storage<none, T...> st_;
+    int ix_;
+    variant_storage<none, T...> st1_;
 
-    constexpr variant_base_impl(): ix_( 0 ), st_( mp11::mp_size_t<0>() )
+    constexpr variant_base_impl(): ix_( 0 ), st1_( mp11::mp_size_t<0>() )
     {
     }
 
-    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( I::value + 1 ), st_( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... )
+    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( I::value + 1 ), st1_( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... )
     {
     }
 
     // requires: ix_ == 0
     template<class I, class... A> void _replace( I, A&&... a )
     {
-        ::new( &st_ ) variant_storage<none, T...>( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... );
+        ::new( &st1_ ) variant_storage<none, T...>( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... );
         ix_ = I::value + 1;
     }
 
@@ -984,7 +989,7 @@ template<class... T> struct variant_base_impl<false, true, T...>
         template<class I> void operator()( I ) const noexcept
         {
             using U = mp11::mp_at<mp11::mp_list<none, T...>, I>;
-            this_->st_.get( I() ).~U();
+            this_->st1_.get( I() ).~U();
         }
     };
 
@@ -1012,7 +1017,7 @@ template<class... T> struct variant_base_impl<false, true, T...>
 
         assert( ix_ == J );
 
-        return st_.get( mp11::mp_size_t<J>() );
+        return st1_.get( mp11::mp_size_t<J>() );
     }
 
     template<std::size_t I> constexpr mp11::mp_at_c<variant<T...>, I> const& _get_impl( mp11::mp_size_t<I> ) const noexcept
@@ -1020,7 +1025,7 @@ template<class... T> struct variant_base_impl<false, true, T...>
         // size_t const J = I+1;
         // assert( ix_ == J );
 
-        return st_.get( mp11::mp_size_t<I+1>() );
+        return st1_.get( mp11::mp_size_t<I+1>() );
     }
 
     template<std::size_t I, class... A> void emplace( A&&... a )
@@ -1035,7 +1040,7 @@ template<class... T> struct variant_base_impl<false, true, T...>
 
         _destroy();
 
-        st_.emplace( mp11::mp_size_t<J>(), std::move(tmp) );
+        st1_.emplace( mp11::mp_size_t<J>(), std::move(tmp) );
         ix_ = J;
     }
 };
@@ -1043,61 +1048,23 @@ template<class... T> struct variant_base_impl<false, true, T...>
 // not trivially destructible, double buffered
 template<class... T> struct variant_base_impl<false, false, T...>
 {
-    unsigned ix_;
-
-#if defined(__GNUC__) && __GNUC__ < 11 && !defined(__clang__) && !defined(__INTEL_COMPILER)
-
-    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=63707 :-(
-
-    variant_storage<none, T...> st1_, st2_;
+    int ix_;
+    variant_storage<none, T...> st1_;
+    variant_storage<none, T...> st2_;
 
     constexpr variant_base_impl(): ix_( 0 ), st1_( mp11::mp_size_t<0>() ), st2_( mp11::mp_size_t<0>() )
     {
     }
 
-    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( ( I::value + 1 ) * 2 ), st1_( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... ), st2_( mp11::mp_size_t<0>() )
+    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( I::value + 1 ), st1_( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... ), st2_( mp11::mp_size_t<0>() )
     {
     }
 
-    BOOST_CXX14_CONSTEXPR variant_storage<none, T...>& storage( unsigned i2 ) noexcept
-    {
-        return i2 == 0? st1_: st2_;
-    }
-
-    constexpr variant_storage<none, T...> const& storage( unsigned i2 ) const noexcept
-    {
-        return i2 == 0? st1_: st2_;
-    }
-
-#else
-
-    variant_storage<none, T...> st_[ 2 ];
-
-    constexpr variant_base_impl(): ix_( 0 ), st_{ { mp11::mp_size_t<0>() }, { mp11::mp_size_t<0>() } }
-    {
-    }
-
-    template<class I, class... A> constexpr explicit variant_base_impl( I, A&&... a ): ix_( ( I::value + 1 ) * 2 ), st_{ { mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... }, { mp11::mp_size_t<0>() } }
-    {
-    }
-
-    BOOST_CXX14_CONSTEXPR variant_storage<none, T...>& storage( unsigned i2 ) noexcept
-    {
-        return st_[ i2 ];
-    }
-
-    constexpr variant_storage<none, T...> const& storage( unsigned i2 ) const noexcept
-    {
-        return st_[ i2 ];
-    }
-
-#endif
-
     // requires: ix_ == 0
     template<class I, class... A> void _replace( I, A&&... a )
     {
-        ::new( &storage( 0 ) ) variant_storage<none, T...>( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... );
-        ix_ = ( I::value + 1 ) * 2;
+        ::new( &st1_ ) variant_storage<none, T...>( mp11::mp_size_t<I::value + 1>(), std::forward<A>(a)... );
+        ix_ = I::value + 1;
     }
 
     //[&]( auto I ){
@@ -1108,18 +1075,35 @@ template<class... T> struct variant_base_impl<false, false, T...>
     struct _destroy_L1
     {
         variant_base_impl * this_;
-        unsigned i2_;
 
         template<class I> void operator()( I ) const noexcept
         {
             using U = mp11::mp_at<mp11::mp_list<none, T...>, I>;
-            this_->storage( i2_ ).get( I() ).~U();
+            this_->st1_.get( I() ).~U();
+        }
+    };
+
+    struct _destroy_L2
+    {
+        variant_base_impl * this_;
+
+        template<class I> void operator()( I ) const noexcept
+        {
+            using U = mp11::mp_at<mp11::mp_list<none, T...>, I>;
+            this_->st2_.get( I() ).~U();
         }
     };
 
     void _destroy() noexcept
     {
-        mp11::mp_with_index<1 + sizeof...(T)>( ix_ / 2, _destroy_L1{ this, ix_ & 1 } );
+        if( ix_ > 0 )
+        {
+            mp11::mp_with_index<1 + sizeof...(T)>( ix_, _destroy_L1{ this } );
+        }
+        else if( ix_ < 0 )
+        {
+            mp11::mp_with_index<1 + sizeof...(T)>( -ix_, _destroy_L2{ this } );
+        }
     }
 
     ~variant_base_impl() noexcept
@@ -1129,38 +1113,46 @@ template<class... T> struct variant_base_impl<false, false, T...>
 
     constexpr std::size_t index() const noexcept
     {
-        return ix_ / 2 - 1;
+        return ix_ >= 0? ix_ - 1: -ix_ - 1;
     }
 
     template<std::size_t I> BOOST_CXX14_CONSTEXPR mp11::mp_at_c<variant<T...>, I>& _get_impl( mp11::mp_size_t<I> ) noexcept
     {
-        assert( index() == I );
-
         size_t const J = I+1;
 
+        assert( ix_ == J || -ix_ == J );
+
         constexpr mp11::mp_size_t<J> j{};
-        return storage( ix_ & 1 ).get( j );
+        return ix_ >= 0? st1_.get( j ): st2_.get( j );
     }
 
     template<std::size_t I> constexpr mp11::mp_at_c<variant<T...>, I> const& _get_impl( mp11::mp_size_t<I> ) const noexcept
     {
-        // assert( index() == I );
         // size_t const J = I+1;
+        // assert( ix_ == J || -ix_ == J );
         // constexpr mp_size_t<J> j{};
 
-        return storage( ix_ & 1 ).get( mp11::mp_size_t<I+1>() );
+        return ix_ >= 0? st1_.get( mp11::mp_size_t<I+1>() ): st2_.get( mp11::mp_size_t<I+1>() );
     }
 
     template<std::size_t I, class... A> void emplace( A&&... a )
     {
         size_t const J = I+1;
 
-        unsigned i2 = 1 - ( ix_ & 1 );
+        if( ix_ >= 0 )
+        {
+            st2_.emplace( mp11::mp_size_t<J>(), std::forward<A>(a)... );
+            _destroy();
 
-        storage( i2 ).emplace( mp11::mp_size_t<J>(), std::forward<A>(a)... );
-        _destroy();
+            ix_ = -static_cast<int>( J );
+        }
+        else
+        {
+            st1_.emplace( mp11::mp_size_t<J>(), std::forward<A>(a)... );
+            _destroy();
 
-        ix_ = J * 2 + i2;
+            ix_ = J;
+        }
     }
 };
 
@@ -1337,7 +1329,7 @@ template<bool CopyAssignable, bool TriviallyCopyAssignable, class... T> struct v
 
 template<class... T> using variant_ca_base = variant_ca_base_impl<
     mp11::mp_all<std::is_copy_constructible<T>..., std::is_copy_assignable<T>...>::value,
-    mp11::mp_all<std::is_trivially_destructible<T>..., detail::is_trivially_copy_constructible<T>..., detail::is_trivially_copy_assignable<T>...>::value,
+    mp11::mp_all<detail::is_trivially_destructible<T>..., detail::is_trivially_copy_constructible<T>..., detail::is_trivially_copy_assignable<T>...>::value,
     T...>;
 
 template<class... T> struct variant_ca_base_impl<true, true, T...>: public variant_cc_base<T...>
@@ -1486,7 +1478,7 @@ template<bool MoveAssignable, bool TriviallyMoveAssignable, class... T> struct v
 
 template<class... T> using variant_ma_base = variant_ma_base_impl<
     mp11::mp_all<std::is_move_constructible<T>..., std::is_move_assignable<T>...>::value,
-    mp11::mp_all<std::is_trivially_destructible<T>..., detail::is_trivially_move_constructible<T>..., detail::is_trivially_move_assignable<T>...>::value,
+    mp11::mp_all<detail::is_trivially_destructible<T>..., detail::is_trivially_move_constructible<T>..., detail::is_trivially_move_assignable<T>...>::value,
     T...>;
 
 template<class... T> struct variant_ma_base_impl<true, true, T...>: public variant_mc_base<T...>
@@ -1581,7 +1573,7 @@ public:
 
     template<class U,
         class Ud = typename std::decay<U>::type,
-        class E1 = typename std::enable_if< !std::is_same<Ud, variant>::value && !std::is_base_of<variant, Ud>::value && !detail::is_in_place_index<Ud>::value && !detail::is_in_place_type<Ud>::value >::type,
+        class E1 = typename std::enable_if< !std::is_same<Ud, variant>::value && !detail::is_in_place_index<Ud>::value && !detail::is_in_place_type<Ud>::value >::type,
         class V = detail::resolve_overload_type<U&&, T...>,
         class E2 = typename std::enable_if<std::is_constructible<V, U&&>::value>::type
         >

test/Jamfile

@@ -119,5 +119,3 @@ run variant_visit_r.cpp : : :
     <toolset>gcc,<target-os>windows:<variant>release
     <toolset>gcc,<target-os>cygwin:<variant>release
     ;
-
-compile variant_derived_construct.cpp ;

test/variant_derived_construct.cpp

@@ -1,33 +0,0 @@
-// Copyright 2021 Peter Dimov.
-// Distributed under the Boost Software License, Version 1.0.
-// https://www.boost.org/LICENSE_1_0.txt
-
-#include <boost/variant2/variant.hpp>
-
-using namespace boost::variant2;
-
-template<class... T> class X: variant<T...>
-{
-    using base = variant<T...>;
-    using base::base;
-};
-
-struct Y
-{
-    Y( Y const& rhs ) = default;
-
-    template<class T> Y( T const& t )
-    {
-        t.bar();
-    }
-};
-
-int main()
-{
-    using W = X<int, double, Y>;
-
-    W a( 1 );
-    W b( a );
-
-    (void)b;
-}

test/variant_eq_ne.cpp

@@ -88,12 +88,5 @@ int main()
         BOOST_TEST_NOT( v1 != v2 );
     }
 
-    {
-        variant<monostate> v1, v2;
-
-        BOOST_TEST( v1 == v2 );
-        BOOST_TEST_NOT( v1 != v2 );
-    }
-
     return boost::report_errors();
 }

test/variant_eq_ne_cx.cpp

@@ -93,13 +93,6 @@ int main()
         STATIC_ASSERT( !(v1 == v2) );
         STATIC_ASSERT( !(v1 != v2) );
     }
-
-    {
-        constexpr variant<monostate> v1, v2;
-
-        STATIC_ASSERT( v1 == v2 );
-        STATIC_ASSERT( !(v1 != v2) );
-    }
 }
 
 #endif

test/variant_in_place_index_construct_cx.cpp

@@ -105,7 +105,7 @@ int main()
         STATIC_ASSERT( v.index() == 4 );
     }
 
-#if BOOST_WORKAROUND(BOOST_GCC, >= 100000 && BOOST_GCC < 110000)
+#if BOOST_WORKAROUND(BOOST_GCC, >= 100000 && BOOST_GCC < 100200)
 
     // no idea why this fails on g++ 10
 

test/variant_in_place_type_construct_cx.cpp

@@ -102,7 +102,7 @@ int main()
         STATIC_ASSERT( holds_alternative<X>(v) );
     }
 
-#if BOOST_WORKAROUND(BOOST_GCC, >= 100000 && BOOST_GCC < 110000)
+#if BOOST_WORKAROUND(BOOST_GCC, >= 100000 && BOOST_GCC < 100200)
 
     // no idea why this fails on g++ 10
 

test/variant_lt_gt.cpp

@@ -81,14 +81,5 @@ int main()
         BOOST_TEST_NOT( v1 >= v2 );
     }
 
-    {
-        variant<monostate> v1, v2;
-
-        BOOST_TEST_NOT( v1 < v2 );
-        BOOST_TEST_NOT( v1 > v2 );
-        BOOST_TEST( v1 <= v2 );
-        BOOST_TEST( v1 >= v2 );
-    }
-
     return boost::report_errors();
 }

test/variant_lt_gt_cx.cpp

@@ -86,15 +86,6 @@ int main()
         STATIC_ASSERT( !(v1 <= v2) );
         STATIC_ASSERT( !(v1 >= v2) );
     }
-
-    {
-        constexpr variant<monostate> v1, v2;
-
-        STATIC_ASSERT( !(v1 < v2) );
-        STATIC_ASSERT( !(v1 > v2) );
-        STATIC_ASSERT( v1 <= v2 );
-        STATIC_ASSERT( v1 >= v2 );
-    }
 }
 
 #endif