Implement matches! macro (#1777)

Fix #1775

beacon_node/eth2_libp2p/src/peer_manager/mod.rs

@@ -519,10 +519,7 @@ impl<TSpec: EthSpec> PeerManager<TSpec> {
             let mut out_list = enr.multiaddr();
             out_list.retain(|addr| {
                 addr.iter()
-                    .find(|v| match v {
+                    .find(|v| matches!(v, MProtocol::Udp(_)))
-                        MProtocol::Udp(_) => true,
-                        _ => false,
-                    })
                     .is_none()
             });
 

beacon_node/eth2_libp2p/src/peer_manager/peer_info.rs

@@ -228,18 +228,12 @@ impl Default for PeerConnectionStatus {
 impl PeerConnectionStatus {
     /// Checks if the status is connected.
     pub fn is_connected(&self) -> bool {
-        match self {
+        matches!(self, PeerConnectionStatus::Connected { .. })
-            PeerConnectionStatus::Connected { .. } => true,
-            _ => false,
-        }
     }
 
     /// Checks if the status is connected.
     pub fn is_dialing(&self) -> bool {
-        match self {
+        matches!(self, PeerConnectionStatus::Dialing { .. })
-            PeerConnectionStatus::Dialing { .. } => true,
-            _ => false,
-        }
     }
 
     /// The peer is either connected or in the process of being dialed.
@@ -249,18 +243,12 @@ impl PeerConnectionStatus {
 
     /// Checks if the status is banned.
     pub fn is_banned(&self) -> bool {
-        match self {
+        matches!(self, PeerConnectionStatus::Banned { .. })
-            PeerConnectionStatus::Banned { .. } => true,
-            _ => false,
-        }
     }
 
     /// Checks if the status is disconnected.
     pub fn is_disconnected(&self) -> bool {
-        match self {
+        matches!(self, Disconnected { .. })
-            Disconnected { .. } => true,
-            _ => false,
-        }
     }
 
     /// Modifies the status to Connected and increases the number of ingoing

beacon_node/eth2_libp2p/src/peer_manager/peer_sync_status.rs

@@ -29,26 +29,17 @@ pub struct SyncInfo {
 impl PeerSyncStatus {
     /// Returns true if the peer has advanced knowledge of the chain.
     pub fn is_advanced(&self) -> bool {
-        match self {
+        matches!(self, PeerSyncStatus::Advanced { .. })
-            PeerSyncStatus::Advanced { .. } => true,
-            _ => false,
-        }
     }
 
     /// Returns true if the peer is up to date with the current chain.
     pub fn is_synced(&self) -> bool {
-        match self {
+        matches!(self, PeerSyncStatus::Synced { .. })
-            PeerSyncStatus::Synced { .. } => true,
-            _ => false,
-        }
     }
 
     /// Returns true if the peer is behind the current chain.
     pub fn is_behind(&self) -> bool {
-        match self {
+        matches!(self, PeerSyncStatus::Behind { .. })
-            PeerSyncStatus::Behind { .. } => true,
-            _ => false,
-        }
     }
 
     /// Updates the sync state given a fully synced peer.

beacon_node/eth2_libp2p/src/peer_manager/peerdb.rs

@@ -136,20 +136,16 @@ impl<TSpec: EthSpec> PeerDB<TSpec> {
 
     /// Returns if the peer is already connected.
     pub fn is_connected(&self, peer_id: &PeerId) -> bool {
-        if let Some(PeerConnectionStatus::Connected { .. }) = self.connection_status(peer_id) {
+        matches!(
-            true
+            self.connection_status(peer_id),
-        } else {
+            Some(PeerConnectionStatus::Connected { .. })
-            false
+        )
-        }
     }
 
     /// If we are connected or currently dialing the peer returns true.
     pub fn is_connected_or_dialing(&self, peer_id: &PeerId) -> bool {
-        match self.connection_status(peer_id) {
+        matches!(self.connection_status(peer_id), Some(PeerConnectionStatus::Connected { .. })
-            Some(PeerConnectionStatus::Connected { .. })
+             | Some(PeerConnectionStatus::Dialing { .. }))
-            | Some(PeerConnectionStatus::Dialing { .. }) => true,
-            _ => false,
-        }
     }
     /// Returns true if the peer is synced at least to our current head.
     pub fn is_synced(&self, peer_id: &PeerId) -> bool {

beacon_node/eth2_libp2p/src/rpc/methods.rs

@@ -277,10 +277,7 @@ impl<T: EthSpec> RPCCodedResponse<T> {
 
     /// Tells the codec whether to decode as an RPCResponse or an error.
     pub fn is_response(response_code: u8) -> bool {
-        match response_code {
+        matches!(response_code, 0)
-            0 => true,
-            _ => false,
-        }
     }
 
     /// Builds an RPCCodedResponse from a response code and an ErrorMessage
@@ -311,10 +308,7 @@ impl<T: EthSpec> RPCCodedResponse<T> {
 
     /// Returns true if this response always terminates the stream.
     pub fn close_after(&self) -> bool {
-        match self {
+        !matches!(self, RPCCodedResponse::Success(_))
-            RPCCodedResponse::Success(_) => false,
-            _ => true,
-        }
     }
 }
 

beacon_node/eth2_libp2p/src/types/sync_state.rs

@@ -47,10 +47,7 @@ impl SyncState {
 
     /// Returns true if the node is synced.
     pub fn is_synced(&self) -> bool {
-        match self {
+        matches!(self, SyncState::Synced)
-            SyncState::Synced => true,
-            _ => false,
-        }
     }
 }
 

consensus/merkle_proof/src/lib.rs

@@ -156,10 +156,7 @@ impl MerkleTree {
 
     /// Is this Merkle tree a leaf?
     pub fn is_leaf(&self) -> bool {
-        match self {
+        matches!(self, MerkleTree::Leaf(_))
-            MerkleTree::Leaf(_) => true,
-            _ => false,
-        }
     }
 
     /// Return the leaf at `index` and a Merkle proof of its inclusion.

testing/ef_tests/src/error.rs

@@ -37,9 +37,6 @@ impl Error {
     }
 
     pub fn is_skipped(&self) -> bool {
-        match self {
+        matches!(self, Error::SkippedBls | Error::SkippedKnownFailure)
-            Error::SkippedBls | Error::SkippedKnownFailure => true,
-            _ => false,
-        }
     }
 }