Fix several errors reported by clippy. (#715)

core/src/nodes/raw_swarm.rs

@@ -634,10 +634,9 @@ where
         }
 
         // Poll the existing nodes.
-        loop {
         let (action, out_event);
         match self.active_nodes.poll() {
-                Async::NotReady => break,
+            Async::NotReady => return Async::NotReady,
             Async::Ready(CollectionEvent::NodeReached(reach_event)) => {
                 let (a, e) = handle_node_reached(&mut self.reach_attempts, reach_event);
                 action = a;
@@ -681,7 +680,7 @@ where
                 action = Default::default();
                 out_event = RawSwarmEvent::NodeEvent { peer_id, event };
             }
-            };
+        }
 
         if let Some((peer_id, handler, first, rest)) = action.start_dial_out {
             self.start_dial_out(peer_id, handler, first, rest);
@@ -699,10 +698,7 @@ where
                          attempts; QED");
         }
 
-            return Async::Ready(out_event);
+        Async::Ready(out_event)
-        }
-
-        Async::NotReady
     }
 }
 

protocols/ping/src/dial_handler.rs

@@ -171,13 +171,10 @@ where
         mut substream: <Self::OutboundProtocol as OutboundUpgrade<TSubstream>>::Output,
         _info: Self::OutboundOpenInfo
     ) {
-        match mem::replace(&mut self.out_state, OutState::Poisoned) {
+        if let OutState::Upgrading { expires } = mem::replace(&mut self.out_state, OutState::Poisoned) {
-            OutState::Upgrading { expires } => {
             // We always upgrade with the intent of immediately pinging.
             substream.ping(Instant::now());
-                self.out_state = OutState::WaitingForPong { substream, expires };
+            self.out_state = OutState::WaitingForPong { substream, expires }
-            }
-            _ => (),
         }
     }
 
@@ -232,15 +229,14 @@ where
             )
         }
 
-        loop {
         match mem::replace(&mut self.out_state, OutState::Poisoned) {
             OutState::Shutdown | OutState::Poisoned => {
                 // This shuts down the whole connection with the remote.
-                    return Ok(Async::Ready(None));
+                Ok(Async::Ready(None))
             },
 
             OutState::Disabled => {
-                    return Ok(Async::NotReady);
+                Ok(Async::NotReady)
             }
 
             // Need to open an outgoing substream.
@@ -248,32 +244,29 @@ where
                 // Note that we ignore the expiration here, as it's pretty unlikely to happen.
                 // The expiration is only here to be transmitted to the `Upgrading`.
                 self.out_state = OutState::Upgrading { expires };
-                    return Ok(Async::Ready(Some(
+                Ok(Async::Ready(Some(
                     ProtocolsHandlerEvent::OutboundSubstreamRequest {
                         upgrade: self.ping_config,
                         info: (),
                     },
-                    )));
+                )))
             }
 
             // Waiting for the upgrade to be negotiated.
             OutState::Upgrading { mut expires } => poll_delay!(expires => {
                     NotReady => {
                         self.out_state = OutState::Upgrading { expires };
-                            return Ok(Async::NotReady);
+                        Ok(Async::NotReady)
                     },
                     Ready => {
                         self.out_state = OutState::Shutdown;
                         let ev = OutEvent::Unresponsive;
-                            return Ok(Async::Ready(Some(ProtocolsHandlerEvent::Custom(ev))));
+                        Ok(Async::Ready(Some(ProtocolsHandlerEvent::Custom(ev))))
                     },
                 }),
 
             // Waiting for the pong.
-                OutState::WaitingForPong {
+            OutState::WaitingForPong { mut substream, mut expires } => {
-                    mut substream,
-                    mut expires,
-                } => {
                 // We start by dialing the substream, leaving one last chance for it to
                 // produce the pong even if the expiration happened.
                 match substream.poll()? {
@@ -290,7 +283,7 @@ where
                         self.out_state = OutState::Shutdown;
                         return Ok(Async::Ready(None));
                     }
-                    };
+                }
 
                 // Check the expiration.
                 poll_delay!(expires => {
@@ -298,35 +291,31 @@ where
                         self.out_state = OutState::WaitingForPong { substream, expires };
                         // Both `substream` and `expires` and not ready, so it's fine to return
                         // not ready.
-                            return Ok(Async::NotReady);
+                        Ok(Async::NotReady)
                     },
                     Ready => {
                         self.out_state = OutState::Shutdown;
                         let ev = OutEvent::Unresponsive;
-                            return Ok(Async::Ready(Some(ProtocolsHandlerEvent::Custom(ev))));
+                        Ok(Async::Ready(Some(ProtocolsHandlerEvent::Custom(ev))))
                     },
                 })
             }
 
-                OutState::Idle {
+            OutState::Idle { mut substream, mut next_ping } => {
-                    mut substream,
-                    mut next_ping,
-                } => {
                 // Poll the future that fires when we need to ping the node again.
                 poll_delay!(next_ping => {
                     NotReady => {
                         self.out_state = OutState::Idle { substream, next_ping };
-                            return Ok(Async::NotReady);
+                        Ok(Async::NotReady)
                     },
                     Ready => {
                         let expires = Delay::new(Instant::now() + self.ping_timeout);
                         substream.ping(Instant::now());
                         self.out_state = OutState::WaitingForPong { substream, expires };
-                            return Ok(Async::Ready(Some(ProtocolsHandlerEvent::Custom(OutEvent::PingStart))));
+                        Ok(Async::Ready(Some(ProtocolsHandlerEvent::Custom(OutEvent::PingStart))))
                     },
                 })
             }
         }
     }
-    }
 }

stores/peerstore/src/peerstore.rs

@@ -99,7 +99,6 @@ pub trait PeerAccess {
     /// Sets the TTL of an address of a peer. Adds the address if it is currently unknown.
     ///
     /// Contrary to `add_addr`, this operation is never a no-op.
-    #[inline]
     fn set_addr_ttl(&mut self, addr: Multiaddr, ttl: TTL);
 
     // Similar to calling `set_addr_ttl` multiple times in a row.