fix: use reference wrappers as ref data members

Author: aminya

src/observer.cc

@@ -370,14 +370,14 @@ void Observer::Initialize(Module& module, Napi::Object& exports) {
 void Observer::Poller::ReadableCallback() {
     assert(read_deferred);
 
-    AsyncScope const scope(socket.Env(), socket.async_context);
-    socket.Receive(take(read_deferred));
+    AsyncScope const scope(socket.get().Env(), socket.get().async_context);
+    socket.get().Receive(take(read_deferred));
 }
 
 Napi::Value Observer::Poller::ReadPromise() {
     assert(!read_deferred);
 
-    read_deferred = Napi::Promise::Deferred(socket.Env());
+    read_deferred = Napi::Promise::Deferred(socket.get().Env());
     return read_deferred->Promise();
 }
 }  // namespace zmq

src/observer.h

@@ -2,6 +2,7 @@
 
 #include <napi.h>
 
+#include <functional>
 #include <optional>
 
 #include "./closable.h"
@@ -38,11 +39,11 @@ class Observer : public Napi::ObjectWrap<Observer>, public Closable {
     force_inline void Receive(const Napi::Promise::Deferred& res);
 
     class Poller : public zmq::Poller<Poller> {
-        Observer& socket;
+        std::reference_wrapper<Observer> socket;
         std::optional<Napi::Promise::Deferred> read_deferred;
 
     public:
-        explicit Poller(Observer& observer) : socket(observer) {}
+        explicit Poller(std::reference_wrapper<Observer> observer) : socket(observer) {}
 
         Napi::Value ReadPromise();
 
@@ -51,7 +52,7 @@ class Observer : public Napi::ObjectWrap<Observer>, public Closable {
         }
 
         [[nodiscard]] bool ValidateReadable() const {
-            return socket.HasEvents();
+            return socket.get().HasEvents();
         }
 
         [[nodiscard]] static bool ValidateWritable() {

src/outgoing_msg.cc

@@ -1,11 +1,12 @@
 
 #include "./outgoing_msg.h"
 
+#include <functional>
 #include "./module.h"
 #include "util/error.h"
 
 namespace zmq {
-OutgoingMsg::OutgoingMsg(Napi::Value value, Module& module) {
+OutgoingMsg::OutgoingMsg(Napi::Value value, std::reference_wrapper<Module> module) {
     static auto constexpr zero_copy_threshold = 1U << 7U;
 
     auto buffer_send = [&](uint8_t* data, size_t length) {
@@ -94,7 +95,7 @@ OutgoingMsg::~OutgoingMsg() {
 }
 
 void OutgoingMsg::Reference::Recycle() {
-    module.MsgTrash.Add(this);
+    module.get().MsgTrash.Add(this);
 }
 
 OutgoingMsg::Parts::Parts(Napi::Value value, Module& module) {

src/outgoing_msg.h

@@ -3,6 +3,7 @@
 #include <napi.h>
 
 #include <forward_list>
+#include <functional>
 
 #include "./zmq_inc.h"
 
@@ -23,7 +24,7 @@ class OutgoingMsg {
     /* Outgoing message. Takes a string or buffer argument and releases
        the underlying V8 resources whenever the message is sent, or earlier
        if the message was copied (small buffers & strings). */
-    explicit OutgoingMsg(Napi::Value value, Module& module);
+    explicit OutgoingMsg(Napi::Value value, std::reference_wrapper<Module> module);
     ~OutgoingMsg();
 
     zmq_msg_t* get() {
@@ -33,10 +34,10 @@ class OutgoingMsg {
 private:
     class Reference {
         Napi::Reference<Napi::Value> persistent;
-        Module& module;
+        std::reference_wrapper<Module> module;
 
     public:
-        explicit Reference(Napi::Value val, Module& module)
+        explicit Reference(Napi::Value val, std::reference_wrapper<Module> module)
             : persistent(Napi::Persistent(val)), module(module) {}
 
         void Recycle();

src/socket.cc

@@ -311,7 +311,7 @@ void Socket::Receive(const Napi::Promise::Deferred& res) {
        followed by a metadata object. */
     auto list = Napi::Array::New(Env(), 1);
 
-    uint32_t i = 0;
+    uint32_t i_part = 0;
     while (true) {
         IncomingMsg part;
         while (zmq_msg_recv(part.get(), socket, ZMQ_DONTWAIT) < 0) {
@@ -321,7 +321,7 @@ void Socket::Receive(const Napi::Promise::Deferred& res) {
             }
         }
 
-        list[i++] = part.IntoBuffer(Env());
+        list[i_part++] = part.IntoBuffer(Env());
 
 #ifdef ZMQ_HAS_POLLABLE_THREAD_SAFE
         switch (type) {
@@ -953,33 +953,33 @@ void Socket::Initialize(Module& module, Napi::Object& exports) {
 
 void Socket::Poller::ReadableCallback() {
     assert(read_deferred);
-    socket.sync_operations = 0;
+    socket.get().sync_operations = 0;
 
-    AsyncScope const scope(socket.Env(), socket.async_context);
-    socket.Receive(take(read_deferred));
+    AsyncScope const scope(socket.get().Env(), socket.get().async_context);
+    socket.get().Receive(take(read_deferred));
 }
 
 void Socket::Poller::WritableCallback() {
     assert(write_deferred);
-    socket.sync_operations = 0;
+    socket.get().sync_operations = 0;
 
-    AsyncScope const scope(socket.Env(), socket.async_context);
-    socket.Send(take(write_deferred), write_value);
+    AsyncScope const scope(socket.get().Env(), socket.get().async_context);
+    socket.get().Send(take(write_deferred), write_value);
     write_value.Clear();
 }
 
 Napi::Value Socket::Poller::ReadPromise() {
     assert(!read_deferred);
 
-    read_deferred = Napi::Promise::Deferred(socket.Env());
+    read_deferred = Napi::Promise::Deferred(socket.get().Env());
     return read_deferred->Promise();
 }
 
 Napi::Value Socket::Poller::WritePromise(OutgoingMsg::Parts&& parts) {
     assert(!write_deferred);
 
     write_value = std::move(parts);
-    write_deferred = Napi::Promise::Deferred(socket.Env());
+    write_deferred = Napi::Promise::Deferred(socket.get().Env());
     return write_deferred->Promise();
 }
 }  // namespace zmq

src/socket.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <functional>
 #include <optional>
 
 #include "./closable.h"
@@ -70,13 +71,13 @@ class Socket : public Napi::ObjectWrap<Socket>, public Closable {
     force_inline void Receive(const Napi::Promise::Deferred& res);
 
     class Poller : public zmq::Poller<Poller> {
-        Socket& socket;
+        std::reference_wrapper<Socket> socket;
         std::optional<Napi::Promise::Deferred> read_deferred;
         std::optional<Napi::Promise::Deferred> write_deferred;
         OutgoingMsg::Parts write_value;
 
     public:
-        explicit Poller(Socket& socket) : socket(socket) {}
+        explicit Poller(std::reference_wrapper<Socket> socket) : socket(socket) {}
 
         Napi::Value ReadPromise();
         Napi::Value WritePromise(OutgoingMsg::Parts&& parts);
@@ -90,11 +91,11 @@ class Socket : public Napi::ObjectWrap<Socket>, public Closable {
         }
 
         [[nodiscard]] bool ValidateReadable() const {
-            return socket.HasEvents(ZMQ_POLLIN);
+            return socket.get().HasEvents(ZMQ_POLLIN);
         }
 
         [[nodiscard]] bool ValidateWritable() const {
-            return socket.HasEvents(ZMQ_POLLOUT);
+            return socket.get().HasEvents(ZMQ_POLLOUT);
         }
 
         void ReadableCallback();

src/util/arguments.h

@@ -61,7 +61,7 @@ using Optional = Verify<F..., Undefined>;
 
 template <typename... F>
 class Validator {
-    static constexpr size_t N = sizeof...(F);
+    static constexpr size_t NumArgs = sizeof...(F);
     std::tuple<F...> validators;
 
 public:
@@ -85,10 +85,10 @@ class Validator {
 private:
     template <size_t I = 0>
     [[nodiscard]] std::optional<Napi::Error> eval(const Napi::CallbackInfo& info) const {
-        if constexpr (I == N) {
-            if (info.Length() > N) {
-                auto msg =
-                    "Expected " + std::to_string(N) + " argument" + (N != 1 ? "s" : "");
+        if constexpr (I == NumArgs) {
+            if (info.Length() > NumArgs) {
+                auto msg = "Expected " + std::to_string(NumArgs) + " argument"
+                    + (NumArgs != 1 ? "s" : "");
                 return Napi::TypeError::New(info.Env(), msg);
             }