*: Apply clippy suggestions (#2540)

protocols/gossipsub/src/behaviour.rs

@@ -473,14 +473,9 @@ where
 
     /// Lists all mesh peers for a certain topic hash.
     pub fn mesh_peers(&self, topic_hash: &TopicHash) -> impl Iterator<Item = &PeerId> {
-        self.mesh
+        self.mesh.get(topic_hash).into_iter().flat_map(|x| x.iter())
-            .get(topic_hash)
-            .into_iter()
-            .map(|x| x.iter())
-            .flatten()
     }
 
-    /// Lists all mesh peers for all topics.
     pub fn all_mesh_peers(&self) -> impl Iterator<Item = &PeerId> {
         let mut res = BTreeSet::new();
         for peers in self.mesh.values() {

protocols/identify/src/identify.rs

@@ -240,8 +240,7 @@ impl NetworkBehaviour for Identify {
         if let Some(entry) = self.discovered_peers.get_mut(peer_id) {
             for addr in failed_addresses
                 .into_iter()
-                .map(|addresses| addresses.into_iter())
+                .flat_map(|addresses| addresses.into_iter())
-                .flatten()
             {
                 entry.remove(addr);
             }

protocols/relay/src/v1/behaviour.rs

@@ -189,12 +189,11 @@ impl NetworkBehaviour for Relay {
                     .get(remote_peer_id)
                     .into_iter()
                     .flatten()
-                    .map(
+                    .flat_map(
                         |IncomingRelayReq::DialingDst {
                              incoming_relay_req, ..
                          }| incoming_relay_req.dst_peer().addrs.clone(),
-                    )
+                    ),
-                    .flatten(),
             )
             .collect()
     }

protocols/relay/src/v1/protocol/outgoing_dst_req.rs

@@ -110,8 +110,7 @@ impl upgrade::OutboundUpgrade<NegotiatedSubstream> for OutgoingDstReq {
             } = CircuitRelay::decode(msg)?;
 
             match r#type
-                .map(circuit_relay::Type::from_i32)
+                .and_then(circuit_relay::Type::from_i32)
-                .flatten()
                 .ok_or(OutgoingDstReqError::ParseTypeField)?
             {
                 circuit_relay::Type::Status => {}
@@ -126,8 +125,7 @@ impl upgrade::OutboundUpgrade<NegotiatedSubstream> for OutgoingDstReq {
             }
 
             match code
-                .map(circuit_relay::Status::from_i32)
+                .and_then(circuit_relay::Status::from_i32)
-                .flatten()
                 .ok_or(OutgoingDstReqError::ParseStatusField)?
             {
                 circuit_relay::Status::Success => {}

protocols/relay/src/v1/protocol/outgoing_relay_req.rs

@@ -120,8 +120,7 @@ impl upgrade::OutboundUpgrade<NegotiatedSubstream> for OutgoingRelayReq {
             } = CircuitRelay::decode(msg)?;
 
             match r#type
-                .map(circuit_relay::Type::from_i32)
+                .and_then(circuit_relay::Type::from_i32)
-                .flatten()
                 .ok_or(OutgoingRelayReqError::ParseTypeField)?
             {
                 circuit_relay::Type::Status => {}
@@ -129,8 +128,7 @@ impl upgrade::OutboundUpgrade<NegotiatedSubstream> for OutgoingRelayReq {
             }
 
             match code
-                .map(circuit_relay::Status::from_i32)
+                .and_then(circuit_relay::Status::from_i32)
-                .flatten()
                 .ok_or(OutgoingRelayReqError::ParseStatusField)?
             {
                 circuit_relay::Status::Success => {}

protocols/relay/src/v2/relay.rs

@@ -437,8 +437,7 @@ impl NetworkBehaviour for Relay {
                 } else if let Some(dst_conn) = self
                     .reservations
                     .get(&inbound_circuit_req.dst())
-                    .map(|cs| cs.iter().next())
+                    .and_then(|cs| cs.iter().next())
-                    .flatten()
                 {
                     // Accept circuit request if reservation present.
                     let circuit_id = self.circuits.insert(Circuit {

swarm/src/handler/multi.rs

@@ -452,8 +452,7 @@ where
         self.upgrades
             .iter()
             .enumerate()
-            .map(|(i, (_, h))| iter::repeat(i).zip(h.protocol_info()))
+            .flat_map(|(i, (_, h))| iter::repeat(i).zip(h.protocol_info()))
-            .flatten()
             .map(|(i, h)| IndexedProtoName(i, h))
             .collect::<Vec<_>>()
             .into_iter()

swarm/src/lib.rs

@@ -1192,16 +1192,16 @@ pub struct SwarmPollParameters<'a> {
 }
 
 impl<'a> PollParameters for SwarmPollParameters<'a> {
-    type SupportedProtocolsIter = std::vec::IntoIter<Vec<u8>>;
+    type SupportedProtocolsIter = std::iter::Cloned<std::slice::Iter<'a, std::vec::Vec<u8>>>;
-    type ListenedAddressesIter = std::vec::IntoIter<Multiaddr>;
+    type ListenedAddressesIter = std::iter::Cloned<std::slice::Iter<'a, Multiaddr>>;
     type ExternalAddressesIter = AddressIntoIter;
 
     fn supported_protocols(&self) -> Self::SupportedProtocolsIter {
-        self.supported_protocols.to_vec().into_iter()
+        self.supported_protocols.iter().cloned()
     }
 
     fn listened_addresses(&self) -> Self::ListenedAddressesIter {
-        self.listened_addrs.to_vec().into_iter()
+        self.listened_addrs.iter().cloned()
     }
 
     fn external_addresses(&self) -> Self::ExternalAddressesIter {

transports/wasm-ext/src/lib.rs

@@ -311,39 +311,33 @@ impl Stream for Listen {
                 return Poll::Ready(None);
             };
 
-            for addr in event
+            if let Some(addrs) = event.new_addrs() {
-                .new_addrs()
+                for addr in addrs.into_iter() {
-                .into_iter()
+                    let addr = js_value_to_addr(&addr)?;
-                .flat_map(|e| e.to_vec().into_iter())
+                    self.pending_events
-            {
+                        .push_back(ListenerEvent::NewAddress(addr));
-                let addr = js_value_to_addr(&addr)?;
+                }
-                self.pending_events
-                    .push_back(ListenerEvent::NewAddress(addr));
             }
 
-            for upgrade in event
+            if let Some(upgrades) = event.new_connections() {
-                .new_connections()
+                for upgrade in upgrades.into_iter().cloned() {
-                .into_iter()
+                    let upgrade: ffi::ConnectionEvent = upgrade.into();
-                .flat_map(|e| e.to_vec().into_iter())
+                    self.pending_events.push_back(ListenerEvent::Upgrade {
-            {
+                        local_addr: upgrade.local_addr().parse()?,
-                let upgrade: ffi::ConnectionEvent = upgrade.into();
+                        remote_addr: upgrade.observed_addr().parse()?,
-                self.pending_events.push_back(ListenerEvent::Upgrade {
+                        upgrade: futures::future::ok(Connection::new(upgrade.connection())),
-                    local_addr: upgrade.local_addr().parse()?,
+                    });
-                    remote_addr: upgrade.observed_addr().parse()?,
+                }
-                    upgrade: futures::future::ok(Connection::new(upgrade.connection())),
-                });
             }
 
-            for addr in event
+            if let Some(addrs) = event.expired_addrs() {
-                .expired_addrs()
+                for addr in addrs.into_iter() {
-                .into_iter()
+                    match js_value_to_addr(&addr) {
-                .flat_map(|e| e.to_vec().into_iter())
+                        Ok(addr) => self
-            {
+                            .pending_events
-                match js_value_to_addr(&addr) {
+                            .push_back(ListenerEvent::NewAddress(addr)),
-                    Ok(addr) => self
+                        Err(err) => self.pending_events.push_back(ListenerEvent::Error(err)),
-                        .pending_events
+                    }
-                        .push_back(ListenerEvent::NewAddress(addr)),
-                    Err(err) => self.pending_events.push_back(ListenerEvent::Error(err)),
                 }
             }
         }