Run cargo fmt with 2024 edition

Author: tikue

tarpc/src/client.rs

@@ -10,10 +10,10 @@ mod in_flight_requests;
 pub mod stub;
 
 use crate::{
-    cancellations::{cancellations, CanceledRequests, RequestCancellation},
+    ChannelError, ClientMessage, Request, RequestName, Response, ServerError, Transport,
+    cancellations::{CanceledRequests, RequestCancellation, cancellations},
     context, trace,
     util::TimeUntil,
-    ChannelError, ClientMessage, Request, RequestName, Response, ServerError, Transport,
 };
 use futures::{prelude::*, ready, stream::Fuse, task::*};
 use in_flight_requests::InFlightRequests;
@@ -24,8 +24,8 @@ use std::{
     fmt,
     pin::Pin,
     sync::{
-        atomic::{AtomicUsize, Ordering},
         Arc,
+        atomic::{AtomicUsize, Ordering},
     },
     time::SystemTime,
 };
@@ -679,13 +679,13 @@ struct DispatchRequest<Req, Resp> {
 #[cfg(test)]
 mod tests {
     use super::{
-        cancellations, Channel, DispatchRequest, RequestDispatch, ResponseGuard, RpcError,
+        Channel, DispatchRequest, RequestDispatch, ResponseGuard, RpcError, cancellations,
     };
     use crate::{
-        client::{in_flight_requests::InFlightRequests, Config},
+        ChannelError, ClientMessage, Response,
+        client::{Config, in_flight_requests::InFlightRequests},
         context::{self, current},
         transport::{self, channel::UnboundedChannel},
-        ChannelError, ClientMessage, Response,
     };
     use assert_matches::assert_matches;
     use futures::{prelude::*, task::*};
@@ -695,8 +695,8 @@ mod tests {
         marker::PhantomData,
         pin::Pin,
         sync::{
-            atomic::{AtomicUsize, Ordering},
             Arc,
+            atomic::{AtomicUsize, Ordering},
         },
     };
     use thiserror::Error;

tarpc/src/client/stub.rs

@@ -1,10 +1,10 @@
 //! Provides a Stub trait, implemented by types that can call remote services.
 
 use crate::{
+    RequestName,
     client::{Channel, RpcError},
     context,
     server::Serve,
-    RequestName,
 };
 
 pub mod load_balance;
@@ -25,7 +25,7 @@ pub trait Stub {
 
     /// Calls a remote service.
     async fn call(&self, ctx: context::Context, request: Self::Req)
-        -> Result<Self::Resp, RpcError>;
+    -> Result<Self::Resp, RpcError>;
 }
 
 impl<Req, Resp> Stub for Channel<Req, Resp>

tarpc/src/client/stub/load_balance.rs

@@ -6,7 +6,7 @@ pub use round_robin::RoundRobin;
 /// Provides a stub that load-balances with a simple round-robin strategy.
 mod round_robin {
     use crate::{
-        client::{stub, RpcError},
+        client::{RpcError, stub},
         context,
     };
     use cycle::AtomicCycle;
@@ -48,8 +48,8 @@ mod round_robin {
 
     mod cycle {
         use std::sync::{
-            atomic::{AtomicUsize, Ordering},
             Arc,
+            atomic::{AtomicUsize, Ordering},
         };
 
         /// Cycles endlessly and atomically over a collection of elements of type T.
@@ -99,7 +99,7 @@ mod round_robin {
 /// the same stub.
 mod consistent_hash {
     use crate::{
-        client::{stub, RpcError},
+        client::{RpcError, stub},
         context,
     };
     use std::{
@@ -176,7 +176,7 @@ mod consistent_hash {
     mod tests {
         use super::ConsistentHash;
         use crate::{
-            client::stub::{mock::Mock, Stub},
+            client::stub::{Stub, mock::Mock},
             context,
         };
         use std::{

tarpc/src/client/stub/mock.rs

@@ -1,6 +1,7 @@
 use crate::{
-    client::{stub::Stub, RpcError},
-    context, RequestName, ServerError,
+    RequestName, ServerError,
+    client::{RpcError, stub::Stub},
+    context,
 };
 use std::{collections::HashMap, hash::Hash, io};
 

tarpc/src/client/stub/retry.rs

@@ -1,8 +1,9 @@
 //! Provides a stub that retries requests based on response contents..
 
 use crate::{
-    client::{stub, RpcError},
-    context, RequestName,
+    RequestName,
+    client::{RpcError, stub},
+    context,
 };
 use std::sync::Arc;
 

tarpc/src/serde_transport.rs

@@ -14,7 +14,7 @@ use serde::{Deserialize, Serialize};
 use std::{error::Error, io, pin::Pin};
 use tokio::io::{AsyncRead, AsyncWrite};
 use tokio_serde::{Framed as SerdeFramed, *};
-use tokio_util::codec::{length_delimited::LengthDelimitedCodec, Framed};
+use tokio_util::codec::{Framed, length_delimited::LengthDelimitedCodec};
 
 /// A transport that serializes to, and deserializes from, a byte stream.
 #[pin_project]
@@ -42,10 +42,7 @@ where
     type Item = io::Result<Item>;
 
     fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<io::Result<Item>>> {
-        self.project()
-            .inner
-            .poll_next(cx)
-            .map_err(io::Error::other)
+        self.project().inner.poll_next(cx).map_err(io::Error::other)
     }
 }
 
@@ -289,7 +286,7 @@ pub mod unix {
         super::*,
         futures::ready,
         std::{marker::PhantomData, path::Path},
-        tokio::net::{unix::SocketAddr, UnixListener, UnixStream},
+        tokio::net::{UnixListener, UnixStream, unix::SocketAddr},
         tokio_util::codec::length_delimited,
     };
 
@@ -561,7 +558,7 @@ pub mod unix {
 mod tests {
     use super::Transport;
     use assert_matches::assert_matches;
-    use futures::{task::*, Sink, Stream};
+    use futures::{Sink, Stream, task::*};
     #[cfg(any(feature = "tcp", all(unix, feature = "unix")))]
     use futures::{SinkExt, StreamExt};
     use pin_utils::pin_mut;

tarpc/src/server.rs

@@ -7,11 +7,11 @@
 //! Provides a server that concurrently handles many connections sending multiplexed requests.
 
 use crate::{
-    cancellations::{cancellations, CanceledRequests, RequestCancellation},
+    ChannelError, ClientMessage, Request, RequestName, Response, ServerError, Transport,
+    cancellations::{CanceledRequests, RequestCancellation, cancellations},
     context::{self, SpanExt},
     trace,
     util::TimeUntil,
-    ChannelError, ClientMessage, Request, RequestName, Response, ServerError, Transport,
 };
 use ::tokio::sync::mpsc;
 use futures::{
@@ -26,7 +26,7 @@ use pin_project::pin_project;
 use std::{
     convert::TryFrom, error::Error, fmt, marker::PhantomData, pin::Pin, sync::Arc, time::SystemTime,
 };
-use tracing::{info_span, instrument::Instrument, Span};
+use tracing::{Span, info_span, instrument::Instrument};
 
 mod in_flight_requests;
 pub mod request_hook;
@@ -955,20 +955,20 @@ where
 #[cfg(test)]
 mod tests {
     use super::{
+        BaseChannel, Channel, Config, Requests, Serve,
         in_flight_requests::AlreadyExistsError,
         request_hook::{AfterRequest, BeforeRequest, RequestHook},
-        serve, BaseChannel, Channel, Config, Requests, Serve,
+        serve,
     };
     use crate::{
-        context, trace,
+        ClientMessage, Request, Response, ServerError, context, trace,
         transport::channel::{self, UnboundedChannel},
-        ClientMessage, Request, Response, ServerError,
     };
     use assert_matches::assert_matches;
     use futures::{
-        future::{pending, AbortRegistration, Abortable, Aborted},
-        prelude::*,
         Future,
+        future::{AbortRegistration, Abortable, Aborted, pending},
+        prelude::*,
     };
     use futures_test::task::noop_context;
     use std::{
@@ -1321,12 +1321,14 @@ mod tests {
             result => panic!("Unexpected result: {result:?}"),
         };
         request.execute(serve(|_, _| async { Ok(()) })).await;
-        assert!(requests
-            .as_mut()
-            .channel_pin_mut()
-            .canceled_requests
-            .poll_recv(&mut noop_context())
-            .is_pending());
+        assert!(
+            requests
+                .as_mut()
+                .channel_pin_mut()
+                .canceled_requests
+                .poll_recv(&mut noop_context())
+                .is_pending()
+        );
     }
 
     #[tokio::test]

tarpc/src/server/in_flight_requests.rs

@@ -131,8 +131,8 @@ mod tests {
 
     use assert_matches::assert_matches;
     use futures::{
-        future::{pending, Abortable},
         FutureExt,
+        future::{Abortable, pending},
     };
     use futures_test::task::noop_context;
 

tarpc/src/server/incoming.rs

@@ -1,6 +1,6 @@
 use super::{
-    limits::{channels_per_key::MaxChannelsPerKey, requests_per_channel::MaxRequestsPerChannel},
     Channel, RequestName, Serve,
+    limits::{channels_per_key::MaxChannelsPerKey, requests_per_channel::MaxRequestsPerChannel},
 };
 use futures::prelude::*;
 use std::{fmt, hash::Hash};

tarpc/src/server/limits/requests_per_channel.rs

@@ -5,8 +5,8 @@
 // https://opensource.org/licenses/MIT.
 
 use crate::{
-    server::{Channel, Config},
     Response, ServerError,
+    server::{Channel, Config},
 };
 use futures::{prelude::*, ready, task::*};
 use pin_project::pin_project;
@@ -179,8 +179,8 @@ mod tests {
     use super::*;
 
     use crate::server::{
-        testing::{self, FakeChannel, PollExt},
         TrackedRequest,
+        testing::{self, FakeChannel, PollExt},
     };
     use pin_utils::pin_mut;
     use std::{
@@ -267,8 +267,8 @@ mod tests {
             ghost: PhantomData<fn(Out) -> In>,
         }
         impl PendingSink<(), ()> {
-            pub fn default<Req, Resp>(
-            ) -> PendingSink<io::Result<TrackedRequest<Req>>, Response<Resp>> {
+            pub fn default<Req, Resp>()
+            -> PendingSink<io::Result<TrackedRequest<Req>>, Response<Resp>> {
                 PendingSink { ghost: PhantomData }
             }
         }