chore(lib): refactor conditional expression

Author: tottoto

src/body/incoming.rs

@@ -186,13 +186,9 @@ impl Body for Incoming {
                 want_tx.send(WANT_READY);
 
                 if !data_rx.is_terminated() {
-                    match ready!(Pin::new(data_rx).poll_next(cx)?) {
-                        Some(chunk) => {
-                            len.sub_if(chunk.len() as u64);
-                            return Poll::Ready(Some(Ok(Frame::data(chunk))));
-                        }
-                        // fall through to trailers
-                        None => (),
+                    if let Some(chunk) = ready!(Pin::new(data_rx).poll_next(cx)?) {
+                        len.sub_if(chunk.len() as u64);
+                        return Poll::Ready(Some(Ok(Frame::data(chunk))));
                     }
                 }
 

src/headers.rs

@@ -98,10 +98,10 @@ fn from_digits(bytes: &[u8]) -> Option<u64> {
 
 #[cfg(all(feature = "http2", feature = "client"))]
 pub(super) fn method_has_defined_payload_semantics(method: &Method) -> bool {
-    match *method {
-        Method::GET | Method::HEAD | Method::DELETE | Method::CONNECT => false,
-        _ => true,
-    }
+    !matches!(
+        *method,
+        Method::GET | Method::HEAD | Method::DELETE | Method::CONNECT
+    )
 }
 
 #[cfg(feature = "http2")]

src/proto/h1/conn.rs

@@ -169,10 +169,10 @@ where
     }
 
     pub(crate) fn can_read_body(&self) -> bool {
-        match self.state.reading {
-            Reading::Body(..) | Reading::Continue(..) => true,
-            _ => false,
-        }
+        matches!(
+            self.state.reading,
+            Reading::Body(..) | Reading::Continue(..)
+        )
     }
 
     #[cfg(feature = "server")]
@@ -950,11 +950,7 @@ impl State {
     }
 
     fn wants_keep_alive(&self) -> bool {
-        if let KA::Disabled = self.keep_alive.status() {
-            false
-        } else {
-            true
-        }
+        !matches!(self.keep_alive.status(), KA::Disabled)
     }
 
     fn try_keep_alive<T: Http1Transaction>(&mut self) {

src/proto/h1/role.rs

@@ -471,27 +471,21 @@ impl Server {
     }
 
     fn can_chunked(method: &Option<Method>, status: StatusCode) -> bool {
-        if method == &Some(Method::HEAD) || method == &Some(Method::CONNECT) && status.is_success()
+        if method == &Some(Method::HEAD)
+            || method == &Some(Method::CONNECT) && status.is_success()
+            || status.is_informational()
         {
             false
-        } else if status.is_informational() {
-            false
         } else {
-            match status {
-                StatusCode::NO_CONTENT | StatusCode::NOT_MODIFIED => false,
-                _ => true,
-            }
+            !matches!(status, StatusCode::NO_CONTENT | StatusCode::NOT_MODIFIED)
         }
     }
 
     fn can_have_content_length(method: &Option<Method>, status: StatusCode) -> bool {
         if status.is_informational() || method == &Some(Method::CONNECT) && status.is_success() {
             false
         } else {
-            match status {
-                StatusCode::NO_CONTENT | StatusCode::NOT_MODIFIED => false,
-                _ => true,
-            }
+            !matches!(status, StatusCode::NO_CONTENT | StatusCode::NOT_MODIFIED)
         }
     }
 

src/proto/h2/client.rs

@@ -307,22 +307,18 @@ where
     fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
         let mut this = self.project();
 
-        if !this.conn.is_terminated() {
-            if let Poll::Ready(_) = this.conn.poll_unpin(cx) {
-                // ok or err, the `conn` has finished.
-                return Poll::Ready(());
-            };
+        if !this.conn.is_terminated() && this.conn.poll_unpin(cx).is_ready() {
+            // ok or err, the `conn` has finished.
+            return Poll::Ready(());
         }
 
-        if !this.drop_rx.is_terminated() {
-            if let Poll::Ready(_) = this.drop_rx.poll_unpin(cx) {
-                // mpsc has been dropped, hopefully polling
-                // the connection some more should start shutdown
-                // and then close.
-                trace!("send_request dropped, starting conn shutdown");
-                drop(this.cancel_tx.take().expect("ConnTask Future polled twice"));
-            }
-        };
+        if !this.drop_rx.is_terminated() && this.drop_rx.poll_unpin(cx).is_ready() {
+            // mpsc has been dropped, hopefully polling
+            // the connection some more should start shutdown
+            // and then close.
+            trace!("send_request dropped, starting conn shutdown");
+            drop(this.cancel_tx.take().expect("ConnTask Future polled twice"));
+        }
 
         Poll::Pending
     }
@@ -613,14 +609,11 @@ where
                 }
             };
 
-            match self.fut_ctx.take() {
-                // If we were waiting on pending open
-                // continue where we left off.
-                Some(f) => {
-                    self.poll_pipe(f, cx);
-                    continue;
-                }
-                None => (),
+            // If we were waiting on pending open
+            // continue where we left off.
+            if let Some(f) = self.fut_ctx.take() {
+                self.poll_pipe(f, cx);
+                continue;
             }
 
             match self.req_rx.poll_recv(cx) {
@@ -642,17 +635,16 @@ where
                     let is_connect = req.method() == Method::CONNECT;
                     let eos = body.is_end_stream();
 
-                    if is_connect {
-                        if headers::content_length_parse_all(req.headers())
+                    if is_connect
+                        && headers::content_length_parse_all(req.headers())
                             .map_or(false, |len| len != 0)
-                        {
-                            warn!("h2 connect request with non-zero body not supported");
-                            cb.send(Err((
-                                crate::Error::new_h2(h2::Reason::INTERNAL_ERROR.into()),
-                                None,
-                            )));
-                            continue;
-                        }
+                    {
+                        warn!("h2 connect request with non-zero body not supported");
+                        cb.send(Err((
+                            crate::Error::new_h2(h2::Reason::INTERNAL_ERROR.into()),
+                            None,
+                        )));
+                        continue;
                     }
 
                     if let Some(protocol) = req.extensions_mut().remove::<Protocol>() {