refactor: Remove DestructorCatcher and AsyncCallable

Use kj::Function instead of std::function to avoid the need for AsyncCallable
and DestructorCatcher classes, which were used to work around the requirement
that std::function objects need to be copyable. kj::Function does not have this
requirement.

Change is from bitcoin-core#144 (comment)

Co-authored-by: Ryan Ofsky <[email protected]>

Author: vasild

include/mp/proxy-io.h

@@ -14,9 +14,10 @@
 
 #include <assert.h>
 #include <functional>
-#include <optional>
+#include <kj/function.h>
 #include <map>
 #include <memory>
+#include <optional>
 #include <sstream>
 #include <string>
 
@@ -166,15 +167,15 @@ class EventLoop
 
     //! Run function on event loop thread. Does not return until function completes.
     //! Must be called while the loop() function is active.
-    void post(const std::function<void()>& fn);
+    void post(kj::Function<void()> fn);
 
     //! Wrapper around EventLoop::post that takes advantage of the
     //! fact that callable will not go out of scope to avoid requirement that it
     //! be copyable.
     template <typename Callable>
     void sync(Callable&& callable)
     {
-        post(std::ref(callable));
+        post(std::forward<Callable>(callable));
     }
 
     //! Start asynchronous worker thread if necessary. This is only done if
@@ -214,7 +215,7 @@ class EventLoop
     std::thread m_async_thread;
 
     //! Callback function to run on event loop thread during post() or sync() call.
-    const std::function<void()>* m_post_fn = nullptr;
+    kj::Function<void()>* m_post_fn = nullptr;
 
     //! Callback functions to run on async thread.
     CleanupList m_async_fns;
@@ -282,11 +283,9 @@ struct Waiter
             // in the case where a capnp response is sent and a brand new
             // request is immediately received.
             while (m_fn) {
-                auto fn = std::move(m_fn);
-                m_fn = nullptr;
-                lock.unlock();
-                fn();
-                lock.lock();
+                auto fn = std::move(*m_fn);
+                m_fn.reset();
+                Unlock(lock, fn);
             }
             const bool done = pred();
             return done;
@@ -295,7 +294,7 @@ struct Waiter
 
     std::mutex m_mutex;
     std::condition_variable m_cv;
-    std::function<void()> m_fn;
+    std::optional<kj::Function<void()>> m_fn;
 };
 
 //! Object holding network & rpc state associated with either an incoming server

include/mp/type-context.h

@@ -64,8 +64,7 @@ auto PassField(Priority<1>, TypeList<>, ServerContext& server_context, const Fn&
     auto future = kj::newPromiseAndFulfiller<typename ServerContext::CallContext>();
     auto& server = server_context.proxy_server;
     int req = server_context.req;
-    auto invoke = MakeAsyncCallable(
-        [fulfiller = kj::mv(future.fulfiller),
+    auto invoke = [fulfiller = kj::mv(future.fulfiller),
          call_context = kj::mv(server_context.call_context), &server, req, fn, args...]() mutable {
                 const auto& params = call_context.getParams();
                 Context::Reader context_arg = Accessor::get(params);
@@ -143,14 +142,14 @@ auto PassField(Priority<1>, TypeList<>, ServerContext& server_context, const Fn&
                         fulfiller_dispose->reject(kj::mv(*exception));
                     });
                 }
-            });
+            };
 
     // Lookup Thread object specified by the client. The specified thread should
     // be a local Thread::Server object, but it needs to be looked up
     // asynchronously with getLocalServer().
     auto thread_client = context_arg.getThread();
     return server.m_context.connection->m_threads.getLocalServer(thread_client)
-        .then([&server, invoke, req](const kj::Maybe<Thread::Server&>& perhaps) {
+        .then([&server, invoke = kj::mv(invoke), req](const kj::Maybe<Thread::Server&>& perhaps) mutable {
             // Assuming the thread object is found, pass it a pointer to the
             // `invoke` lambda above which will invoke the function on that
             // thread.

include/mp/util.h

@@ -161,6 +161,7 @@ void Unlock(Lock& lock, Callback&& callback)
     callback();
 }
 
+<<<<<<< HEAD
 //! Needed for libc++/macOS compatibility. Lets code work with shared_ptr nothrow declaration
 //! https://github.com/capnproto/capnproto/issues/553#issuecomment-328554603
 template <typename T>
@@ -201,6 +202,49 @@ AsyncCallable<std::remove_reference_t<Callable>> MakeAsyncCallable(Callable&& ca
     return std::forward<Callable>(callable);
 }
 
+||||||| parent of 4b02963 (refactor: Remove DestructorCatcher and AsyncCallable)
+//! Needed for libc++/macOS compatibility. Lets code work with shared_ptr nothrow declaration
+//! https://github.com/capnproto/capnproto/issues/553#issuecomment-328554603
+template <typename T>
+struct DestructorCatcher
+{
+    T value;
+    template <typename... Params>
+    DestructorCatcher(Params&&... params) : value(kj::fwd<Params>(params)...)
+    {
+    }
+    ~DestructorCatcher() noexcept try {
+    } catch (const kj::Exception& e) { // NOLINT(bugprone-empty-catch)
+    }
+};
+
+//! Wrapper around callback function for compatibility with std::async.
+//!
+//! std::async requires callbacks to be copyable and requires noexcept
+//! destructors, but this doesn't work well with kj types which are generally
+//! move-only and not noexcept.
+template <typename Callable>
+struct AsyncCallable
+{
+    AsyncCallable(Callable&& callable) : m_callable(std::make_shared<DestructorCatcher<Callable>>(std::move(callable)))
+    {
+    }
+    AsyncCallable(const AsyncCallable&) = default;
+    AsyncCallable(AsyncCallable&&) = default;
+    ~AsyncCallable() noexcept = default;
+    ResultOf<Callable> operator()() const { return (m_callable->value)(); }
+    mutable std::shared_ptr<DestructorCatcher<Callable>> m_callable;
+};
+
+//! Construct AsyncCallable object.
+template <typename Callable>
+AsyncCallable<std::remove_reference_t<Callable>> MakeAsyncCallable(Callable&& callable)
+{
+    return std::move(callable);
+}
+
+=======
+>>>>>>> 4b02963 (refactor: Remove DestructorCatcher and AsyncCallable)
 //! Format current thread name as "{exe_name}-{$pid}/{thread_name}-{$tid}".
 std::string ThreadName(const char* exe_name);
 

src/mp/proxy.cpp

@@ -22,6 +22,7 @@
 #include <kj/common.h>
 #include <kj/debug.h>
 #include <kj/exception.h>
+#include <kj/function.h>
 #include <kj/memory.h>
 #include <map>
 #include <memory>
@@ -246,7 +247,7 @@ void EventLoop::loop()
     m_post_fd = -1;
 }
 
-void EventLoop::post(const std::function<void()>& fn)
+void EventLoop::post(kj::Function<void()> fn)
 {
     if (std::this_thread::get_id() == m_thread_id) {
         fn();