From 0997734e5cfd1ae083d706b88af8d640f227b46f Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Fri, 9 Jun 2017 02:05:34 +0300
Subject: [PATCH 01/13] Make emplace constexpr

---
 include/boost/variant2/variant.hpp | 73 +++++++++++++++++---------
 test/Jamfile                       |  2 +
 test/variant_emplace_index_cx.cpp  | 83 ++++++++++++++++++++++++++++++
 test/variant_emplace_type_cx.cpp   | 63 +++++++++++++++++++++++
 4 files changed, 196 insertions(+), 25 deletions(-)
 create mode 100644 test/variant_emplace_index_cx.cpp
 create mode 100644 test/variant_emplace_type_cx.cpp

diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
index 4a0937c..ee457c9 100644
--- a/include/boost/variant2/variant.hpp
+++ b/include/boost/variant2/variant.hpp
@@ -342,12 +342,22 @@ template<class T1, class... T> union variant_storage_impl<mp_true, T1, T...>
     {
     }
 
-    template<class... A> void emplace( mp_size_t<0>, A&&... a ) noexcept
+    template<class... A> void emplace_impl( mp_false, A&&... a ) noexcept
     {
         ::new( &first_ ) T1( std::forward<A>(a)... );
     }
 
-    template<std::size_t I, class... A> void emplace( mp_size_t<I>, A&&... a ) noexcept
+    template<class... A> constexpr void emplace_impl( mp_true, A&&... a ) noexcept
+    {
+        *this = variant_storage_impl( mp_size_t<0>(), std::forward<A>(a)... );
+    }
+
+    template<class... A> constexpr void emplace( mp_size_t<0>, A&&... a ) noexcept
+    {
+        this->emplace_impl( mp_all<std::is_trivially_move_assignable<T1>, std::is_trivially_move_assignable<T>...>(), std::forward<A>(a)... );
+    }
+
+    template<std::size_t I, class... A> constexpr void emplace( mp_size_t<I>, A&&... a ) noexcept
     {
         rest_.emplace( mp_size_t<I-1>(), std::forward<A>(a)... );
     }
@@ -436,20 +446,25 @@ template<class... T> struct variant_base_impl<true, true, T...>
         return st1_.get( mp_size_t<J>() );
     }
 
-    template<std::size_t I, class... A> void emplace( A&&... a )
+    template<std::size_t J, class U, bool B, class... A> constexpr void emplace_impl( mp_true, mp_bool<B>, A&&... a )
     {
-        std::size_t const J = I+1;
+        st1_.emplace( mp_size_t<J>(), std::forward<A>(a)... );
+        ix_ = J;
+    }
 
+    template<std::size_t J, class U, class... A> constexpr void emplace_impl( mp_false, mp_true, A&&... a )
+    {
+        U tmp( std::forward<A>(a)... );
+
+        st1_.emplace( mp_size_t<J>(), std::move(tmp) );
+        ix_ = J;
+    }
+
+    template<std::size_t J, class U, class... A> void emplace_impl( mp_false, mp_false, A&&... a )
+    {
         std::size_t const K = mp_find_if<mp_list<T...>, std::is_nothrow_constructible>::value;
 
-        using U = mp_at_c<variant<T...>, I>;
-
-        if( std::is_nothrow_constructible<U, A...>::value )
-        {
-            st1_.emplace( mp_size_t<J>(), std::forward<A>(a)... );
-            ix_ = J;
-        }
-        else if( K < sizeof...(T) ) // have nothrow destructible
+        if( K < sizeof...(T) ) // have nothrow destructible
         {
             try
             {
@@ -458,8 +473,8 @@ template<class... T> struct variant_base_impl<true, true, T...>
             }
             catch( ... )
             {
-                st1_.emplace( mp_size_t<K>() );
-                ix_ = K;
+                st1_.emplace( mp_size_t<K+1>() );
+                ix_ = K+1;
 
                 throw;
             }
@@ -474,6 +489,14 @@ template<class... T> struct variant_base_impl<true, true, T...>
             ix_ = J;
         }
     }
+
+    template<std::size_t I, class... A> constexpr void emplace( A&&... a )
+    {
+        std::size_t const J = I+1;
+        using U = mp_at_c<variant<T...>, I>;
+
+        this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<std::is_trivially_move_constructible<U>, std::is_trivially_move_assignable<T>...>(), std::forward<A>(a)... );
+    }
 };
 
 // trivially destructible, double buffered
@@ -516,7 +539,7 @@ template<class... T> struct variant_base_impl<true, false, T...>
         return ix_ >= 0? st1_.get( j ): st2_.get( j );
     }
 
-    template<std::size_t I, class... A> void emplace( A&&... a )
+    template<std::size_t I, class... A> constexpr void emplace( A&&... a )
     {
         size_t const J = I+1;
 
@@ -830,7 +853,7 @@ public:
     }
 
     template<class E1 = void, class E2 = mp_if<mp_all<std::is_copy_constructible<T>...>, E1>>
-    variant( variant const& r )
+    constexpr variant( variant const& r )
         noexcept( mp_all<std::is_nothrow_copy_constructible<T>...>::value )
     {
         mp_with_index<sizeof...(T)>( r.index(), [&]( auto I ){
@@ -841,7 +864,7 @@ public:
     }
 
     template<class E1 = void, class E2 = mp_if<mp_all<std::is_move_constructible<T>...>, E1>>
-    variant( variant && r )
+    constexpr variant( variant && r )
         noexcept( mp_all<std::is_nothrow_move_constructible<T>...>::value )
     {
         mp_with_index<sizeof...(T)>( r.index(), [&]( auto I ){
@@ -885,7 +908,7 @@ public:
 
     // assignment
     template<class E1 = void, class E2 = mp_if<mp_all<std::is_copy_constructible<T>..., std::is_copy_assignable<T>...>, E1>>
-    variant& operator=( variant const & r )
+    constexpr variant& operator=( variant const & r )
         noexcept( mp_all<std::is_nothrow_copy_constructible<T>..., std::is_nothrow_copy_assignable<T>...>::value )
     {
         mp_with_index<sizeof...(T)>( r.index(), [&]( auto I ){
@@ -905,7 +928,7 @@ public:
     }
 
     template<class E1 = void, class E2 = mp_if<mp_all<std::is_move_constructible<T>..., std::is_move_assignable<T>...>, E1>>
-    variant& operator=( variant && r )
+    constexpr variant& operator=( variant && r )
         noexcept( mp_all<std::is_nothrow_move_constructible<T>..., std::is_nothrow_move_assignable<T>...>::value )
     {
         mp_with_index<sizeof...(T)>( r.index(), [&]( auto I ){
@@ -929,7 +952,7 @@ public:
         class V = variant2::detail::resolve_overload_type<U, T...>,
         class E2 = std::enable_if_t<std::is_assignable<V&, U>::value && std::is_constructible<V, U>::value>
     >
-    variant& operator=( U&& u )
+    constexpr variant& operator=( U&& u )
         noexcept( std::is_nothrow_assignable<V&, U>::value && std::is_nothrow_constructible<V, U>::value )
     {
         std::size_t const I = variant2::detail::resolve_overload_index<U, T...>::value;
@@ -949,28 +972,28 @@ public:
     // modifiers
 
     template<class U, class... A, class I = mp_find<variant<T...>, U>, class E = std::enable_if_t<std::is_constructible<U, A...>::value>>
-    U& emplace( A&&... a )
+    constexpr U& emplace( A&&... a )
     {
         variant_base::template emplace<I::value>( std::forward<A>(a)... );
         return _get_impl( I() );
     }
 
     template<class U, class V, class... A, class I = mp_find<variant<T...>, U>, class E = std::enable_if_t<std::is_constructible<U, std::initializer_list<V>&, A...>::value>>
-    U& emplace( std::initializer_list<V> il, A&&... a )
+    constexpr U& emplace( std::initializer_list<V> il, A&&... a )
     {
         variant_base::template emplace<I::value>( il, std::forward<A>(a)... );
         return _get_impl( I() );
     }
 
     template<std::size_t I, class... A, class E = std::enable_if_t<std::is_constructible<mp_at_c<variant<T...>, I>, A...>::value>>
-    variant_alternative_t<I, variant<T...>>& emplace( A&&... a )
+    constexpr variant_alternative_t<I, variant<T...>>& emplace( A&&... a )
     {
         variant_base::template emplace<I>( std::forward<A>(a)... );
         return _get_impl( mp_size_t<I>() );
     }
 
     template<std::size_t I, class V, class... A, class E = std::enable_if_t<std::is_constructible<mp_at_c<variant<T...>, I>, std::initializer_list<V>&, A...>::value>>
-    variant_alternative_t<I, variant<T...>>& emplace( std::initializer_list<V> il, A&&... a )
+    constexpr variant_alternative_t<I, variant<T...>>& emplace( std::initializer_list<V> il, A&&... a )
     {
         variant_base::template emplace<I>( il, std::forward<A>(a)... );
         return _get_impl( mp_size_t<I>() );
@@ -1044,7 +1067,7 @@ public:
 
 private:
 
-    template<class... U, class V, std::size_t J, class E = std::enable_if_t<J != sizeof...(U)>> static variant<U...> _subset_impl( mp_size_t<J>, V && v )
+    template<class... U, class V, std::size_t J, class E = std::enable_if_t<J != sizeof...(U)>> static constexpr variant<U...> _subset_impl( mp_size_t<J>, V && v )
     {
         return variant<U...>( in_place_index<J>, std::forward<V>(v) );
     }
diff --git a/test/Jamfile b/test/Jamfile
index c11eef5..b9ad29b 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -33,7 +33,9 @@ run variant_copy_assign.cpp : : : $(REQ) ;
 run variant_move_assign.cpp : : : $(REQ) ;
 run variant_value_assign.cpp : : : $(REQ) ;
 run variant_emplace_index.cpp : : : $(REQ) ;
+compile variant_emplace_index_cx.cpp : : : $(REQ) ;
 run variant_emplace_type.cpp : : : $(REQ) ;
+compile variant_emplace_type_cx.cpp : : : $(REQ) ;
 run variant_swap.cpp : : : $(REQ) ;
 run variant_eq_ne.cpp : : : $(REQ) ;
 run variant_destroy.cpp : : : $(REQ) ;
diff --git a/test/variant_emplace_index_cx.cpp b/test/variant_emplace_index_cx.cpp
new file mode 100644
index 0000000..3a5d73d
--- /dev/null
+++ b/test/variant_emplace_index_cx.cpp
@@ -0,0 +1,83 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+
+using namespace boost::variant2;
+
+struct X
+{
+    int v;
+    constexpr X(): v( 0 ) {}
+    constexpr explicit X( int v ): v( v ) {}
+	constexpr operator int() const { return v; }
+};
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+template<class V, std::size_t I, class A> constexpr A test( A const& a )
+{
+    V v;
+
+    v.template emplace<I>( a );
+
+    return get<I>(v);
+}
+
+int main()
+{
+    {
+        constexpr auto w = test<variant<int>, 0>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<X>, 0>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, float>, 0>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, float>, 1>( 3.0f );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, X, X>, 0>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, X, X>, 1>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, X, X>, 2>( 2.0f );
+        STATIC_ASSERT( w == 2.0f );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, X, X>, 3>( 3.0f );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, X, X>, 4>( 4 );
+        STATIC_ASSERT( w == 4 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, X, X>, 5>( 5 );
+        STATIC_ASSERT( w == 5 );
+    }
+}
diff --git a/test/variant_emplace_type_cx.cpp b/test/variant_emplace_type_cx.cpp
new file mode 100644
index 0000000..4162484
--- /dev/null
+++ b/test/variant_emplace_type_cx.cpp
@@ -0,0 +1,63 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+
+using namespace boost::variant2;
+
+struct X
+{
+    int v;
+    constexpr X(): v( 0 ) {}
+    constexpr explicit X( int v ): v( v ) {}
+    constexpr operator int() const { return v; }
+};
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+template<class V, class T, class A> constexpr A test( A const& a )
+{
+    V v;
+
+    v.template emplace<T>( a );
+
+    return get<T>(v);
+}
+
+int main()
+{
+    {
+        constexpr auto w = test<variant<int>, int>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<X>, X>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, float>, int>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, float>, float>( 3.0f );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float>, float>( 3.0f );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, X>, X>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+}

From 613d411396acdd86cf6bdc7c3edc8a7fcde8d7ff Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Fri, 9 Jun 2017 02:27:02 +0300
Subject: [PATCH 02/13] Fix constexpr emplace on clang and msvc-14.1

---
 include/boost/variant2/variant.hpp | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
index ee457c9..c9c0d48 100644
--- a/include/boost/variant2/variant.hpp
+++ b/include/boost/variant2/variant.hpp
@@ -311,12 +311,12 @@ template<class T1, class... T> union variant_storage_impl<mp_false, T1, T...>
     {
     }
 
-    template<class... A> void emplace( mp_size_t<0>, A&&... a ) noexcept
+    template<class... A> void emplace( mp_size_t<0>, A&&... a )
     {
         ::new( &first_ ) T1( std::forward<A>(a)... );
     }
 
-    template<std::size_t I, class... A> void emplace( mp_size_t<I>, A&&... a ) noexcept
+    template<std::size_t I, class... A> void emplace( mp_size_t<I>, A&&... a )
     {
         rest_.emplace( mp_size_t<I-1>(), std::forward<A>(a)... );
     }
@@ -342,26 +342,26 @@ template<class T1, class... T> union variant_storage_impl<mp_true, T1, T...>
     {
     }
 
-    template<class... A> void emplace_impl( mp_false, A&&... a ) noexcept
+    template<class... A> void emplace_impl( mp_false, mp_size_t<0>, A&&... a )
     {
         ::new( &first_ ) T1( std::forward<A>(a)... );
     }
 
-    template<class... A> constexpr void emplace_impl( mp_true, A&&... a ) noexcept
-    {
-        *this = variant_storage_impl( mp_size_t<0>(), std::forward<A>(a)... );
-    }
-
-    template<class... A> constexpr void emplace( mp_size_t<0>, A&&... a ) noexcept
-    {
-        this->emplace_impl( mp_all<std::is_trivially_move_assignable<T1>, std::is_trivially_move_assignable<T>...>(), std::forward<A>(a)... );
-    }
-
-    template<std::size_t I, class... A> constexpr void emplace( mp_size_t<I>, A&&... a ) noexcept
+    template<std::size_t I, class... A> constexpr void emplace_impl( mp_false, mp_size_t<I>, A&&... a )
     {
         rest_.emplace( mp_size_t<I-1>(), std::forward<A>(a)... );
     }
 
+    template<std::size_t I, class... A> constexpr void emplace_impl( mp_true, mp_size_t<I>, A&&... a ) noexcept
+    {
+        *this = variant_storage_impl( mp_size_t<I>(), std::forward<A>(a)... );
+    }
+
+    template<std::size_t I, class... A> constexpr void emplace( mp_size_t<I>, A&&... a )
+    {
+        this->emplace_impl( mp_all<std::is_trivially_move_assignable<T1>, std::is_trivially_move_assignable<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
+    }
+
     constexpr T1& get( mp_size_t<0> ) noexcept { return first_; }
     constexpr T1 const& get( mp_size_t<0> ) const noexcept { return first_; }
 

From 893cd7c1e556a37809623fe14a327a7fb2cc9365 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Fri, 9 Jun 2017 03:22:31 +0300
Subject: [PATCH 03/13] Add workaround for libstdc++ < 5

---
 include/boost/variant2/variant.hpp | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
index c9c0d48..a7df153 100644
--- a/include/boost/variant2/variant.hpp
+++ b/include/boost/variant2/variant.hpp
@@ -359,7 +359,15 @@ template<class T1, class... T> union variant_storage_impl<mp_true, T1, T...>
 
     template<std::size_t I, class... A> constexpr void emplace( mp_size_t<I>, A&&... a )
     {
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+
+        this->emplace_impl( mp_all<std::has_trivial_move_assign<T1>, std::has_trivial_move_assign<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
+
+#else
+
         this->emplace_impl( mp_all<std::is_trivially_move_assignable<T1>, std::is_trivially_move_assignable<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
+
+#endif
     }
 
     constexpr T1& get( mp_size_t<0> ) noexcept { return first_; }
@@ -495,7 +503,15 @@ template<class... T> struct variant_base_impl<true, true, T...>
         std::size_t const J = I+1;
         using U = mp_at_c<variant<T...>, I>;
 
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+
+        this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<std::has_trivial_move_constructor<U>, std::has_trivial_move_assign<T>...>(), std::forward<A>(a)... );
+
+#else
+
         this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<std::is_trivially_move_constructible<U>, std::is_trivially_move_assignable<T>...>(), std::forward<A>(a)... );
+
+#endif
     }
 };
 

From 7c00db06002b9b17f507adcb38fa8192fb7c3cb3 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Fri, 9 Jun 2017 03:44:02 +0300
Subject: [PATCH 04/13] has_trivial_move doesn't exist either in libstd++ pre-5

---
 include/boost/variant2/variant.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
index a7df153..5ddda9b 100644
--- a/include/boost/variant2/variant.hpp
+++ b/include/boost/variant2/variant.hpp
@@ -361,7 +361,7 @@ template<class T1, class... T> union variant_storage_impl<mp_true, T1, T...>
     {
 #if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
 
-        this->emplace_impl( mp_all<std::has_trivial_move_assign<T1>, std::has_trivial_move_assign<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
+        this->emplace_impl( mp_all<std::has_trivial_copy_assign<T1>, std::has_trivial_copy_assign<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
 
 #else
 
@@ -505,7 +505,7 @@ template<class... T> struct variant_base_impl<true, true, T...>
 
 #if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
 
-        this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<std::has_trivial_move_constructor<U>, std::has_trivial_move_assign<T>...>(), std::forward<A>(a)... );
+        this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<std::has_trivial_copy_constructor<U>, std::has_trivial_copy_assign<T>...>(), std::forward<A>(a)... );
 
 #else
 

From 3c18ded3aabb8a7d259e21529e89108eae123cb7 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Fri, 9 Jun 2017 04:17:06 +0300
Subject: [PATCH 05/13] Check is_move_constructible, is_move_assignable

---
 include/boost/variant2/variant.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
index 5ddda9b..e1c715b 100644
--- a/include/boost/variant2/variant.hpp
+++ b/include/boost/variant2/variant.hpp
@@ -361,7 +361,7 @@ template<class T1, class... T> union variant_storage_impl<mp_true, T1, T...>
     {
 #if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
 
-        this->emplace_impl( mp_all<std::has_trivial_copy_assign<T1>, std::has_trivial_copy_assign<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
+        this->emplace_impl( mp_all<std::has_trivial_copy_assign<T1>, std::is_move_assignable<T1>, std::has_trivial_copy_assign<T>..., std::is_move_assignable<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
 
 #else
 
@@ -505,7 +505,7 @@ template<class... T> struct variant_base_impl<true, true, T...>
 
 #if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
 
-        this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<std::has_trivial_copy_constructor<U>, std::has_trivial_copy_assign<T>...>(), std::forward<A>(a)... );
+        this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<std::has_trivial_copy_constructor<U>, std::is_move_constructible<U>, std::has_trivial_copy_assign<T>..., std::is_move_assignable<T>...>(), std::forward<A>(a)... );
 
 #else
 

From 3a198b5f2b9097346a857d5590db043dd5695d77 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Fri, 9 Jun 2017 04:31:59 +0300
Subject: [PATCH 06/13] Use is_trivially_copyable instead of has_trivial_copy_*

---
 include/boost/variant2/variant.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
index e1c715b..7c50317 100644
--- a/include/boost/variant2/variant.hpp
+++ b/include/boost/variant2/variant.hpp
@@ -361,7 +361,7 @@ template<class T1, class... T> union variant_storage_impl<mp_true, T1, T...>
     {
 #if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
 
-        this->emplace_impl( mp_all<std::has_trivial_copy_assign<T1>, std::is_move_assignable<T1>, std::has_trivial_copy_assign<T>..., std::is_move_assignable<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
+        this->emplace_impl( mp_all<std::is_move_assignable<T1>, std::is_trivially_copyable<T1>, std::is_move_assignable<T>..., std::is_trivially_copyable<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
 
 #else
 
@@ -505,7 +505,7 @@ template<class... T> struct variant_base_impl<true, true, T...>
 
 #if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
 
-        this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<std::has_trivial_copy_constructor<U>, std::is_move_constructible<U>, std::has_trivial_copy_assign<T>..., std::is_move_assignable<T>...>(), std::forward<A>(a)... );
+        this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<std::is_move_constructible<U>, std::is_move_assignable<T>..., std::is_trivially_copyable<T>...>(), std::forward<A>(a)... );
 
 #else
 

From ca0e58f3fc088a253c71a02c450b00aca0739d58 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Fri, 9 Jun 2017 04:49:44 +0300
Subject: [PATCH 07/13] is_trivially_copyable doesn't exist on 4.9 either

---
 include/boost/variant2/variant.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
index 7c50317..6b3a70f 100644
--- a/include/boost/variant2/variant.hpp
+++ b/include/boost/variant2/variant.hpp
@@ -361,7 +361,7 @@ template<class T1, class... T> union variant_storage_impl<mp_true, T1, T...>
     {
 #if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
 
-        this->emplace_impl( mp_all<std::is_move_assignable<T1>, std::is_trivially_copyable<T1>, std::is_move_assignable<T>..., std::is_trivially_copyable<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
+        this->emplace_impl( mp_all<std::is_move_assignable<T1>, std::is_trivial<T1>, std::is_move_assignable<T>..., std::is_trivial<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
 
 #else
 
@@ -505,7 +505,7 @@ template<class... T> struct variant_base_impl<true, true, T...>
 
 #if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
 
-        this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<std::is_move_constructible<U>, std::is_move_assignable<T>..., std::is_trivially_copyable<T>...>(), std::forward<A>(a)... );
+        this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<std::is_move_constructible<U>, std::is_move_assignable<T>..., std::is_trivial<T>...>(), std::forward<A>(a)... );
 
 #else
 

From 870dcee0a8329b89658af01158224e8546ce2380 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Fri, 9 Jun 2017 05:29:22 +0300
Subject: [PATCH 08/13] Fix tests accordingly

---
 test/variant_emplace_index_cx.cpp | 57 +++++++++++++++++++++++++++++--
 test/variant_emplace_type_cx.cpp  | 30 +++++++++++++++-
 2 files changed, 84 insertions(+), 3 deletions(-)

diff --git a/test/variant_emplace_index_cx.cpp b/test/variant_emplace_index_cx.cpp
index 3a5d73d..f66f99f 100644
--- a/test/variant_emplace_index_cx.cpp
+++ b/test/variant_emplace_index_cx.cpp
@@ -13,9 +13,17 @@ using namespace boost::variant2;
 struct X
 {
     int v;
-    constexpr X(): v( 0 ) {}
+    X() = default;
     constexpr explicit X( int v ): v( v ) {}
-	constexpr operator int() const { return v; }
+    constexpr operator int() const { return v; }
+};
+
+struct Y
+{
+    int v;
+    constexpr Y(): v() {}
+    constexpr explicit Y( int v ): v( v ) {}
+    constexpr operator int() const { return v; }
 };
 
 #define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
@@ -41,6 +49,16 @@ int main()
         STATIC_ASSERT( w == 1 );
     }
 
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr auto w = test<variant<Y>, 0>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#endif
+
     {
         constexpr auto w = test<variant<int, float>, 0>( 1 );
         STATIC_ASSERT( w == 1 );
@@ -80,4 +98,39 @@ int main()
         constexpr auto w = test<variant<int, int, float, float, X, X>, 5>( 5 );
         STATIC_ASSERT( w == 5 );
     }
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, Y, Y>, 0>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, Y, Y>, 1>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, Y, Y>, 2>( 2.0f );
+        STATIC_ASSERT( w == 2.0f );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, Y, Y>, 3>( 3.0f );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, Y, Y>, 4>( 4 );
+        STATIC_ASSERT( w == 4 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, Y, Y>, 5>( 5 );
+        STATIC_ASSERT( w == 5 );
+    }
+
+#endif
 }
diff --git a/test/variant_emplace_type_cx.cpp b/test/variant_emplace_type_cx.cpp
index 4162484..2449b12 100644
--- a/test/variant_emplace_type_cx.cpp
+++ b/test/variant_emplace_type_cx.cpp
@@ -13,11 +13,19 @@ using namespace boost::variant2;
 struct X
 {
     int v;
-    constexpr X(): v( 0 ) {}
+    X() = default;
     constexpr explicit X( int v ): v( v ) {}
     constexpr operator int() const { return v; }
 };
 
+struct Y
+{
+    int v;
+    constexpr Y(): v() {}
+    constexpr explicit Y( int v ): v( v ) {}
+    constexpr operator int() const { return v; }
+};
+
 #define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
 
 template<class V, class T, class A> constexpr A test( A const& a )
@@ -41,6 +49,16 @@ int main()
         STATIC_ASSERT( w == 1 );
     }
 
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr auto w = test<variant<Y>, Y>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#endif
+
     {
         constexpr auto w = test<variant<int, float>, int>( 1 );
         STATIC_ASSERT( w == 1 );
@@ -60,4 +78,14 @@ int main()
         constexpr auto w = test<variant<int, int, float, float, X>, X>( 1 );
         STATIC_ASSERT( w == 1 );
     }
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, Y>, Y>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#endif
 }

From 72c16ccee161a6c0be10be65ed74b62151a9bfac Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Fri, 9 Jun 2017 14:58:49 +0300
Subject: [PATCH 09/13] Add test/variant_value_assign_cx

---
 test/Jamfile                     |  14 ++++
 test/variant_value_assign_cx.cpp | 106 +++++++++++++++++++++++++++++++
 2 files changed, 120 insertions(+)
 create mode 100644 test/variant_value_assign_cx.cpp

diff --git a/test/Jamfile b/test/Jamfile
index b9ad29b..559f2b9 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -13,29 +13,43 @@ REQ = ; #[ requires cxx11_variadic_templates cxx11_template_aliases cxx11_declty
 
 run variant_size.cpp : : : $(REQ) ;
 run variant_alternative.cpp : : : $(REQ) ;
+
 run variant_holds_alternative.cpp : : : $(REQ) ;
 compile variant_holds_alternative_cx.cpp : : : $(REQ) ;
+
 run variant_get_by_index.cpp : : : $(REQ) ;
 compile variant_get_by_index_cx.cpp : : : $(REQ) ;
+
 run variant_get_by_type.cpp : : : $(REQ) ;
 compile variant_get_by_type_cx.cpp : : : $(REQ) ;
+
 run variant_default_construct.cpp : : : $(REQ) ;
 compile variant_default_construct_cx.cpp : : : $(REQ) ;
+
 run variant_copy_construct.cpp : : : $(REQ) ;
 run variant_move_construct.cpp : : : $(REQ) ;
+
 run variant_value_construct.cpp : : : $(REQ) ;
 compile variant_value_construct_cx.cpp : : : $(REQ) ;
+
 run variant_in_place_index_construct.cpp : : : $(REQ) ;
 compile variant_in_place_index_construct_cx.cpp : : : $(REQ) ;
+
 run variant_in_place_type_construct.cpp : : : $(REQ) ;
 compile variant_in_place_type_construct_cx.cpp : : : $(REQ) ;
+
 run variant_copy_assign.cpp : : : $(REQ) ;
 run variant_move_assign.cpp : : : $(REQ) ;
+
 run variant_value_assign.cpp : : : $(REQ) ;
+compile variant_value_assign_cx.cpp : : : $(REQ) ;
+
 run variant_emplace_index.cpp : : : $(REQ) ;
 compile variant_emplace_index_cx.cpp : : : $(REQ) ;
+
 run variant_emplace_type.cpp : : : $(REQ) ;
 compile variant_emplace_type_cx.cpp : : : $(REQ) ;
+
 run variant_swap.cpp : : : $(REQ) ;
 run variant_eq_ne.cpp : : : $(REQ) ;
 run variant_destroy.cpp : : : $(REQ) ;
diff --git a/test/variant_value_assign_cx.cpp b/test/variant_value_assign_cx.cpp
new file mode 100644
index 0000000..0a29a0a
--- /dev/null
+++ b/test/variant_value_assign_cx.cpp
@@ -0,0 +1,106 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/variant2/variant.hpp>
+
+using namespace boost::variant2;
+
+struct X
+{
+    int v;
+    X() = default;
+    constexpr X( int v ): v( v ) {}
+    constexpr operator int() const { return v; }
+};
+
+struct Y
+{
+    int v;
+    constexpr Y(): v() {}
+    constexpr Y( int v ): v( v ) {}
+    constexpr operator int() const { return v; }
+};
+
+enum E
+{
+    v
+};
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+template<class V, class T, class A> constexpr A test( A const& a )
+{
+    V v;
+
+    v = a;
+
+    return get<T>(v);
+}
+
+int main()
+{
+    {
+        constexpr auto w = test<variant<int>, int>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<X>, X>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr auto w = test<variant<Y>, Y>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#endif
+
+    {
+        constexpr auto w = test<variant<int, float>, int>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, float>, float>( 3.0f );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float>, float>( 3.0f );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr auto w = test<variant<E, E, X>, X>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, X>, X>( X(1) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr auto w = test<variant<E, E, Y>, Y>( 1 );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, Y>, Y>( Y(1) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#endif
+}

From 6545dc3d10ef6e86a63769670aab52ba093fadf1 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Fri, 9 Jun 2017 15:09:42 +0300
Subject: [PATCH 10/13] Add test/variant_copy_assign_cx

---
 test/Jamfile                    |   2 +
 test/variant_copy_assign_cx.cpp | 125 ++++++++++++++++++++++++++++++++
 2 files changed, 127 insertions(+)
 create mode 100644 test/variant_copy_assign_cx.cpp

diff --git a/test/Jamfile b/test/Jamfile
index 559f2b9..b0dc727 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -39,6 +39,8 @@ run variant_in_place_type_construct.cpp : : : $(REQ) ;
 compile variant_in_place_type_construct_cx.cpp : : : $(REQ) ;
 
 run variant_copy_assign.cpp : : : $(REQ) ;
+compile variant_copy_assign_cx.cpp : : : $(REQ) ;
+
 run variant_move_assign.cpp : : : $(REQ) ;
 
 run variant_value_assign.cpp : : : $(REQ) ;
diff --git a/test/variant_copy_assign_cx.cpp b/test/variant_copy_assign_cx.cpp
new file mode 100644
index 0000000..21403f2
--- /dev/null
+++ b/test/variant_copy_assign_cx.cpp
@@ -0,0 +1,125 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#if !defined( __cpp_constexpr ) || __cpp_constexpr < 201603
+
+// no constexpr lambda support
+int main() {}
+
+#else
+
+#include <boost/variant2/variant.hpp>
+
+using namespace boost::variant2;
+
+struct X
+{
+    int v;
+    X() = default;
+    constexpr X( int v ): v( v ) {}
+    constexpr operator int() const { return v; }
+};
+
+struct Y
+{
+    int v;
+    constexpr Y(): v() {}
+    constexpr Y( int v ): v( v ) {}
+    constexpr operator int() const { return v; }
+};
+
+enum E
+{
+    v
+};
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+template<class V, class T, class A> constexpr T test( A const& a )
+{
+    V v;
+
+    v = a;
+
+    return get<T>(v);
+}
+
+int main()
+{
+    {
+        constexpr variant<int> v( 1 );
+        constexpr auto w = test<variant<int>, int>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr variant<X> v( 1 );
+        constexpr auto w = test<variant<X>, X>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr variant<Y> v( 1 );
+        constexpr auto w = test<variant<Y>, Y>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#endif
+
+    {
+        constexpr variant<int, float> v( 1 );
+        constexpr auto w = test<variant<int, float>, int>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr variant<int, float> v( 3.0f );
+        constexpr auto w = test<variant<int, float>, float>( v );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr variant<int, int, float> v( 3.0f );
+        constexpr auto w = test<variant<int, int, float>, float>( v );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr variant<E, E, X> v( 1 );
+        constexpr auto w = test<variant<E, E, X>, X>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr variant<int, int, float, float, X> v( X(1) );
+        constexpr auto w = test<variant<int, int, float, float, X>, X>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr variant<E, E, Y> v( 1 );
+        constexpr auto w = test<variant<E, E, Y>, Y>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr variant<int, int, float, float, Y> v( Y(1) );
+        constexpr auto w = test<variant<int, int, float, float, Y>, Y>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#endif
+}
+
+#endif // constexpr lambda support

From f216bb5c1f08b95ccec43003eaadacc7cca08404 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Fri, 9 Jun 2017 15:13:36 +0300
Subject: [PATCH 11/13] Add test/variant_move_assign_cx

---
 test/Jamfile                    |   1 +
 test/variant_move_assign_cx.cpp | 116 ++++++++++++++++++++++++++++++++
 2 files changed, 117 insertions(+)
 create mode 100644 test/variant_move_assign_cx.cpp

diff --git a/test/Jamfile b/test/Jamfile
index b0dc727..4830d34 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -42,6 +42,7 @@ run variant_copy_assign.cpp : : : $(REQ) ;
 compile variant_copy_assign_cx.cpp : : : $(REQ) ;
 
 run variant_move_assign.cpp : : : $(REQ) ;
+compile variant_move_assign_cx.cpp : : : $(REQ) ;
 
 run variant_value_assign.cpp : : : $(REQ) ;
 compile variant_value_assign_cx.cpp : : : $(REQ) ;
diff --git a/test/variant_move_assign_cx.cpp b/test/variant_move_assign_cx.cpp
new file mode 100644
index 0000000..e6a6443
--- /dev/null
+++ b/test/variant_move_assign_cx.cpp
@@ -0,0 +1,116 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#if !defined( __cpp_constexpr ) || __cpp_constexpr < 201603
+
+// no constexpr lambda support
+int main() {}
+
+#else
+
+#include <boost/variant2/variant.hpp>
+#include <utility>
+
+using namespace boost::variant2;
+
+struct X
+{
+    int v;
+    X() = default;
+    constexpr X( int v ): v( v ) {}
+    constexpr operator int() const { return v; }
+};
+
+struct Y
+{
+    int v;
+    constexpr Y(): v() {}
+    constexpr Y( int v ): v( v ) {}
+    constexpr operator int() const { return v; }
+};
+
+enum E
+{
+    v
+};
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+template<class V, class T, class A> constexpr T test( A&& a )
+{
+    V v;
+
+    v = std::forward<A>(a);
+
+    return get<T>(v);
+}
+
+int main()
+{
+    {
+        constexpr auto w = test<variant<int>, int>( variant<int>( 1 ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<X>, X>( variant<X>( 1 ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr auto w = test<variant<Y>, Y>( variant<Y>( 1 ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#endif
+
+    {
+        constexpr auto w = test<variant<int, float>, int>( variant<int, float>( 1 ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, float>, float>( variant<int, float>( 3.0f ) );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float>, float>( variant<int, int, float>( 3.0f ) );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr auto w = test<variant<E, E, X>, X>( variant<E, E, X>( 1 ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, X>, X>( variant<int, int, float, float, X>( X(1) ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr auto w = test<variant<E, E, Y>, Y>( variant<E, E, Y>( 1 ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<variant<int, int, float, float, Y>, Y>( variant<int, int, float, float, Y>( Y(1) ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#endif
+}
+
+#endif // constexpr lambda support

From 82104cd55e76fe0fecbc91a09eda1e0eb3de9f20 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Fri, 9 Jun 2017 17:24:23 +0300
Subject: [PATCH 12/13] constexpr the copy/move constructors; change copy/move
 assign to not require constexpr lambdas

---
 include/boost/variant2/variant.hpp |  60 ++++++++++++--
 test/Jamfile                       |   3 +
 test/variant_copy_assign_cx.cpp    |   9 ---
 test/variant_copy_construct_cx.cpp | 122 +++++++++++++++++++++++++++++
 test/variant_move_assign_cx.cpp    |   9 ---
 test/variant_move_construct_cx.cpp | 113 ++++++++++++++++++++++++++
 6 files changed, 291 insertions(+), 25 deletions(-)
 create mode 100644 test/variant_copy_construct_cx.cpp
 create mode 100644 test/variant_move_construct_cx.cpp

diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
index 6b3a70f..4e44611 100644
--- a/include/boost/variant2/variant.hpp
+++ b/include/boost/variant2/variant.hpp
@@ -868,8 +868,19 @@ public:
     {
     }
 
-    template<class E1 = void, class E2 = mp_if<mp_all<std::is_copy_constructible<T>...>, E1>>
-    constexpr variant( variant const& r )
+    template<class E1 = void,
+        class E2 = mp_if<mp_all<std::is_trivially_copy_constructible<T>...>, E1>
+    >
+    constexpr variant( variant const& r ) noexcept
+        : variant_base( static_cast<variant_base const&>(r) )
+    {
+    }
+
+    template<class E1 = void,
+        class E2 = mp_if<mp_not<mp_all<std::is_trivially_copy_constructible<T>...>>, E1>,
+        class E3 = mp_if<mp_all<std::is_copy_constructible<T>...>, E1>
+    >
+    variant( variant const& r )
         noexcept( mp_all<std::is_nothrow_copy_constructible<T>...>::value )
     {
         mp_with_index<sizeof...(T)>( r.index(), [&]( auto I ){
@@ -879,8 +890,19 @@ public:
         });
     }
 
-    template<class E1 = void, class E2 = mp_if<mp_all<std::is_move_constructible<T>...>, E1>>
-    constexpr variant( variant && r )
+    template<class E1 = void,
+        class E2 = mp_if<mp_all<std::is_trivially_move_constructible<T>...>, E1>
+    >
+    constexpr variant( variant && r ) noexcept
+        : variant_base( static_cast<variant_base&&>(r) )
+    {
+    }
+
+    template<class E1 = void,
+        class E2 = mp_if<mp_not<mp_all<std::is_trivially_move_constructible<T>...>>, E1>,
+        class E3 = mp_if<mp_all<std::is_move_constructible<T>...>, E1>
+    >
+    variant( variant && r )
         noexcept( mp_all<std::is_nothrow_move_constructible<T>...>::value )
     {
         mp_with_index<sizeof...(T)>( r.index(), [&]( auto I ){
@@ -923,7 +945,19 @@ public:
     }
 
     // assignment
-    template<class E1 = void, class E2 = mp_if<mp_all<std::is_copy_constructible<T>..., std::is_copy_assignable<T>...>, E1>>
+    template<class E1 = void,
+        class E2 = mp_if<mp_all<std::is_trivially_destructible<T>..., std::is_trivially_copy_assignable<T>...>, E1>
+    >
+    constexpr variant& operator=( variant const & r ) noexcept
+    {
+        static_cast<variant_base&>( *this ) = static_cast<variant_base const&>( r );
+        return *this;
+    }
+
+    template<class E1 = void,
+        class E2 = mp_if<mp_not<mp_all<std::is_trivially_destructible<T>..., std::is_trivially_copy_assignable<T>...>>, E1>,
+        class E3 = mp_if<mp_all<std::is_copy_constructible<T>..., std::is_copy_assignable<T>...>, E1>
+    >
     constexpr variant& operator=( variant const & r )
         noexcept( mp_all<std::is_nothrow_copy_constructible<T>..., std::is_nothrow_copy_assignable<T>...>::value )
     {
@@ -943,8 +977,20 @@ public:
         return *this;
     }
 
-    template<class E1 = void, class E2 = mp_if<mp_all<std::is_move_constructible<T>..., std::is_move_assignable<T>...>, E1>>
-    constexpr variant& operator=( variant && r )
+    template<class E1 = void,
+        class E2 = mp_if<mp_all<std::is_trivially_destructible<T>..., std::is_trivially_move_assignable<T>...>, E1>
+    >
+    constexpr variant& operator=( variant && r ) noexcept
+    {
+        static_cast<variant_base&>( *this ) = static_cast<variant_base&&>( r );
+        return *this;
+    }
+
+    template<class E1 = void,
+        class E2 = mp_if<mp_not<mp_all<std::is_trivially_destructible<T>..., std::is_trivially_move_assignable<T>...>>, E1>,
+        class E3 = mp_if<mp_all<std::is_move_constructible<T>..., std::is_move_assignable<T>...>, E1>
+    >
+    variant& operator=( variant && r )
         noexcept( mp_all<std::is_nothrow_move_constructible<T>..., std::is_nothrow_move_assignable<T>...>::value )
     {
         mp_with_index<sizeof...(T)>( r.index(), [&]( auto I ){
diff --git a/test/Jamfile b/test/Jamfile
index 4830d34..39973c9 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -27,7 +27,10 @@ run variant_default_construct.cpp : : : $(REQ) ;
 compile variant_default_construct_cx.cpp : : : $(REQ) ;
 
 run variant_copy_construct.cpp : : : $(REQ) ;
+compile variant_copy_construct_cx.cpp : : : $(REQ) ;
+
 run variant_move_construct.cpp : : : $(REQ) ;
+compile variant_move_construct_cx.cpp : : : $(REQ) ;
 
 run variant_value_construct.cpp : : : $(REQ) ;
 compile variant_value_construct_cx.cpp : : : $(REQ) ;
diff --git a/test/variant_copy_assign_cx.cpp b/test/variant_copy_assign_cx.cpp
index 21403f2..8be2579 100644
--- a/test/variant_copy_assign_cx.cpp
+++ b/test/variant_copy_assign_cx.cpp
@@ -6,13 +6,6 @@
 // See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt
 
-#if !defined( __cpp_constexpr ) || __cpp_constexpr < 201603
-
-// no constexpr lambda support
-int main() {}
-
-#else
-
 #include <boost/variant2/variant.hpp>
 
 using namespace boost::variant2;
@@ -121,5 +114,3 @@ int main()
 
 #endif
 }
-
-#endif // constexpr lambda support
diff --git a/test/variant_copy_construct_cx.cpp b/test/variant_copy_construct_cx.cpp
new file mode 100644
index 0000000..e208f4e
--- /dev/null
+++ b/test/variant_copy_construct_cx.cpp
@@ -0,0 +1,122 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#if !defined( __cpp_constexpr ) || __cpp_constexpr < 201603
+
+// no constexpr lambda support
+int main() {}
+
+#else
+
+#include <boost/variant2/variant.hpp>
+
+using namespace boost::variant2;
+
+struct X
+{
+    int v;
+    X() = default;
+    constexpr X( int v ): v( v ) {}
+    constexpr operator int() const { return v; }
+};
+
+struct Y
+{
+    int v;
+    constexpr Y(): v() {}
+    constexpr Y( int v ): v( v ) {}
+    constexpr operator int() const { return v; }
+};
+
+enum E
+{
+    v
+};
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+template<class T, class V> constexpr T test( V const& v )
+{
+    V v2( v );
+    return get<T>(v);
+}
+
+int main()
+{
+    {
+        constexpr variant<int> v( 1 );
+        constexpr auto w = test<int>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr variant<X> v( 1 );
+        constexpr auto w = test<X>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr variant<Y> v( 1 );
+        constexpr auto w = test<Y>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#endif
+
+    {
+        constexpr variant<int, float> v( 1 );
+        constexpr auto w = test<int>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr variant<int, float> v( 3.0f );
+        constexpr auto w = test<float>( v );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr variant<int, int, float> v( 3.0f );
+        constexpr auto w = test<float>( v );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr variant<E, E, X> v( 1 );
+        constexpr auto w = test<X>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr variant<int, int, float, float, X> v( X(1) );
+        constexpr auto w = test<X>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr variant<E, E, Y> v( 1 );
+        constexpr auto w = test<Y>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr variant<int, int, float, float, Y> v( Y(1) );
+        constexpr auto w = test<Y>( v );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#endif
+}
+
+#endif // constexpr lambda support
diff --git a/test/variant_move_assign_cx.cpp b/test/variant_move_assign_cx.cpp
index e6a6443..d7ab65f 100644
--- a/test/variant_move_assign_cx.cpp
+++ b/test/variant_move_assign_cx.cpp
@@ -6,13 +6,6 @@
 // See accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt
 
-#if !defined( __cpp_constexpr ) || __cpp_constexpr < 201603
-
-// no constexpr lambda support
-int main() {}
-
-#else
-
 #include <boost/variant2/variant.hpp>
 #include <utility>
 
@@ -112,5 +105,3 @@ int main()
 
 #endif
 }
-
-#endif // constexpr lambda support
diff --git a/test/variant_move_construct_cx.cpp b/test/variant_move_construct_cx.cpp
new file mode 100644
index 0000000..269607c
--- /dev/null
+++ b/test/variant_move_construct_cx.cpp
@@ -0,0 +1,113 @@
+
+// Copyright 2017 Peter Dimov.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//
+// See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt
+
+#if !defined( __cpp_constexpr ) || __cpp_constexpr < 201603
+
+// no constexpr lambda support
+int main() {}
+
+#else
+
+#include <boost/variant2/variant.hpp>
+#include <utility>
+
+using namespace boost::variant2;
+
+struct X
+{
+    int v;
+    X() = default;
+    constexpr X( int v ): v( v ) {}
+    constexpr operator int() const { return v; }
+};
+
+struct Y
+{
+    int v;
+    constexpr Y(): v() {}
+    constexpr Y( int v ): v( v ) {}
+    constexpr operator int() const { return v; }
+};
+
+enum E
+{
+    v
+};
+
+#define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+template<class T, class V> constexpr T test( V&& v )
+{
+    V v2( std::forward<V>(v) );
+    return get<T>(v);
+}
+
+int main()
+{
+    {
+        constexpr auto w = test<int>( variant<int>( 1 ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<X>( variant<X>( 1 ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr auto w = test<Y>( variant<Y>( 1 ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#endif
+
+    {
+        constexpr auto w = test<int>( variant<int, float>( 1 ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<float>( variant<int, float>( 3.0f ) );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr auto w = test<float>( variant<int, int, float>( 3.0f ) );
+        STATIC_ASSERT( w == 3.0f );
+    }
+
+    {
+        constexpr auto w = test<X>( variant<E, E, X>( 1 ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<X>( variant<int, int, float, float, X>( X(1) ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+#else
+
+    {
+        constexpr auto w = test<Y>( variant<E, E, Y>( 1 ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+    {
+        constexpr auto w = test<Y>( variant<int, int, float, float, Y>( Y(1) ) );
+        STATIC_ASSERT( w == 1 );
+    }
+
+#endif
+}
+
+#endif // constexpr lambda support

From 3bb14bf93b60f1def0c741f507fe6371be137dc1 Mon Sep 17 00:00:00 2001
From: Peter Dimov <pdimov@pdimov.com>
Date: Fri, 9 Jun 2017 17:45:36 +0300
Subject: [PATCH 13/13] Add emulations for is_trivially_* traits for libstdc++
 < 5

---
 include/boost/variant2/variant.hpp | 65 ++++++++++++++++++------------
 1 file changed, 39 insertions(+), 26 deletions(-)

diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
index 4e44611..260411c 100644
--- a/include/boost/variant2/variant.hpp
+++ b/include/boost/variant2/variant.hpp
@@ -283,6 +283,35 @@ template<class U, class... T> constexpr std::add_pointer_t<U const> get_if(varia
 namespace detail
 {
 
+// trivially_*
+
+#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
+
+template<class T> struct is_trivially_copy_constructible: mp_bool<std::is_copy_constructible<T>::value && std::has_trivial_copy_constructor<T>::value>
+{
+};
+
+template<class T> struct is_trivially_copy_assignable: mp_bool<std::is_copy_assignable<T>::value && std::has_trivial_copy_assign<T>::value>
+{
+};
+
+template<class T> struct is_trivially_move_constructible: mp_bool<std::is_move_constructible<T>::value && std::is_trivial<T>::value>
+{
+};
+
+template<class T> struct is_trivially_move_assignable: mp_bool<std::is_move_assignable<T>::value && std::is_trivial<T>::value>
+{
+};
+
+#else
+
+using std::is_trivially_copy_constructible;
+using std::is_trivially_copy_assignable;
+using std::is_trivially_move_constructible;
+using std::is_trivially_move_assignable;
+
+#endif
+
 // variant_storage
 
 template<class D, class... T> union variant_storage_impl;
@@ -359,15 +388,7 @@ template<class T1, class... T> union variant_storage_impl<mp_true, T1, T...>
 
     template<std::size_t I, class... A> constexpr void emplace( mp_size_t<I>, A&&... a )
     {
-#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
-
-        this->emplace_impl( mp_all<std::is_move_assignable<T1>, std::is_trivial<T1>, std::is_move_assignable<T>..., std::is_trivial<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
-
-#else
-
-        this->emplace_impl( mp_all<std::is_trivially_move_assignable<T1>, std::is_trivially_move_assignable<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
-
-#endif
+        this->emplace_impl( mp_all<variant2::detail::is_trivially_move_assignable<T1>, variant2::detail::is_trivially_move_assignable<T>...>(), mp_size_t<I>(), std::forward<A>(a)... );
     }
 
     constexpr T1& get( mp_size_t<0> ) noexcept { return first_; }
@@ -503,15 +524,7 @@ template<class... T> struct variant_base_impl<true, true, T...>
         std::size_t const J = I+1;
         using U = mp_at_c<variant<T...>, I>;
 
-#if defined( BOOST_LIBSTDCXX_VERSION ) && BOOST_LIBSTDCXX_VERSION < 50000
-
-        this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<std::is_move_constructible<U>, std::is_move_assignable<T>..., std::is_trivial<T>...>(), std::forward<A>(a)... );
-
-#else
-
-        this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<std::is_trivially_move_constructible<U>, std::is_trivially_move_assignable<T>...>(), std::forward<A>(a)... );
-
-#endif
+        this->emplace_impl<J, U>( std::is_nothrow_constructible<U, A...>(), mp_all<variant2::detail::is_trivially_move_constructible<U>, variant2::detail::is_trivially_move_assignable<T>...>(), std::forward<A>(a)... );
     }
 };
 
@@ -869,7 +882,7 @@ public:
     }
 
     template<class E1 = void,
-        class E2 = mp_if<mp_all<std::is_trivially_copy_constructible<T>...>, E1>
+        class E2 = mp_if<mp_all<variant2::detail::is_trivially_copy_constructible<T>...>, E1>
     >
     constexpr variant( variant const& r ) noexcept
         : variant_base( static_cast<variant_base const&>(r) )
@@ -877,7 +890,7 @@ public:
     }
 
     template<class E1 = void,
-        class E2 = mp_if<mp_not<mp_all<std::is_trivially_copy_constructible<T>...>>, E1>,
+        class E2 = mp_if<mp_not<mp_all<variant2::detail::is_trivially_copy_constructible<T>...>>, E1>,
         class E3 = mp_if<mp_all<std::is_copy_constructible<T>...>, E1>
     >
     variant( variant const& r )
@@ -891,7 +904,7 @@ public:
     }
 
     template<class E1 = void,
-        class E2 = mp_if<mp_all<std::is_trivially_move_constructible<T>...>, E1>
+        class E2 = mp_if<mp_all<variant2::detail::is_trivially_move_constructible<T>...>, E1>
     >
     constexpr variant( variant && r ) noexcept
         : variant_base( static_cast<variant_base&&>(r) )
@@ -899,7 +912,7 @@ public:
     }
 
     template<class E1 = void,
-        class E2 = mp_if<mp_not<mp_all<std::is_trivially_move_constructible<T>...>>, E1>,
+        class E2 = mp_if<mp_not<mp_all<variant2::detail::is_trivially_move_constructible<T>...>>, E1>,
         class E3 = mp_if<mp_all<std::is_move_constructible<T>...>, E1>
     >
     variant( variant && r )
@@ -946,7 +959,7 @@ public:
 
     // assignment
     template<class E1 = void,
-        class E2 = mp_if<mp_all<std::is_trivially_destructible<T>..., std::is_trivially_copy_assignable<T>...>, E1>
+        class E2 = mp_if<mp_all<std::is_trivially_destructible<T>..., variant2::detail::is_trivially_copy_assignable<T>...>, E1>
     >
     constexpr variant& operator=( variant const & r ) noexcept
     {
@@ -955,7 +968,7 @@ public:
     }
 
     template<class E1 = void,
-        class E2 = mp_if<mp_not<mp_all<std::is_trivially_destructible<T>..., std::is_trivially_copy_assignable<T>...>>, E1>,
+        class E2 = mp_if<mp_not<mp_all<std::is_trivially_destructible<T>..., variant2::detail::is_trivially_copy_assignable<T>...>>, E1>,
         class E3 = mp_if<mp_all<std::is_copy_constructible<T>..., std::is_copy_assignable<T>...>, E1>
     >
     constexpr variant& operator=( variant const & r )
@@ -978,7 +991,7 @@ public:
     }
 
     template<class E1 = void,
-        class E2 = mp_if<mp_all<std::is_trivially_destructible<T>..., std::is_trivially_move_assignable<T>...>, E1>
+        class E2 = mp_if<mp_all<std::is_trivially_destructible<T>..., variant2::detail::is_trivially_move_assignable<T>...>, E1>
     >
     constexpr variant& operator=( variant && r ) noexcept
     {
@@ -987,7 +1000,7 @@ public:
     }
 
     template<class E1 = void,
-        class E2 = mp_if<mp_not<mp_all<std::is_trivially_destructible<T>..., std::is_trivially_move_assignable<T>...>>, E1>,
+        class E2 = mp_if<mp_not<mp_all<std::is_trivially_destructible<T>..., variant2::detail::is_trivially_move_assignable<T>...>>, E1>,
         class E3 = mp_if<mp_all<std::is_move_constructible<T>..., std::is_move_assignable<T>...>, E1>
     >
     variant& operator=( variant && r )