Enable implicit construction when the alternative is explicitly constructible from the argument. Fixes #103.

include/boost/system/detail/error_category_impl.hpp

@@ -106,18 +106,6 @@ namespace boost
 namespace system
 {
 
-namespace detail
-{
-
-template<class = void> struct stdcat_mx_holder
-{
-    static mutex mx_;
-};
-
-template<class T> mutex stdcat_mx_holder<T>::mx_;
-
-} // namespace detail
-
 inline void error_category::init_stdcat() const
 {
     static_assert( sizeof( stdcat_ ) >= sizeof( boost::system::detail::std_category ), "sizeof(stdcat_) is not enough for std_category" );
@@ -130,7 +118,13 @@ inline void error_category::init_stdcat() const
 
 #endif
 
-    system::detail::lock_guard<system::detail::mutex> lk( system::detail::stdcat_mx_holder<>::mx_ );
+    // detail::mutex has a constexpr default constructor,
+    // and therefore guarantees static initialization, on
+    // everything except VS 2013 (msvc-12.0)
+
+    static system::detail::mutex mx_;
+
+    system::detail::lock_guard<system::detail::mutex> lk( mx_ );
 
     if( sc_init_.load( std::memory_order_acquire ) == 0 )
     {

include/boost/system/detail/mutex.hpp

@@ -31,6 +31,28 @@ struct mutex
 } // namespace system
 } // namespace boost
 
+#elif defined(BOOST_MSSTL_VERSION) && BOOST_MSSTL_VERSION >= 140
+
+// Under the MS STL, std::mutex::mutex() is not constexpr, as is
+// required by the standard, which leads to initialization order
+// issues. However, shared_mutex is based on SRWLock and its
+// default constructor is constexpr, so we use that instead.
+
+#include <shared_mutex>
+
+namespace boost
+{
+namespace system
+{
+namespace detail
+{
+
+typedef std::shared_mutex mutex;
+
+} // namespace detail
+} // namespace system
+} // namespace boost
+
 #else
 
 #include <mutex>

include/boost/system/result.hpp

@@ -122,7 +122,7 @@ public:
     template<class A = T, typename std::enable_if<
         std::is_convertible<A, T>::value &&
         !(detail::is_errc_t<A>::value && std::is_arithmetic<T>::value) &&
-        !std::is_constructible<E, A>::value, int>::type = 0>
+        !std::is_convertible<A, E>::value, int>::type = 0>
     constexpr result( A&& a )
         noexcept( std::is_nothrow_constructible<T, A>::value )
         : v_( in_place_value, std::forward<A>(a) )
@@ -132,7 +132,7 @@ public:
     // implicit, error
     template<class A = E, class = void, typename std::enable_if<
         std::is_convertible<A, E>::value &&
-        !std::is_constructible<T, A>::value, int>::type = 0>
+        !std::is_convertible<A, T>::value, int>::type = 0>
     constexpr result( A&& a )
         noexcept( std::is_nothrow_constructible<E, A>::value )
         : v_( in_place_error, std::forward<A>(a) )

test/CMakeLists.txt

@@ -134,6 +134,8 @@ boost_test(TYPE run SOURCES win32_generic_test.cpp)
 
 boost_test(TYPE run SOURCES ec_hash_value_test.cpp)
 
+boost_test(TYPE run SOURCES std_interop_test16.cpp)
+
 # result
 
 set(BOOST_TEST_COMPILE_FEATURES cxx_std_11)
@@ -152,7 +154,10 @@ boost_test(TYPE run SOURCES result_eq.cpp)
 boost_test(TYPE run SOURCES result_range_for.cpp)
 boost_test(TYPE run SOURCES result_value_construct2.cpp)
 boost_test(TYPE run SOURCES result_error_construct2.cpp)
+boost_test(TYPE run SOURCES result_errc_construct.cpp)
 boost_test(TYPE run SOURCES result_convert_construct.cpp)
 boost_test(TYPE run SOURCES result_typedefs.cpp)
 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)

test/Jamfile.v2

@@ -162,6 +162,8 @@ run win32_generic_test.cpp ;
 
 run ec_hash_value_test.cpp ;
 
+run std_interop_test16.cpp ;
+
 # result
 
 import ../../config/checks/config : requires ;
@@ -188,3 +190,4 @@ run result_typedefs.cpp : : : $(CPP11) ;
 run result_value_construct3.cpp : : : $(CPP11) ;
 run result_error_construct3.cpp : : : $(CPP11) ;
 run result_emplace.cpp : : : $(CPP11) ;
+run result_error_construct4.cpp : : : $(CPP11) ;

test/result_error_construct.cpp

@@ -146,8 +146,14 @@ int main()
         BOOST_TEST_TRAIT_TRUE((std::is_constructible<result<std::string, X>, int>));
         BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<std::string, X>>));
 
-        BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int, X>, int>));
-        BOOST_TEST_TRAIT_FALSE((std::is_convertible<int, result<int, X>>));
+        // We'd like this to be false due to the ambiguity caused by X having
+        // an explicit constructor taking an int, which should be viable in this
+        // context, but the implicit constructor is enabled, and there's no way to
+        // disallow it
+        //
+        // BOOST_TEST_TRAIT_FALSE((std::is_constructible<result<int, X>, int>));
+
+        BOOST_TEST_TRAIT_TRUE((std::is_convertible<int, result<int, X>>));
     }
 
     {

test/result_error_construct4.cpp

@@ -0,0 +1,49 @@
+// 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;
+
+// Eigen::Matrix4d has an explicit templated constructor
+// https://github.com/boostorg/system/issues/103
+// https://github.com/boostorg/json/issues/843
+
+struct X
+{
+    X() {}
+    template<class T> explicit X( T const& ) {}
+};
+
+int main()
+{
+    {
+        auto ec = make_error_code( errc::invalid_argument );
+
+        result<X> r = ec;
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+#if defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+    {
+        auto ec = make_error_code( std::errc::invalid_argument );
+
+        result<X> r = ec;
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_EQ( r.error(), ec );
+    }
+
+#endif
+
+    return boost::report_errors();
+}

test/std_interop_test16.cpp

@@ -0,0 +1,57 @@
+// Copyright 2023 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/error_category.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if !defined(BOOST_SYSTEM_HAS_SYSTEM_ERROR)
+
+BOOST_PRAGMA_MESSAGE( "BOOST_SYSTEM_HAS_SYSTEM_ERROR not defined, test will be skipped" )
+int main() {}
+
+#else
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/core/snprintf.hpp>
+#include <system_error>
+
+// get_user_category
+
+class user_category: public boost::system::error_category
+{
+public:
+
+    virtual const char * name() const BOOST_NOEXCEPT
+    {
+        return "user";
+    }
+
+    virtual std::string message( int ev ) const
+    {
+        char buffer[ 256 ];
+        boost::core::snprintf( buffer, sizeof( buffer ), "user message %d", ev );
+
+        return buffer;
+    }
+};
+
+boost::system::error_category const & get_user_category()
+{
+    static user_category instance;
+    return instance;
+}
+
+//
+
+bool init_lwt = (boost::core::lwt_init(), true);
+
+std::error_category const & cat = get_user_category();
+
+int main()
+{
+    BOOST_TEST_CSTR_EQ( cat.name(), "user" );
+    return boost::report_errors();
+}
+
+#endif