silence newer clippy warnings

Signed-off-by: Marc-Antoine Perennou <Marc-Antoine@Perennou.com>

Author: Keruspe

src/channel.rs

@@ -129,11 +129,11 @@ impl Channel {
     }
 
     pub async fn wait_for_recovery(&self, error: Error) -> Result<()> {
-        if self.recovery_config.can_recover(&error) {
-            if let Some(notifier) = error.notifier() {
-                notifier.await;
-                return Ok(());
-            }
+        if self.recovery_config.can_recover(&error)
+            && let Some(notifier) = error.notifier()
+        {
+            notifier.await;
+            return Ok(());
         }
         Err(error)
     }

src/error.rs

@@ -85,19 +85,19 @@ impl Error {
     }
 
     pub fn is_amqp_soft_error(&self) -> bool {
-        if let ErrorKind::ProtocolError(e) = self.kind() {
-            if let AMQPErrorKind::Soft(_) = e.kind() {
-                return true;
-            }
+        if let ErrorKind::ProtocolError(e) = self.kind()
+            && let AMQPErrorKind::Soft(_) = e.kind()
+        {
+            return true;
         }
         false
     }
 
     pub fn is_amqp_hard_error(&self) -> bool {
-        if let ErrorKind::ProtocolError(e) = self.kind() {
-            if let AMQPErrorKind::Hard(_) = e.kind() {
-                return true;
-            }
+        if let ErrorKind::ProtocolError(e) = self.kind()
+            && let AMQPErrorKind::Hard(_) = e.kind()
+        {
+            return true;
         }
         false
     }

src/frames.rs

@@ -312,33 +312,31 @@ impl Inner {
         {
             return Some(frame);
         }
-        if flow {
-            if let Some(frame) = self.low_prio_frames.pop_front() {
-                // If the next frame is a header, that means we're a basic.publish
-                // Header frame needs to follow directly the basic.publish frame, and Body frames
-                // need to be sent just after those or the AMQP server will close the connection.
-                // Push the header into publish_frames which is there to handle just that.
-                if self
-                    .low_prio_frames
-                    .front()
-                    .map(|frame| frame.is_header())
-                    .unwrap_or(false)
-                {
-                    while let Some(next_frame) = self.low_prio_frames.pop_front() {
-                        match *next_frame {
-                            AMQPFrame::Header(..) | AMQPFrame::Body(..) => {
-                                self.publish_frames.push_back(next_frame);
-                            }
-                            _ => {
-                                // We've exhausted Body frames for this publish, push back the next one and exit
-                                self.low_prio_frames.push_front(next_frame);
-                                break;
-                            }
+        if flow && let Some(frame) = self.low_prio_frames.pop_front() {
+            // If the next frame is a header, that means we're a basic.publish
+            // Header frame needs to follow directly the basic.publish frame, and Body frames
+            // need to be sent just after those or the AMQP server will close the connection.
+            // Push the header into publish_frames which is there to handle just that.
+            if self
+                .low_prio_frames
+                .front()
+                .map(|frame| frame.is_header())
+                .unwrap_or(false)
+            {
+                while let Some(next_frame) = self.low_prio_frames.pop_front() {
+                    match *next_frame {
+                        AMQPFrame::Header(..) | AMQPFrame::Body(..) => {
+                            self.publish_frames.push_back(next_frame);
+                        }
+                        _ => {
+                            // We've exhausted Body frames for this publish, push back the next one and exit
+                            self.low_prio_frames.push_front(next_frame);
+                            break;
                         }
                     }
                 }
-                return Some(frame);
             }
+            return Some(frame);
         }
         None
     }

src/io_loop.rs

@@ -231,14 +231,13 @@ impl<
 
                 trace!(status=?self.status, connection_status=?self.connection_status.state(), "io_loop entering exit/cleanup phase");
                 self.internal_rpc.stop();
-                if self.heartbeat.killswitch().killed() {
-                    if let Err(err) = self.runtime.block_on(std::future::poll_fn(move |cx| {
+                if self.heartbeat.killswitch().killed()
+                    && let Err(err) = self.runtime.block_on(std::future::poll_fn(move |cx| {
                         Pin::new(&mut stream)
                             .poll_close(cx)
                     })) {
                         error!(?err, "Failed to close IO stream");
                     }
-                }
                 res
             })?;
         waker.wake();

src/thread.rs

@@ -28,14 +28,14 @@ impl ThreadHandle {
     }
 
     pub(crate) fn wait(&self, context: &'static str) -> Result<()> {
-        if let Some(handle) = self.take() {
-            if handle.thread().id() != thread::current().id() {
-                match handle.join() {
-                    Ok(res) => return res,
-                    Err(e) => {
-                        error!(%context, "Failed waiting for thread");
-                        panic::resume_unwind(e);
-                    }
+        if let Some(handle) = self.take()
+            && handle.thread().id() != thread::current().id()
+        {
+            match handle.join() {
+                Ok(res) => return res,
+                Err(e) => {
+                    error!(%context, "Failed waiting for thread");
+                    panic::resume_unwind(e);
                 }
             }
         }