Disable C4800 under msvc-14.0

include/boost/system/result.hpp

@@ -85,6 +85,10 @@ template<class T> using remove_cvref = typename std::remove_cv< typename std::re
 
 template<class... T> using is_errc_t = std::is_same<mp11::mp_list<remove_cvref<T>...>, mp11::mp_list<errc::errc_t>>;
 
+template<class T, class... A> struct is_constructible: std::is_constructible<T, A...> {};
+template<class A> struct is_constructible<bool, A>: std::is_convertible<A, bool> {};
+template<class A> struct is_constructible<bool const, A>: std::is_convertible<A, bool> {};
+
 } // namespace detail
 
 // result
@@ -141,9 +145,9 @@ public:
 
     // explicit, value
     template<class... A, class En = typename std::enable_if<
-        std::is_constructible<T, A...>::value &&
+        detail::is_constructible<T, A...>::value &&
         !(detail::is_errc_t<A...>::value && std::is_arithmetic<T>::value) &&
-        !std::is_constructible<E, A...>::value &&
+        !detail::is_constructible<E, A...>::value &&
         sizeof...(A) >= 1
         >::type>
     explicit constexpr result( A&&... a )
@@ -154,8 +158,8 @@ public:
 
     // explicit, error
     template<class... A, class En2 = void, class En = typename std::enable_if<
-        !std::is_constructible<T, A...>::value &&
-        std::is_constructible<E, A...>::value &&
+        !detail::is_constructible<T, A...>::value &&
+        detail::is_constructible<E, A...>::value &&
         sizeof...(A) >= 1
         >::type>
     explicit constexpr result( A&&... a )
@@ -187,7 +191,8 @@ public:
     // converting
     template<class T2, class E2, class En = typename std::enable_if<
         std::is_convertible<T2, T>::value &&
-        std::is_convertible<E2, E>::value
+        std::is_convertible<E2, E>::value &&
+        !std::is_convertible<result<T2, E2> const&, T>::value
         >::type>
     BOOST_CXX14_CONSTEXPR result( result<T2, E2> const& r2 )
         noexcept(
@@ -205,7 +210,8 @@ public:
 
     template<class T2, class E2, class En = typename std::enable_if<
         std::is_convertible<T2, T>::value &&
-        std::is_convertible<E2, E>::value
+        std::is_convertible<E2, E>::value &&
+        !std::is_convertible<result<T2, E2>&&, T>::value
         >::type>
     BOOST_CXX14_CONSTEXPR result( result<T2, E2>&& r2 )
         noexcept(

test/CMakeLists.txt

@@ -161,3 +161,5 @@ boost_test(TYPE run SOURCES result_value_construct3.cpp)
 boost_test(TYPE run SOURCES result_error_construct3.cpp)
 boost_test(TYPE run SOURCES result_emplace.cpp)
 boost_test(TYPE run SOURCES result_error_construct4.cpp)
+boost_test(TYPE run SOURCES result_value_construct4.cpp)
+boost_test(TYPE run SOURCES result_value_construct5.cpp)

test/Jamfile.v2

@@ -191,3 +191,5 @@ run result_value_construct3.cpp : : : $(CPP11) ;
 run result_error_construct3.cpp : : : $(CPP11) ;
 run result_emplace.cpp : : : $(CPP11) ;
 run result_error_construct4.cpp : : : $(CPP11) ;
+run result_value_construct4.cpp : : : $(CPP11) ;
+run result_value_construct5.cpp : : : $(CPP11) ;

test/result_value_construct4.cpp

@@ -0,0 +1,59 @@
+// Copyright 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+using namespace boost::system;
+
+// Tricky mixed construction cases
+// https://github.com/boostorg/system/issues/104
+// https://brevzin.github.io//c++/2023/01/18/optional-construction/
+
+int main()
+{
+    {
+        result<int> r( make_error_code( errc::invalid_argument ) );
+        result<result<int>> r2( r );
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), r );
+    }
+
+    {
+        result<int> r( 5 );
+        result<result<int>> r2( r );
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), r );
+    }
+
+    {
+        result<int> const r( make_error_code( errc::invalid_argument ) );
+        result<result<int>> r2( r );
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), r );
+    }
+
+    {
+        result<int> const r( 5 );
+        result<result<int>> r2( r );
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), r );
+    }
+
+    {
+        result<int> r( make_error_code( errc::invalid_argument ) );
+        result<result<int>> r2( std::move( r ) );
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), r );
+    }
+
+    {
+        result<int> r( 5 );
+        result<result<int>> r2( std::move( r ) );
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), r );
+    }
+
+    return boost::report_errors();
+}

test/result_value_construct5.cpp

@@ -0,0 +1,86 @@
+// Copyright 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#if defined(_MSC_VER) && _MSC_VER < 1910
+# pragma warning( disable: 4800 ) // forcing value to bool 'true' or 'false'
+#endif
+
+#include <boost/system/result.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/lightweight_test_trait.hpp>
+#include <utility>
+#include <type_traits>
+
+using namespace boost::system;
+
+// Tricky mixed construction cases
+// https://github.com/boostorg/system/issues/104
+// https://brevzin.github.io//c++/2023/01/18/optional-construction/
+
+template<class R1, class R2> void test()
+{
+    {
+        R1 r1( make_error_code( errc::invalid_argument ) );
+        R2 r2( r1 );
+
+        BOOST_TEST( !r2.has_value() );
+    }
+
+    {
+        R1 r1( 0 );
+        R2 r2( r1 );
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), false );
+    }
+
+    {
+        R1 r1( 1 );
+        R2 r2( r1 );
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), true );
+    }
+
+    {
+        R1 r1( make_error_code( errc::invalid_argument ) );
+        R2 r2( std::move( r1 ) );
+
+        BOOST_TEST( !r2.has_value() );
+    }
+
+    {
+        R1 r1( 0 );
+        R2 r2( std::move( r1 ) );
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), false );
+    }
+
+    {
+        R1 r1( 1 );
+        R2 r2( std::move( r1 ) );
+
+        BOOST_TEST( r2.has_value() ) && BOOST_TEST_EQ( r2.value(), true );
+    }
+}
+
+struct X
+{
+};
+
+int main()
+{
+    test< result<int>, result<bool> >();
+    test< result<int> const, result<bool> >();
+
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool>, result<X>&>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool>, result<X> const&>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool>, result<X>&&>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool>, result<X> const&&>));
+
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool const>, result<X>&>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool const>, result<X> const&>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool const>, result<X>&&>));
+    BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<bool const>, result<X> const&&>));
+
+    return boost::report_errors();
+}