fix: explicit conversions for getting uv handles

Author: aminya

src/poller.h

@@ -28,17 +28,17 @@ class Poller {
         auto* loop = UvLoop(env);
 
         poll->data = this;
-        if (auto err = uv_poll_init_socket(loop, poll, fd); err != 0) {
+        if (auto err = uv_poll_init_socket(loop, poll.get(), fd); err != 0) {
             return err;
         }
 
         readable_timer->data = this;
-        if (auto err = uv_timer_init(loop, readable_timer); err != 0) {
+        if (auto err = uv_timer_init(loop, readable_timer.get()); err != 0) {
             return err;
         }
 
         writable_timer->data = this;
-        if (auto err = uv_timer_init(loop, writable_timer); err != 0) {
+        if (auto err = uv_timer_init(loop, writable_timer.get()); err != 0) {
             return err;
         }
 
@@ -72,7 +72,7 @@ class Poller {
 
         if (timeout > 0) {
             [[maybe_unused]] auto err = uv_timer_start(
-                readable_timer,
+                readable_timer.get(),
                 [](uv_timer_t* timer) {
                     auto& poller = *reinterpret_cast<Poller*>(timer->data);
                     poller.Trigger(UV_READABLE);
@@ -84,7 +84,7 @@ class Poller {
 
         if (events == 0) {
             /* Only start polling if we were not polling already. */
-            [[maybe_unused]] auto err = uv_poll_start(poll, UV_READABLE, Callback);
+            [[maybe_unused]] auto err = uv_poll_start(poll.get(), UV_READABLE, Callback);
             assert(err == 0);
         }
 
@@ -96,7 +96,7 @@ class Poller {
 
         if (timeout > 0) {
             [[maybe_unused]] auto err = uv_timer_start(
-                writable_timer,
+                writable_timer.get(),
                 [](uv_timer_t* timer) {
                     auto& poller = *reinterpret_cast<Poller*>(timer->data);
                     poller.Trigger(UV_WRITABLE);
@@ -110,7 +110,7 @@ class Poller {
            events on the socket in an edge-triggered fashion by making the
            file descriptor become ready for READING." */
         if (events == 0) {
-            [[maybe_unused]] auto err = uv_poll_start(poll, UV_READABLE, Callback);
+            [[maybe_unused]] auto err = uv_poll_start(poll.get(), UV_READABLE, Callback);
             assert(err == 0);
         }
 
@@ -142,18 +142,18 @@ class Poller {
     void Trigger(uint32_t triggered) {
         events &= ~triggered;
         if (events == 0) {
-            [[maybe_unused]] auto err = uv_poll_stop(poll);
+            [[maybe_unused]] auto err = uv_poll_stop(poll.get());
             assert(err == 0);
         }
 
         if ((triggered & UV_READABLE) != 0) {
-            [[maybe_unused]] auto err = uv_timer_stop(readable_timer);
+            [[maybe_unused]] auto err = uv_timer_stop(readable_timer.get());
             assert(err == 0);
             static_cast<T*>(this)->ReadableCallback();
         }
 
         if ((triggered & UV_WRITABLE) != 0) {
-            [[maybe_unused]] auto err = uv_timer_stop(writable_timer);
+            [[maybe_unused]] auto err = uv_timer_stop(writable_timer.get());
             assert(err == 0);
             static_cast<T*>(this)->WritableCallback();
         }

src/util/trash.h

@@ -29,12 +29,12 @@ class Trash {
             reinterpret_cast<Trash*>(async->data)->Clear();
         };
 
-        [[maybe_unused]] auto err = uv_async_init(loop, async, clear);
+        [[maybe_unused]] auto err = uv_async_init(loop, async.get(), clear);
         assert(err == 0);
 
         /* Immediately unreference this handle in order to prevent the async
            callback from preventing the Node.js process to exit. */
-        uv_unref(this->async);
+        uv_unref(this->async.get_handle());
     }
 
     /* Add given item to the trash, marking it for deletion next time the
@@ -47,7 +47,7 @@ class Trash {
            that calls are coalesced if they occur frequently. This is good
            news for us, since that means frequent additions do not cause
            unnecessary trash cycle operations. */
-        [[maybe_unused]] auto err = uv_async_send(this->async);
+        [[maybe_unused]] auto err = uv_async_send(this->async.get());
         assert(err == 0);
     }
 

src/util/uvdelayed.h

@@ -17,22 +17,22 @@ class UvDelayed {
         [[maybe_unused]] int32_t err = 0;
 
         check->data = this;
-        err = uv_check_init(loop, check);
+        err = uv_check_init(loop, check.get());
         assert(err == 0);
 
         idle->data = this;
-        err = uv_idle_init(loop, idle);
+        err = uv_idle_init(loop, idle.get());
         assert(err == 0);
     }
 
     void Schedule() {
         [[maybe_unused]] int32_t err = 0;
 
         /* Idle handle is needed to stop the event loop from blocking in poll. */
-        err = uv_idle_start(idle, []([[maybe_unused]] uv_idle_t* idle) {});
+        err = uv_idle_start(idle.get(), []([[maybe_unused]] uv_idle_t* idle) {});
         assert(err == 0);
 
-        err = uv_check_start(check, [](uv_check_t* check) {
+        err = uv_check_start(check.get(), [](uv_check_t* check) {
             auto& immediate = *reinterpret_cast<UvDelayed*>(check->data);
             immediate.check.reset();
             immediate.idle.reset();

src/util/uvhandle.h

@@ -35,18 +35,15 @@ class UvHandle : handle_ptr<T> {
     using handle_ptr<T>::reset;
     using handle_ptr<T>::operator->;
 
-    // NOLINTNEXTLINE(*-explicit-*)
-    inline operator bool() {
+    explicit operator bool() {
         return handle_ptr<T>::operator bool() && handle_ptr<T>::get()->type != 0;
     }
 
-    // NOLINTNEXTLINE(*-explicit-*)
-    inline operator T*() {
+    T* get() {
         return handle_ptr<T>::get();
     }
 
-    // NOLINTNEXTLINE(*-explicit-*)
-    inline operator uv_handle_t*() {
+    uv_handle_t* get_handle() {
         return reinterpret_cast<uv_handle_t*>(handle_ptr<T>::get());
     }
 };