From 280bacf780bfa21e0612508a79853e12740d8c6a Mon Sep 17 00:00:00 2001
From: John Buonagurio <jbuonagurio@exponent.com>
Date: Sun, 6 Sep 2020 22:22:25 -0400
Subject: [PATCH 1/3] Work on resolve_overload_* functions for P0608 support

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

diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
index 7a4a2cf..3a58ed3 100644
--- a/include/boost/variant2/variant.hpp
+++ b/include/boost/variant2/variant.hpp
@@ -773,34 +773,50 @@ template<class T0, class T1, class T2, class T3, class T4, class T5, class T6, c
 
 // resolve_overload_*
 
-template<class... T> struct overload;
+template<class T> using remove_cv_ref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
 
-template<> struct overload<>
+struct narrowing_check_impl
 {
-    void operator()() const;
+    template<class T>
+    static auto check(T (&&)[1]) -> mp11::mp_identity<T>;
+
+    template<class T, class U>
+    using fn = decltype(check<T>({ std::declval<U>() }));
 };
 
-template<class T1, class... T> struct overload<T1, T...>: overload<T...>
+template<class T, class U> using narrowing_check = mp11::mp_if<std::is_arithmetic<T>, mp11::mp_identity<T>, mp11::mp_invoke_q<narrowing_check_impl, T, U>>;
+
+template<class T> struct overload
 {
-    using overload<T...>::operator();
-    mp11::mp_identity<T1> operator()(T1) const;
+    template<class U>
+    auto operator()(T, U&&) const -> narrowing_check<T, U>;
 };
 
-#if BOOST_WORKAROUND( BOOST_MSVC, < 1930 )
+template<class T> struct overload_bool
+{
+    template<class U>
+    auto operator()(bool, U&&) const -> mp11::mp_if<std::is_same<remove_cv_ref_t<U>, bool>, mp11::mp_identity<T>>;
+};
 
-template<class U, class... T> using resolve_overload_type_ = decltype( overload<T...>()(std::declval<U>()) );
+template<> struct overload<bool> : overload_bool<bool> {};
+template<> struct overload<const bool> : overload_bool<const bool> {};
+template<> struct overload<volatile bool> : overload_bool<volatile bool> {};
+template<> struct overload<const volatile bool> : overload_bool<const volatile bool> {};
 
-template<class U, class... T> struct resolve_overload_type_impl: mp11::mp_defer< resolve_overload_type_, U, T... >
+template<class... T> struct overloads : T...
 {
+    void operator()() const;
+    using T::operator()...;
 };
 
-template<class U, class... T> using resolve_overload_type = typename resolve_overload_type_impl<U, T...>::type::type;
+template<class U, class L> struct resolve_overload_type_impl;
 
-#else
+template<class U, template<class...> class L, class... T> struct resolve_overload_type_impl<U, L<T...>>
+{
+    using type = typename decltype( overloads<overload<T>...>()(std::declval<U>(), std::declval<U>()) )::type;
+};
 
-template<class U, class... T> using resolve_overload_type = typename decltype( overload<T...>()(std::declval<U>()) )::type;
-
-#endif
+template<class U, class... T> using resolve_overload_type = typename resolve_overload_type_impl<U, mp11::mp_unique<mp11::mp_list<T...>>>::type;
 
 template<class U, class... T> using resolve_overload_index = mp11::mp_find<mp11::mp_list<T...>, resolve_overload_type<U, T...>>;
 
@@ -1947,8 +1963,6 @@ template<class... T> constexpr bool operator>=( variant<T...> const & v, variant
 namespace detail
 {
 
-template<class T> using remove_cv_ref_t = typename std::remove_cv<typename std::remove_reference<T>::type>::type;
-
 template<class... T> variant<T...> const & extract_variant_base_( variant<T...> const & );
 
 #if BOOST_WORKAROUND( BOOST_MSVC, < 1930 )

From 98bd0891e75c680f11836a24189f7dd0eba469c3 Mon Sep 17 00:00:00 2001
From: John Buonagurio <jbuonagurio@exponent.com>
Date: Tue, 8 Sep 2020 16:51:59 -0400
Subject: [PATCH 2/3] Work on resolve_overload_* functions for P0608 support

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

diff --git a/include/boost/variant2/variant.hpp b/include/boost/variant2/variant.hpp
index 3a58ed3..9dd64cc 100644
--- a/include/boost/variant2/variant.hpp
+++ b/include/boost/variant2/variant.hpp
@@ -786,37 +786,59 @@ struct narrowing_check_impl
 
 template<class T, class U> using narrowing_check = mp11::mp_if<std::is_arithmetic<T>, mp11::mp_identity<T>, mp11::mp_invoke_q<narrowing_check_impl, T, U>>;
 
-template<class T> struct overload
+template<class... T> struct overload;
+
+template<> struct overload<>
 {
-    template<class U>
-    auto operator()(T, U&&) const -> narrowing_check<T, U>;
+    void operator()() const;
 };
 
-template<class T> struct overload_bool
+template<class T1, class... T> struct overload<T1, T...> : overload<T...>
 {
-    template<class U>
-    auto operator()(bool, U&&) const -> mp11::mp_if<std::is_same<remove_cv_ref_t<U>, bool>, mp11::mp_identity<T>>;
+    using overload<T...>::operator();
+    template<class U> auto operator()(T1, U&&) const -> narrowing_check<T1, U>;
 };
 
-template<> struct overload<bool> : overload_bool<bool> {};
-template<> struct overload<const bool> : overload_bool<const bool> {};
-template<> struct overload<volatile bool> : overload_bool<volatile bool> {};
-template<> struct overload<const volatile bool> : overload_bool<const volatile bool> {};
+template<class... T> struct overload<bool, T...> : overload<T...>
+{
+    using overload<T...>::operator();
+    template<class U> auto operator()(bool, U&&) const -> mp11::mp_if<std::is_same<remove_cv_ref_t<U>, bool>, mp11::mp_identity<bool>>;
+};
 
-template<class... T> struct overloads : T...
+template<class... T> struct overload<const bool, T...> : overload<T...>
 {
-    void operator()() const;
-    using T::operator()...;
+    using overload<T...>::operator();
+    template<class U> auto operator()(bool, U&&) const -> mp11::mp_if<std::is_same<remove_cv_ref_t<U>, bool>, mp11::mp_identity<const bool>>;
 };
 
-template<class U, class L> struct resolve_overload_type_impl;
+template<class... T> struct overload<volatile bool, T...> : overload<T...>
+{
+    using overload<T...>::operator();
+    template<class U> auto operator()(bool, U&&) const -> mp11::mp_if<std::is_same<remove_cv_ref_t<U>, bool>, mp11::mp_identity<volatile bool>>;
+};
 
-template<class U, template<class...> class L, class... T> struct resolve_overload_type_impl<U, L<T...>>
+template<class... T> struct overload<const volatile bool, T...> : overload<T...>
 {
-    using type = typename decltype( overloads<overload<T>...>()(std::declval<U>(), std::declval<U>()) )::type;
+    using overload<T...>::operator();
+    template<class U> auto operator()(bool, U&&) const -> mp11::mp_if<std::is_same<remove_cv_ref_t<U>, bool>, mp11::mp_identity<const volatile bool>>;
 };
 
-template<class U, class... T> using resolve_overload_type = typename resolve_overload_type_impl<U, mp11::mp_unique<mp11::mp_list<T...>>>::type;
+
+#if BOOST_WORKAROUND( BOOST_MSVC, < 1930 )
+
+template<class U, class... T> using resolve_overload_type_ = decltype( overload<T...>()(std::declval<U>(), std::declval<U>()) );
+
+template<class U, class... T> struct resolve_overload_type_impl: mp11::mp_defer< resolve_overload_type_, U, T... >
+{
+};
+
+template<class U, class... T> using resolve_overload_type = typename resolve_overload_type_impl<U, T...>::type::type;
+
+#else
+
+template<class U, class... T> using resolve_overload_type = typename decltype( overload<T...>()(std::declval<U>(), std::declval<U>()) )::type;
+
+#endif
 
 template<class U, class... T> using resolve_overload_index = mp11::mp_find<mp11::mp_list<T...>, resolve_overload_type<U, T...>>;
 

From c7788fac9d3457766c97c90bc8f6c0c759c12a26 Mon Sep 17 00:00:00 2001
From: John Buonagurio <jbuonagurio@exponent.com>
Date: Tue, 8 Sep 2020 17:07:59 -0400
Subject: [PATCH 3/3] Add test case for P0608 support

---
 test/variant_convert_construct.cpp | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/test/variant_convert_construct.cpp b/test/variant_convert_construct.cpp
index dbf61d9..818c791 100644
--- a/test/variant_convert_construct.cpp
+++ b/test/variant_convert_construct.cpp
@@ -156,6 +156,20 @@ int main()
         BOOST_TEST( holds_alternative<std::string>( v3 ) );
         BOOST_TEST_EQ( get<std::string>( v2 ), get<std::string>( v3 ) );
     }
+    
+    {
+        variant<bool, std::string> v( "s2" );
+
+        variant<bool, bool, const char *, std::string> v2( v );
+
+        BOOST_TEST( holds_alternative<std::string>( v2 ) );
+        BOOST_TEST_EQ( get<std::string>( v ), get<std::string>( v2 ) );
+
+        variant<bool, bool, const char *, std::string> v3( std::move(v) );
+
+        BOOST_TEST( holds_alternative<std::string>( v3 ) );
+        BOOST_TEST_EQ( get<std::string>( v2 ), get<std::string>( v3 ) );
+    }
 
     {
         variant<X1, X2> v{ X1{1} };