Fix clippy warnings

tower/src/balance/p2c/layer.rs

@@ -27,6 +27,12 @@ impl<D, Req> MakeBalanceLayer<D, Req> {
     }
 }
 
+impl<D, Req> Default for MakeBalanceLayer<D, Req> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<S, Req> Layer<S> for MakeBalanceLayer<S, Req> {
     type Service = MakeBalance<S, Req>;
 

tower/src/balance/p2c/service.rs

@@ -107,6 +107,11 @@ where
     pub fn len(&self) -> usize {
         self.services.len()
     }
+
+    /// Returns whether or not the balancer is empty.
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
 }
 
 impl<D, Req> Balance<D, Req>

tower/src/balance/pool/mod.rs

@@ -98,7 +98,7 @@ where
             );
         }
 
-        if this.services.len() == 0 && this.making.is_none() {
+        if this.services.is_empty() && this.making.is_none() {
             let _ = ready!(this.maker.poll_ready(cx))?;
             tracing::trace!("construct initial pool connection");
             this.making
@@ -367,7 +367,7 @@ where
         if let Poll::Ready(()) = self.balance.poll_ready(cx)? {
             // services was ready -- there are enough services
             // update ewma with a 0 sample
-            self.ewma = (1.0 - self.options.alpha) * self.ewma;
+            self.ewma *= 1.0 - self.options.alpha;
 
             let discover = self.balance.discover_mut().as_mut().project();
             if self.ewma < self.options.low {

tower/src/builder/mod.rs

@@ -106,6 +106,12 @@ pub struct ServiceBuilder<L> {
     layer: L,
 }
 
+impl Default for ServiceBuilder<Identity> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl ServiceBuilder<Identity> {
     /// Create a new `ServiceBuilder`.
     pub fn new() -> Self {

tower/src/hedge/select.rs

@@ -99,6 +99,6 @@ where
                 return Poll::Ready(Ok(r.map_err(Into::into)?));
             }
         }
-        return Poll::Pending;
+        Poll::Pending
     }
 }

tower/src/lib.rs

@@ -5,7 +5,8 @@
     rust_2018_idioms,
     unreachable_pub
 )]
-#![allow(elided_lifetimes_in_paths)]
+#![allow(elided_lifetimes_in_paths, clippy::type_complexity)]
+#![cfg_attr(test, allow(clippy::float_cmp))]
 #![cfg_attr(docsrs, feature(doc_cfg))]
 
 //! `fn(Request) -> Future<Response>`

tower/src/limit/rate/mod.rs

@@ -1,6 +1,7 @@
 //! Limit the rate at which requests are processed.
 
 mod layer;
+#[allow(clippy::module_inception)]
 mod rate;
 mod service;
 

tower/src/limit/rate/service.rs

@@ -37,7 +37,7 @@ impl<T> RateLimit<T> {
         RateLimit {
             inner,
             rate,
-            state: state,
+            state,
             // The sleep won't actually be used with this duration, but
             // we create it eagerly so that we can reset it in place rather than
             // `Box::pin`ning a new `Sleep` every time we need one.

tower/src/load_shed/layer.rs

@@ -4,7 +4,7 @@ use tower_layer::Layer;
 use super::LoadShed;
 
 /// A `tower-layer` to wrap services in `LoadShed` middleware.
-#[derive(Clone)]
+#[derive(Clone, Default)]
 pub struct LoadShedLayer {
     _p: (),
 }

tower/src/ready_cache/cache.rs

@@ -112,6 +112,7 @@ where
     }
 }
 
+#[allow(clippy::len_without_is_empty)]
 impl<K, S, Req> ReadyCache<K, S, Req>
 where
     K: Eq + Hash,
@@ -263,7 +264,7 @@ where
                 }
                 Poll::Ready(Some(Err(PendingError::Inner(key, e)))) => {
                     let cancel_tx = self.pending_cancel_txs.swap_remove(&key);
-                    if let Some(_) = cancel_tx {
+                    if cancel_tx.is_some() {
                         return Err(error::Failed(key, e.into())).into();
                     } else {
                         // See comment for the same clause under Ready(Some(Ok)).

tower/src/reconnect/mod.rs

@@ -111,7 +111,7 @@ where
                         Poll::Ready(Err(e)) => {
                             trace!("poll_ready; error");
                             self.state = State::Idle;
-                            self.error = Some(e.into());
+                            self.error = Some(e);
                             break;
                         }
                     }

tower/src/spawn_ready/layer.rs

@@ -2,7 +2,7 @@ use super::MakeSpawnReady;
 use tower_layer::Layer;
 
 /// Spawns tasks to drive its inner service to readiness.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct SpawnReadyLayer;
 
 impl SpawnReadyLayer {

tower/src/timeout/error.rs

@@ -3,7 +3,7 @@
 use std::{error, fmt};
 
 /// The timeout elapsed.
-#[derive(Debug)]
+#[derive(Debug, Default)]
 pub struct Elapsed(pub(super) ());
 
 impl Elapsed {

tower/tests/builder.rs

@@ -21,8 +21,8 @@ async fn builder_service() {
         .concurrency_limit(5)
         .rate_limit(5, Duration::from_secs(5))
         .retry(policy)
-        .map_response(|r: &'static str| if r == "world" { true } else { false })
-        .map_request(|r: &'static str| if r == "hello" { true } else { false })
+        .map_response(|r: &'static str| r == "world")
+        .map_request(|r: &'static str| r == "hello")
         .service(service);
 
     // allow a request through

tower/tests/hedge/main.rs

@@ -146,8 +146,8 @@ type Res = &'static str;
 type Mock = tower_test::mock::Mock<Req, Res>;
 type Handle = tower_test::mock::Handle<Req, Res>;
 
-static NOT_RETRYABLE: &'static str = "NOT_RETRYABLE";
-static NOT_CLONABLE: &'static str = "NOT_CLONABLE";
+static NOT_RETRYABLE: &str = "NOT_RETRYABLE";
+static NOT_CLONABLE: &str = "NOT_CLONABLE";
 
 #[derive(Clone)]
 struct TestPolicy;

tower/tests/util/call_all.rs

@@ -102,13 +102,7 @@ fn ordered() {
     assert_eq!(count.get(), 4);
 
     // We should also be able to recover the wrapped Service.
-    assert_eq!(
-        ca.take_service(),
-        Srv {
-            count: count.clone(),
-            admit
-        }
-    );
+    assert_eq!(ca.take_service(), Srv { count, admit });
 }
 
 #[tokio::test(flavor = "current_thread")]

tower/tests/util/main.rs

@@ -1,4 +1,5 @@
 #![cfg(feature = "util")]
+#![allow(clippy::type_complexity)]
 
 mod call_all;
 mod oneshot;