rework error handling

Author: jll63

docs.in/reference/set_error_handler.cpp

@@ -1,20 +1,24 @@
 #ifdef YOMM2_MD
-headers: yorel/yomm2/core.hpp, yorel/yomm2.hpp, yorel/yomm2.hpp
+headers : yorel / yomm2 / core.hpp, yorel / yomm2.hpp,
+    yorel /
+    yomm2.hpp
 
-```c++
-error_handler_type set_error_handler(error_handler_type handler);
+```c++ error_handler_type set_error_handler(error_handler_type handler);
 ```
 
-All errors are reported via an indirect call to a handler, passing it a
-`std::variant` that identifies the specific error. The handler can be set to
-a user-defined function with `set_error_handler`. The library calls `abort()`
-immediately after calling the handler, but the handler can prevent program
-termination by throwing an exception. The default handler writes an error
-message to `stderr` in debug mode.
+    All errors are reported via an indirect call to a handler,
+    passing it a
+`std::variant` that identifies the specific error.The
+        handler can be set to a user -
+    defined function with `set_error_handler`.The
+        library calls `abort()` immediately after calling the handler,
+    but the handler can prevent program termination by throwing an exception
+        .The default handler writes an error message to `stderr` in debug mode
+        .
 
 `set_error_handler` returns the previous handler.
 
-## Example
+    ##Example
 
 #endif
 
@@ -30,7 +34,7 @@ message to `stderr` in debug mode.
 #include <yorel/yomm2.hpp>
 #include <yorel/yomm2/compiler.hpp>
 
-struct Animal {
+    struct Animal {
     virtual ~Animal() {
     }
 };
@@ -43,9 +47,9 @@ declare_method(void, kick, (virtual_<Animal&>));
 
 using namespace yorel::yomm2; // for brevity
 
-error_handler_type next_error_handler;
+default_policy::error_handler_type next_error_handler;
 
-void no_definition_handler(const error_type& ev) {
+void no_definition_handler(const default_policy::error_variant& ev) {
     if (auto error = std::get_if<resolution_error>(&ev)) {
         if (error->status == resolution_error::no_definition) {
             throw std::runtime_error("not defined");
@@ -56,7 +60,8 @@ void no_definition_handler(const error_type& ev) {
 }
 
 BOOST_AUTO_TEST_CASE(ref_set_error_handler_example) {
-    next_error_handler = set_error_handler(no_definition_handler);
+    next_error_handler =
+        default_policy::set_error_handler(no_definition_handler);
     update();
 
     try {

include/yorel/yomm2/core.hpp

@@ -892,9 +892,9 @@ method<Name, Return(Parameters...), Options...>::vptr(const ArgType& arg) const
 template<
     typename Name, typename Return, typename... Parameters, class... Options>
 template<class Error>
-inline void
+inline auto
 method<Name, Return(Parameters...), Options...>::check_static_offset(
-    std::size_t actual, std::size_t expected) const noexcept(NoExcept) {
+    std::size_t actual, std::size_t expected) const noexcept(NoExcept) -> void {
     using namespace detail;
 
     if (actual != expected) {
@@ -903,7 +903,7 @@ method<Name, Return(Parameters...), Options...>::check_static_offset(
             error.method = Policy::template static_type<method>();
             error.expected = this->slots_strides[0];
             error.actual = actual;
-            Policy::error(error_type(std::move(error)));
+            Policy::error(error);
 
             abort();
         }
@@ -1059,7 +1059,7 @@ method<Name, Return(Parameters...), Options...>::not_implemented_handler(
         std::copy_n(
             types, (std::min)(sizeof...(args), resolution_error::max_types),
             &error.types[0]);
-        Policy::error(error_type(std::move(error)));
+        Policy::error(error);
     }
 
     abort(); // in case user handler "forgets" to abort
@@ -1081,7 +1081,7 @@ method<Name, Return(Parameters...), Options...>::ambiguous_handler(
         std::copy_n(
             types, (std::min)(sizeof...(args), resolution_error::max_types),
             &error.types[0]);
-        Policy::error(error_type(std::move(error)));
+        Policy::error(error);
     }
 
     abort(); // in case user handler "forgets" to abort
@@ -1152,18 +1152,6 @@ struct method_macro_aux<Name, Signature, types<Options...>> {
 
 } // namespace detail
 
-#ifndef BOOST_NO_RTTI
-
-inline auto set_error_handler(error_handler_type handler)
-    -> error_handler_type {
-    auto p = &default_policy::error;
-    auto prev = default_policy::error;
-    default_policy::error = handler;
-    return prev;
-}
-
-#endif
-
 } // namespace yomm2
 } // namespace yorel
 

include/yorel/yomm2/detail/compiler.hpp

@@ -413,7 +413,7 @@ void compiler<Policy>::augment_classes() {
 
                 if constexpr (Policy::template has_facet<
                                   policies::error_handler>) {
-                    Policy::error(error_type(error));
+                    Policy::error(error);
                 }
 
                 abort();
@@ -554,7 +554,7 @@ void compiler<Policy>::augment_methods() {
                 error.type = ti;
 
                 if constexpr (has_facet<Policy, error_handler>) {
-                    Policy::error(error_type(error));
+                    Policy::error(error);
                 }
 
                 abort();
@@ -599,7 +599,7 @@ void compiler<Policy>::augment_methods() {
                     error.type = type;
 
                     if constexpr (has_facet<Policy, error_handler>) {
-                        Policy::error(error_type(error));
+                        Policy::error(error);
                     }
 
                     abort();

include/yorel/yomm2/policies/core.hpp

@@ -70,24 +70,6 @@ struct static_offset_error : error {
 struct static_slot_error : static_offset_error {};
 struct static_stride_error : static_offset_error {};
 
-using error_type = std::variant<
-    error, resolution_error, unknown_class_error, hash_search_error,
-    method_table_error, static_slot_error, static_stride_error>;
-
-using error_handler_type = std::function<void(const error_type& error)>;
-
-// deprecated
-
-struct method_call_error {
-    resolution_error::status_type code;
-    static constexpr auto not_implemented = resolution_error::no_definition;
-    static constexpr auto ambiguous = resolution_error::ambiguous;
-    std::string_view method_name;
-};
-
-using method_call_error_handler =
-    void (*)(const method_call_error& error, std::size_t arity, type_id* types);
-
 namespace policies {
 
 struct abstract_policy {};

include/yorel/yomm2/policies/fast_perfect_hash.hpp

@@ -143,7 +143,7 @@ void fast_perfect_hash<Policy>::hash_initialize(
     error.buckets = 1 << M;
 
     if constexpr (has_facet<Policy, error_handler>) {
-        Policy::error(error_type(error));
+        Policy::error(error);
     }
 
     abort();

include/yorel/yomm2/policies/throw_error.hpp

@@ -14,8 +14,9 @@ namespace yomm2 {
 namespace policies {
 
 struct yOMM2_API_gcc throw_error : virtual error_handler {
-    static void error(const error_type& error_v) {
-        std::visit([](auto&& arg) { throw arg; }, error_v);
+    template<class Error>
+    static auto error(const Error& error) {
+        throw error;
     }
 };
 

include/yorel/yomm2/policies/vectored_error.hpp renamed to include/yorel/yomm2/policies/vectored_error_handler.hpp

@@ -13,11 +13,29 @@ namespace yorel {
 namespace yomm2 {
 namespace policies {
 
-template<class Policy, typename DefaultHandlerProvider = void>
-struct yOMM2_API_gcc vectored_error : virtual error_handler {
-    static error_handler_type error;
+template<class Policy>
+struct yOMM2_API_gcc vectored_error_handler : virtual error_handler {
 
-    static void default_error_handler(const error_type& error_v) {
+    using error_variant = std::variant<
+        error, resolution_error, unknown_class_error, hash_search_error,
+        method_table_error, static_slot_error, static_stride_error>;
+
+    using error_handler_type = std::function<void(const error_variant& error)>;
+    static error_handler_type error_handler;
+
+    template<class Error>
+    static auto error(const Error& error) {
+        error_handler(error_variant(error));
+    }
+
+    static auto set_error_handler(error_handler_type handler) {
+        auto prev = error_handler;
+        error_handler = handler;
+
+        return error_handler;
+    }
+
+    static auto default_error_handler(const error_variant& error_v) {
         using namespace detail;
         using namespace policies;
 
@@ -59,11 +77,10 @@ struct yOMM2_API_gcc vectored_error : virtual error_handler {
     }
 };
 
-template<class Policy, typename DefaultHandlerProvider>
-error_handler_type vectored_error<Policy, DefaultHandlerProvider>::error =
-    std::conditional_t<
-        std::is_same_v<DefaultHandlerProvider, void>, vectored_error<Policy>,
-        DefaultHandlerProvider>::default_error_handler;
+template<class Policy>
+typename vectored_error_handler<Policy>::error_handler_type
+    vectored_error_handler<Policy>::error_handler =
+        vectored_error_handler<Policy>::default_error_handler;
 
 } // namespace policies
 } // namespace yomm2

include/yorel/yomm2/policy.hpp

@@ -21,7 +21,7 @@
 #include <yorel/yomm2/policies/basic_error_output.hpp>
 #include <yorel/yomm2/policies/basic_trace_output.hpp>
 #include <yorel/yomm2/policies/fast_perfect_hash.hpp>
-#include <yorel/yomm2/policies/vectored_error.hpp>
+#include <yorel/yomm2/policies/vectored_error_handler.hpp>
 
 #ifndef BOOST_NO_EXCEPTIONS
 #include <yorel/yomm2/policies/throw_error.hpp>
@@ -34,13 +34,13 @@ namespace policies {
 struct yOMM2_API_gcc release
     : basic_policy<
           release, std_rtti, fast_perfect_hash<release>, vptr_vector<release>,
-          vectored_error<release>> {};
+          vectored_error_handler<release>> {};
 
 struct yOMM2_API_gcc debug
     : basic_policy<
           debug, std_rtti, checked_perfect_hash<debug>, vptr_vector<debug>,
           basic_error_output<debug>, basic_trace_output<debug>,
-          vectored_error<debug>> {};
+          vectored_error_handler<debug>> {};
 
 } // namespace policies
 

tests/test_blackbox.cpp

@@ -262,7 +262,7 @@ YOMM2_DEFINE(void, times, (const diagonal_matrix&, const matrix&)) {
 YOMM2_DEFINE(void, times, (const matrix&, const diagonal_matrix&)) {
 }
 
-void test_handler(const error_type& error_v) {
+void test_handler(const default_policy::error_variant& error_v) {
     if (auto error = std::get_if<resolution_error>(&error_v)) {
         throw *error;
     }
@@ -278,46 +278,6 @@ void test_handler(const error_type& error_v) {
     throw int();
 }
 
-BOOST_AUTO_TEST_CASE(call_error_handling) {
-    update();
-
-    auto prev_handler = set_error_handler(test_handler);
-
-    try {
-        times(dense_matrix(), dense_matrix());
-        BOOST_FAIL("did not throw");
-    } catch (const resolution_error& error) {
-        BOOST_TEST(error.status == resolution_error::no_definition);
-    } catch (...) {
-        BOOST_FAIL("unexpected exception");
-    }
-
-    try {
-        times(diagonal_matrix(), diagonal_matrix());
-        BOOST_FAIL("did not throw");
-    } catch (const resolution_error& error) {
-        BOOST_TEST(error.status == resolution_error::ambiguous);
-    } catch (...) {
-        BOOST_FAIL("unexpected exception");
-    }
-
-#ifndef NDEBUG
-    struct identity_matrix : matrix {};
-
-    try {
-        times(diagonal_matrix(), identity_matrix());
-        BOOST_FAIL("did not throw");
-    } catch (const unknown_class_error& error) {
-        BOOST_TEST(
-            error.type == reinterpret_cast<type_id>(&typeid(identity_matrix)));
-    } catch (...) {
-        BOOST_FAIL("unexpected exception");
-    }
-#endif
-
-    set_error_handler(prev_handler);
-}
-
 } // namespace errors
 
 namespace update_error_handling {
@@ -332,17 +292,16 @@ struct base {
 YOMM2_DECLARE(void, foo, (virtual_<base&>), test_policy);
 
 BOOST_AUTO_TEST_CASE(test_update_error_handling) {
-    auto prev_handler = test_policy::error;
-    test_policy::error = errors::test_handler;
+    auto prev_handler = test_policy::set_error_handler(errors::test_handler);
 
     try {
         update<test_policy>();
     } catch (const unknown_class_error& error) {
-        test_policy::error = prev_handler;
+        test_policy::set_error_handler(prev_handler);
         BOOST_TEST(error.type == reinterpret_cast<type_id>(&typeid(base)));
         return;
     } catch (...) {
-        test_policy::error = prev_handler;
+        test_policy::set_error_handler(prev_handler);
         BOOST_FAIL("unexpected exception");
     }
     BOOST_FAIL("did not throw");