rustfmt

Author: surban

remoc/src/rch/base/io.rs

@@ -116,5 +116,3 @@ impl io::Read for ChannelBytesReader {
         Ok(len)
     }
 }
-
-

remoc/src/rch/base/receiver.rs

@@ -290,12 +290,9 @@ async fn recv_erased(inner: &mut RecvInner) -> Result<Option<Box<dyn Any + Send>
                         return Err(RecvError::MaxItemSizeExceeded);
                     }
 
-                    let pds_ref = PortDeserializer::start(
-                        inner.receiver.port_allocator(),
-                        inner.receiver.storage(),
-                    );
-                    let item = (inner.deserialize)(&mut data.reader())
-                        .map_err(RecvError::Deserialize)?;
+                    let pds_ref =
+                        PortDeserializer::start(inner.receiver.port_allocator(), inner.receiver.storage());
+                    let item = (inner.deserialize)(&mut data.reader()).map_err(RecvError::Deserialize)?;
                     let pds = PortDeserializer::finish(pds_ref);
                     inner.data = DataSource::None;
                     inner.item = Some(item);

remoc/src/rch/base/sender.rs

@@ -262,10 +262,7 @@ where
 /// of the large async state machine.
 #[inline(never)]
 async fn send_erased(
-    sender: &mut chmux::Sender,
-    item: Box<dyn ErasedSerialize>,
-    big_data: &mut i8,
-    max_item_size: usize,
+    sender: &mut chmux::Sender, item: Box<dyn ErasedSerialize>, big_data: &mut i8, max_item_size: usize,
 ) -> Result<(), (SendErrorKind, Box<dyn Any + Send>)> {
     // Determine if it is worthy to try buffered serialization.
     let data_ps = if *big_data <= 0 {

remoc/src/rch/mpsc/sender.rs

@@ -298,8 +298,7 @@ const fn default_max_item_size() -> u64 {
 /// the type-erased strong reference to the sender.
 #[inline(never)]
 fn spawn_close_monitor(
-    tx: Box<dyn Any + Send>,
-    mut closed_rx: tokio::sync::watch::Receiver<Option<ClosedReason>>,
+    tx: Box<dyn Any + Send>, mut closed_rx: tokio::sync::watch::Receiver<Option<ClosedReason>>,
     mut dropped_rx: tokio::sync::mpsc::Receiver<()>,
 ) {
     exec::spawn(async move {
@@ -326,8 +325,7 @@ where
 {
     /// Creates a new sender.
     pub(crate) fn new(
-        tx: tokio::sync::mpsc::Sender<SendReq<T>>,
-        closed_rx: tokio::sync::watch::Receiver<Option<ClosedReason>>,
+        tx: tokio::sync::mpsc::Sender<SendReq<T>>, closed_rx: tokio::sync::watch::Receiver<Option<ClosedReason>>,
         remote_send_err_rx: tokio::sync::watch::Receiver<Option<RemoteSendError>>,
     ) -> Self {
         let tx = Arc::new(tx);

remoc/src/rch/watch/sender.rs

@@ -333,7 +333,9 @@ where
             async move {
                 // Sender has been dropped after sending, so we receive its channels.
                 let SenderInner { tx, remote_send_err_rx, current_err, .. } = match successor_rx.await {
-                    Ok(inner) => *inner.downcast::<SenderInner<T, Codec>>().expect("type mismatch in watch Sender successor"),
+                    Ok(inner) => *inner
+                        .downcast::<SenderInner<T, Codec>>()
+                        .expect("type mismatch in watch Sender successor"),
                     Err(_) => return,
                 };
                 let remote_send_err_rx = remote_send_err_rx.into_inner().unwrap();