Make SharedHandleContainer a proper struct.

Author: nihohit

redis/src/aio/multiplexed_connection.rs

@@ -1,4 +1,4 @@
-use super::{new_shared_handle, ConnectionLike, Runtime, SharedHandleContainer, TaskHandle};
+use super::{ConnectionLike, Runtime, SharedHandleContainer, TaskHandle};
 use crate::aio::{check_resp3, setup_connection};
 use crate::cmd::Cmd;
 #[cfg(any(feature = "tokio-comp", feature = "async-std-comp"))]
@@ -517,7 +517,7 @@ impl MultiplexedConnection {
     /// This should be called strictly before the multiplexed connection is cloned - that is, before it is returned to the user.
     /// Otherwise some clones will be able to kill the backing task, while other clones are still alive.
     pub(crate) fn set_task_handle(&mut self, handle: TaskHandle) {
-        self._task_handle = Some(new_shared_handle(handle));
+        self._task_handle = Some(SharedHandleContainer::new(handle));
     }
 
     /// Sets the time that the multiplexer will wait for responses on operations before failing.

redis/src/aio/pubsub.rs

@@ -1,4 +1,4 @@
-use crate::aio::{new_shared_handle, Runtime};
+use crate::aio::Runtime;
 use crate::connection::{
     check_connection_setup, connection_setup_pipeline, AuthResult, ConnectionSetupComponents,
 };
@@ -371,7 +371,7 @@ impl PubSub {
         let (sender, receiver) = unbounded_channel();
         let (sink, driver) = PubSubSink::new(codec, sender);
         let handle = Runtime::locate().spawn(driver);
-        let _task_handle = Some(new_shared_handle(handle));
+        let _task_handle = Some(SharedHandleContainer::new(handle));
         let stream = PubSubStream {
             receiver,
             _task_handle,

redis/src/aio/runtime.rs

@@ -47,10 +47,15 @@ impl Drop for HandleContainer {
     }
 }
 
-pub(crate) type SharedHandleContainer = Arc<HandleContainer>;
+#[derive(Clone)]
+// we allow dead code here because the container isn't used directly, only in the derived drop.
+#[allow(dead_code)]
+pub(crate) struct SharedHandleContainer(Arc<HandleContainer>);
 
-pub(crate) fn new_shared_handle(handle: TaskHandle) -> SharedHandleContainer {
-    Arc::new(HandleContainer::new(handle))
+impl SharedHandleContainer {
+    pub(crate) fn new(handle: TaskHandle) -> Self {
+        Self(Arc::new(HandleContainer::new(handle)))
+    }
 }
 
 impl Runtime {

redis/src/cluster_async/mod.rs

@@ -79,9 +79,7 @@ use std::{
 mod request;
 mod routing;
 use crate::{
-    aio::{
-        new_shared_handle, ConnectionLike, MultiplexedConnection, Runtime, SharedHandleContainer,
-    },
+    aio::{ConnectionLike, MultiplexedConnection, Runtime, SharedHandleContainer},
     cluster::{get_connection_info, slot_cmd},
     cluster_client::ClusterParams,
     cluster_routing::{
@@ -128,7 +126,7 @@ where
                         .forward(inner)
                         .await;
                 };
-                let _task_handle = new_shared_handle(Runtime::locate().spawn(stream));
+                let _task_handle = SharedHandleContainer::new(Runtime::locate().spawn(stream));
 
                 ClusterConnection {
                     sender,