Update documentation

doc/system/changes.adoc

@@ -10,10 +10,12 @@ https://www.boost.org/LICENSE_1_0.txt
 
 ## Changes in Boost 1.79
 
-* Added a `throw_exception_from_error` overload for `std::error_code`.
 * Added a `boost::source_location` parameter to `throw_exception_from_error`.
+* Added `throw_exception_from_error` overloads for `errc::errc_t`,
+  `std::error_code`, `std::errc`, `std::exception_ptr`.
 * `result<T>::value` now automatically supplies `BOOST_CURRENT_LOCATION` to
   `throw_exception_from_error` via a default argument.
+* Added an `errc::make_error_code` overload taking a source location.
 
 ## Changes in Boost 1.78
 

doc/system/reference.adoc

@@ -185,9 +185,13 @@ namespace errc {
 template<> struct is_error_condition_enum<errc::errc_t>
   { static const bool value = true; };
 
-constexpr error_code make_error_code( errc::errc_t e ) noexcept;
 constexpr error_condition make_error_condition( errc::errc_t e ) noexcept;
 
+constexpr error_code make_error_code( errc::errc_t e ) noexcept;
+
+error_code make_error_code( errc::errc_t e,
+  boost::source_location const * loc ) noexcept;
+
 } // namespace system
 } // namespace boost
 ```
@@ -256,6 +260,38 @@ void my_api_function( boost::system::error_code& ec )
 }
 ```
 
+```
+constexpr error_code make_error_code( errc::errc_t e,
+  boost::source_location const * loc ) noexcept;
+```
+[none]
+* {blank}
++
+Returns: :: `error_code( e, generic_category(), loc )`.
+
+Same as the above overload, but takes a source location.
+* {blank}
++
+```
+void my_api_function( boost::system::error_code& ec )
+{
+    void* p = std::malloc( 16 );
+
+    if( p == 0 )
+    {
+        // return ENOMEM
+
+        BOOST_STATIC_CONSTEXPR boost::source_location loc =
+          BOOST_CURRENT_LOCATION;
+
+        ec = make_error_code( boost::system::errc::out_of_memory, &loc );
+        return;
+    }
+
+    // use p
+}
+```
+
 ## <boost/system/{zwsp}error_category.hpp>
 
 ### error_category
@@ -1460,6 +1496,15 @@ BOOST_NORETURN inline void throw_exception_from_error( error_code const & e,
 BOOST_NORETURN inline void throw_exception_from_error( std::error_code const & e,
   boost::source_location const & loc );
 
+BOOST_NORETURN inline void throw_exception_from_error( errc::errc_t const & e,
+  boost::source_location const & loc );
+
+BOOST_NORETURN inline void throw_exception_from_error( std::errc const & e,
+  boost::source_location const & loc );
+
+BOOST_NORETURN inline void throw_exception_from_error( std::exception_ptr & e,
+  boost::source_location const & loc );
+
 // in_place_*
 
 using in_place_value_t = /*unspecified*/;
@@ -1497,7 +1542,7 @@ BOOST_NORETURN inline void throw_exception_from_error( error_code const & e,
 * {blank}
 +
 Effects: ::
-  `boost::throw_exception( system_error( e ), loc )`.
+  `boost::throw_with_location( system_error( e ), loc )`.
 
 ```
 BOOST_NORETURN inline void throw_exception_from_error( std::error_code const & e,
@@ -1507,7 +1552,40 @@ BOOST_NORETURN inline void throw_exception_from_error( std::error_code const & e
 * {blank}
 +
 Effects: ::
-  `boost::throw_exception( std::system_error( e ), loc )`.
+  `boost::throw_with_location( std::system_error( e ), loc )`.
+
+```
+BOOST_NORETURN inline void throw_exception_from_error( errc::errc_t const & e,
+  boost::source_location const & loc );
+```
+[none]
+* {blank}
++
+Effects: ::
+  `boost::throw_with_location( system_error( make_error_code( e ) ), loc )`.
+
+```
+BOOST_NORETURN inline void throw_exception_from_error( std::errc const & e,
+  boost::source_location const & loc );
+```
+[none]
+* {blank}
++
+Effects: ::
+  `boost::throw_with_location( std::system_error( make_error_code( e ) ), loc )`.
+
+```
+BOOST_NORETURN inline void throw_exception_from_error( std::exception_ptr & e,
+  boost::source_location const & loc );
+```
+[none]
+* {blank}
++
+Effects: ::
++
+[disc]
+** If `e` isn't null, `std::rethrow_exception( e )`.
+** Otherwise, `boost::throw_with_location( std::bad_exception(), loc )`.
 
 ### result<T, E>
 

include/boost/system/errc.hpp

@@ -16,6 +16,7 @@
 #include <boost/system/detail/generic_category.hpp>
 #include <boost/system/detail/error_category_impl.hpp>
 #include <boost/system/detail/config.hpp>
+#include <boost/assert/source_location.hpp>
 #include <boost/config.hpp>
 
 namespace boost
@@ -35,6 +36,12 @@ BOOST_SYSTEM_CONSTEXPR inline error_code make_error_code( errc_t e ) BOOST_NOEXC
     return error_code( e, generic_category() );
 }
 
+// explicit conversion:
+inline error_code make_error_code( errc_t e, boost::source_location const * loc ) BOOST_NOEXCEPT
+{
+    return error_code( e, generic_category(), loc );
+}
+
 // implicit conversion:
 BOOST_SYSTEM_CONSTEXPR inline error_condition make_error_condition( errc_t e ) BOOST_NOEXCEPT
 {

include/boost/system/result.hpp

@@ -18,6 +18,7 @@
 #include <utility>
 #include <iosfwd>
 #include <system_error>
+#include <exception>
 
 //
 
@@ -35,12 +36,34 @@ namespace system
 
 BOOST_NORETURN BOOST_NOINLINE inline void throw_exception_from_error( error_code const & e, boost::source_location const& loc )
 {
-    boost::throw_exception( system_error( e ), loc );
+    boost::throw_with_location( system_error( e ), loc );
+}
+
+BOOST_NORETURN BOOST_NOINLINE inline void throw_exception_from_error( errc::errc_t const & e, boost::source_location const& loc )
+{
+    boost::throw_with_location( system_error( make_error_code( e ) ), loc );
 }
 
 BOOST_NORETURN BOOST_NOINLINE inline void throw_exception_from_error( std::error_code const & e, boost::source_location const& loc )
 {
-    boost::throw_exception( std::system_error( e ), loc );
+    boost::throw_with_location( std::system_error( e ), loc );
+}
+
+BOOST_NORETURN BOOST_NOINLINE inline void throw_exception_from_error( std::errc const & e, boost::source_location const& loc )
+{
+    boost::throw_with_location( std::system_error( make_error_code( e ) ), loc );
+}
+
+BOOST_NORETURN BOOST_NOINLINE inline void throw_exception_from_error( std::exception_ptr const & p, boost::source_location const& loc )
+{
+    if( p )
+    {
+        std::rethrow_exception( p );
+    }
+    else
+    {
+        boost::throw_with_location( std::bad_exception(), loc );
+    }
 }
 
 #if defined(__GNUC__) && __GNUC__ >= 7 && __GNUC__ <= 8

test/CMakeLists.txt

@@ -116,6 +116,8 @@ boost_test(TYPE run SOURCES ec_wstream_test.cpp)
 
 boost_test(TYPE run SOURCES std_interop_test12.cpp)
 
+boost_test(TYPE run SOURCES errc_test4.cpp)
+
 # result
 
 set(BOOST_TEST_COMPILE_FEATURES cxx_std_11)

test/Jamfile.v2

@@ -140,6 +140,8 @@ run ec_wstream_test.cpp ;
 
 run std_interop_test12.cpp ;
 
+run errc_test4.cpp ;
+
 # result
 
 import ../../config/checks/config : requires ;

test/errc_test4.cpp

@@ -0,0 +1,17 @@
+// Copyright 2022 Peter Dimov.
+// Distributed under the Boost Software License, Version 1.0.
+// http://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/system/errc.hpp>
+#include <boost/assert/source_location.hpp>
+#include <boost/core/lightweight_test.hpp>
+
+int main()
+{
+    BOOST_STATIC_CONSTEXPR boost::source_location loc = BOOST_CURRENT_LOCATION;
+
+    BOOST_TEST( make_error_code( boost::system::errc::no_such_file_or_directory, &loc ).has_location() );
+    BOOST_TEST_EQ( make_error_code( boost::system::errc::no_such_file_or_directory, &loc ).location().to_string(), loc.to_string() );
+
+    return boost::report_errors();
+}

test/result_value_access.cpp

@@ -32,6 +32,10 @@ BOOST_NORETURN void throw_exception_from_error( Y const &, boost::source_locatio
     throw E();
 }
 
+struct E2
+{
+};
+
 int main()
 {
     {
@@ -182,6 +186,62 @@ int main()
         BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
     }
 
+    {
+        result<int, errc::errc_t> const r( in_place_error, errc::invalid_argument );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), system_error );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+    }
+
+    {
+        result<int, std::errc> const r( std::errc::invalid_argument );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), std::system_error );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+    }
+
+    {
+        result<int, std::exception_ptr> const r( std::make_exception_ptr( E2() ) );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), E2 );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+    }
+
+    {
+        result<int, std::exception_ptr> const r( in_place_error );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), std::bad_exception );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<int*>(0) );
+    }
+
     {
         result<X> r( 1 );
 
@@ -374,5 +434,61 @@ int main()
         BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
     }
 
+    {
+        result<void, errc::errc_t> const r( in_place_error, errc::invalid_argument );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), system_error );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+    }
+
+    {
+        result<void, std::errc> const r( std::errc::invalid_argument );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), std::system_error );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+    }
+
+    {
+        result<void, std::exception_ptr> const r( std::make_exception_ptr( E2() ) );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), E2 );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+    }
+
+    {
+        result<void, std::exception_ptr> const r( in_place_error );
+
+        BOOST_TEST( !r.has_value() );
+        BOOST_TEST( r.has_error() );
+
+        BOOST_TEST_NOT( r );
+        BOOST_TEST( !r );
+
+        BOOST_TEST_THROWS( r.value(), std::bad_exception );
+
+        BOOST_TEST_EQ( r.operator->(), static_cast<void*>(0) );
+    }
+
     return boost::report_errors();
 }