Make SharedHandleContainer a proper struct.

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,