refactor: replace SystemError with generic StacktraceError for improved error handling

Author: Hackerl

include/zero/async/promise.h

@@ -77,7 +77,7 @@ namespace zero::async::promise {
             assert(mCore);
 
             if (mRetrieved)
-                throw std::logic_error{"Future already retrieved"};
+                throw error::StacktraceError<std::logic_error>{"Future already retrieved"};
 
             mRetrieved = true;
             return Future<T, E>{mCore};
@@ -107,7 +107,9 @@ namespace zero::async::promise {
             }
 
             if (state != State::OnlyCallback || !mCore->state.compare_exchange_strong(state, State::Done))
-                throw std::logic_error{fmt::format("Unexpected promise state: {}", std::to_underlying(state))};
+                throw error::StacktraceError<std::logic_error>{
+                    fmt::format("Unexpected promise state: {}", std::to_underlying(state))
+                };
 
             mCore->event.set();
             mCore->trigger();
@@ -130,7 +132,9 @@ namespace zero::async::promise {
             }
 
             if (state != State::OnlyCallback || !mCore->state.compare_exchange_strong(state, State::Done))
-                throw std::logic_error{fmt::format("Unexpected promise state: {}", std::to_underlying(state))};
+                throw error::StacktraceError<std::logic_error>{
+                    fmt::format("Unexpected promise state: {}", std::to_underlying(state))
+                };
 
             mCore->event.set();
             mCore->trigger();
@@ -258,7 +262,9 @@ namespace zero::async::promise {
                 return;
 
             if (state != State::OnlyResult || !mCore->state.compare_exchange_strong(state, State::Done))
-                throw std::logic_error{fmt::format("Unexpected promise state: {}", std::to_underlying(state))};
+                throw error::StacktraceError<std::logic_error>{
+                    fmt::format("Unexpected promise state: {}", std::to_underlying(state))
+                };
 
             mCore->trigger();
         }

include/zero/error.h

@@ -653,12 +653,14 @@ namespace zero::error {
 
 namespace zero::error {
 #if defined(__cpp_lib_stacktrace) && __cpp_lib_stacktrace >= 202011L
-    class SystemError final : public std::system_error {
+    template<typename T>
+        requires std::derived_from<T, std::exception>
+    class StacktraceError final : public T {
     public:
         template<typename... Args>
-        explicit SystemError(Args &&... args)
-            : std::system_error{std::forward<Args>(args)...},
-              mMessage{fmt::format("{} {}", std::system_error::what(), std::to_string(std::stacktrace::current(1)))} {
+        explicit StacktraceError(Args &&... args)
+            : T{std::forward<Args>(args)...},
+              mMessage{fmt::format("{} {}", T::what(), std::to_string(std::stacktrace::current(1)))} {
         }
 
         [[nodiscard]] const char *what() const noexcept override {
@@ -669,14 +671,15 @@ namespace zero::error {
         std::string mMessage;
     };
 #else
-    using SystemError = std::system_error;
+    template<typename T>
+    using StacktraceError = T;
 #endif
 
     template<typename T, typename E>
         requires std::is_convertible_v<E, std::error_code>
     T guard(std::expected<T, E> &&expected) {
         if (!expected)
-            throw SystemError{expected.error()};
+            throw StacktraceError<std::system_error>{expected.error()};
 
         if constexpr (std::is_void_v<T>)
             return;

src/env.cpp

@@ -32,7 +32,7 @@ std::optional<std::string> zero::env::get(const std::string &name) {
 
         if (result == 0) {
             if (const auto error = GetLastError(); error != ERROR_ENVVAR_NOT_FOUND)
-                throw error::SystemError{static_cast<int>(error), std::system_category()};
+                throw error::StacktraceError<std::system_error>{static_cast<int>(error), std::system_category()};
 
             return std::nullopt;
         }
@@ -85,7 +85,7 @@ std::map<std::string, std::string> zero::env::list() {
     };
 
     if (!ptr)
-        throw error::SystemError{static_cast<int>(GetLastError()), std::system_category()};
+        throw error::StacktraceError<std::system_error>{static_cast<int>(GetLastError()), std::system_category()};
 
     std::map<std::string, std::string> envs;
 

src/filesystem/fs.cpp

@@ -39,7 +39,7 @@ std::filesystem::path zero::filesystem::applicationPath() {
 
     if (const auto length = GetModuleFileNameW(nullptr, buffer.data(), buffer.size());
         length == 0 || length == buffer.size())
-        throw error::SystemError{static_cast<int>(GetLastError()), std::system_category()};
+        throw error::StacktraceError<std::system_error>{static_cast<int>(GetLastError()), std::system_category()};
 
     return buffer.data();
 #elif defined(__linux__)

src/os/net.cpp

@@ -37,9 +37,9 @@ std::string zero::os::net::stringify(const std::span<const std::byte, 4> ip) {
 
     if (!inet_ntop(AF_INET, ip.data(), address.data(), address.size())) {
 #ifdef _WIN32
-        throw error::SystemError{WSAGetLastError(), std::system_category()};
+        throw error::StacktraceError<std::system_error>{WSAGetLastError(), std::system_category()};
 #else
-        throw error::SystemError{errno, std::system_category()};
+        throw error::StacktraceError<std::system_error>{errno, std::system_category()};
 #endif
     }
 
@@ -51,9 +51,9 @@ std::string zero::os::net::stringify(const std::span<const std::byte, 16> ip) {
 
     if (!inet_ntop(AF_INET6, ip.data(), address.data(), address.size())) {
 #ifdef _WIN32
-        throw error::SystemError{WSAGetLastError(), std::system_category()};
+        throw error::StacktraceError<std::system_error>{WSAGetLastError(), std::system_category()};
 #else
-        throw error::SystemError{errno, std::system_category()};
+        throw error::StacktraceError<std::system_error>{errno, std::system_category()};
 #endif
     }
 

src/os/process.cpp

@@ -807,7 +807,7 @@ zero::os::process::Command::spawn(const std::array<StdioType, 3> &defaultTypes)
             const auto handle = GetStdHandle(typeMapping[i]);
 
             if (handle == INVALID_HANDLE_VALUE)
-                throw error::SystemError{static_cast<int>(GetLastError()), std::system_category()};
+                throw error::StacktraceError<std::system_error>{static_cast<int>(GetLastError()), std::system_category()};
 
             if (!handle)
                 continue;

src/os/windows/process.cpp

@@ -190,7 +190,7 @@ std::expected<std::vector<std::string>, std::error_code> zero::os::windows::proc
 
     Z_DEFER(
         if (LocalFree(args))
-            throw error::SystemError{static_cast<int>(GetLastError()), std::system_category()};
+            throw error::StacktraceError<std::system_error>{static_cast<int>(GetLastError()), std::system_category()};
     );
 
     std::vector<std::string> cmdline;

src/strings/strings.cpp

@@ -139,7 +139,7 @@ zero::strings::encode(const std::wstring_view str, const std::string &encoding)
 
     Z_DEFER(
         if (iconv_close(cd) != 0)
-            throw error::SystemError{errno, std::generic_category()};
+            throw error::StacktraceError<std::system_error>{errno, std::generic_category()};
     );
 
     std::string output;
@@ -171,7 +171,7 @@ zero::strings::decode(const std::string_view str, const std::string &encoding) {
 
     Z_DEFER(
         if (iconv_close(cd) != 0)
-            throw error::SystemError{errno, std::generic_category()};
+            throw error::StacktraceError<std::system_error>{errno, std::generic_category()};
     );
 
     std::wstring output;

src/utility.cpp

@@ -6,10 +6,10 @@ std::tm zero::localTime(const std::time_t time) {
 
 #ifdef _WIN32
     if (const auto result = localtime_s(&tm, &time); result != 0)
-        throw error::SystemError{result, std::generic_category()};
+        throw error::StacktraceError<std::system_error>{result, std::generic_category()};
 #else
     if (!localtime_r(&time, &tm))
-        throw error::SystemError{errno, std::generic_category()};
+        throw error::StacktraceError<std::system_error>{errno, std::generic_category()};
 #endif
 
     return tm;