Fix some rustc/clippy warnings. (#895)

core/src/either.rs

@@ -335,11 +335,11 @@ where
         match self {
             EitherFuture2::A(a) => a.poll()
                 .map(|v| v.map(EitherOutput::First))
-                .map_err(|e| EitherError::A(e)),
+                .map_err(EitherError::A),
 
             EitherFuture2::B(b) => b.poll()
                 .map(|v| v.map(EitherOutput::Second))
-                .map_err(|e| EitherError::B(e))
+                .map_err(EitherError::B)
         }
     }
 }

core/src/nodes/handled_node_tasks/tests.rs

@@ -90,7 +90,7 @@ impl NodeTaskTestBuilder {
             }
         };
         let node_task = NodeTask {
-            inner: inner,
+            inner,
             events_tx: events_from_node_task_tx.clone(), // events TO the outside
             in_events_rx: events_to_node_task_rx.fuse(), // events FROM the outside
             id: self.task_id,

core/src/nodes/raw_swarm.rs

@@ -248,7 +248,7 @@ where
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         match *self {
-            RawSwarmEvent::ListenerClosed { ref listen_addr, listener: _, ref result } => {
+            RawSwarmEvent::ListenerClosed { ref listen_addr, ref result, .. } => {
                 f.debug_struct("ListenerClosed")
                     .field("listen_addr", listen_addr)
                     .field("result", result)
@@ -1327,7 +1327,7 @@ where
 {
     fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         match *self {
-            Peer::Connected( PeerConnected { peer: _, ref peer_id, ref connected_points }) => {
+            Peer::Connected( PeerConnected { ref peer_id, ref connected_points, .. }) => {
                 f.debug_struct("Connected")
                     .field("peer_id", peer_id)
                     .field("connected_points", connected_points)
@@ -1371,7 +1371,7 @@ where
 {
     /// If we are connected, returns the `PeerConnected`.
     #[inline]
-    pub fn as_connected(self) -> Option<PeerConnected<'a, TInEvent, TPeerId>> {
+    pub fn into_connected(self) -> Option<PeerConnected<'a, TInEvent, TPeerId>> {
         match self {
             Peer::Connected(peer) => Some(peer),
             _ => None,
@@ -1380,7 +1380,7 @@ where
 
     /// If a connection is pending, returns the `PeerPendingConnect`.
     #[inline]
-    pub fn as_pending_connect(self) -> Option<PeerPendingConnect<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TPeerId>> {
+    pub fn into_pending_connect(self) -> Option<PeerPendingConnect<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TPeerId>> {
         match self {
             Peer::PendingConnect(peer) => Some(peer),
             _ => None,
@@ -1389,7 +1389,7 @@ where
 
     /// If we are not connected, returns the `PeerNotConnected`.
     #[inline]
-    pub fn as_not_connected(self) -> Option<PeerNotConnected<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TPeerId>> {
+    pub fn into_not_connected(self) -> Option<PeerNotConnected<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TPeerId>> {
         match self {
             Peer::NotConnected(peer) => Some(peer),
             _ => None,
@@ -1464,7 +1464,7 @@ where
 
     /// If we are connected, returns the `PeerConnected`.
     #[inline]
-    pub fn as_connected(self) -> Option<PeerConnected<'a, TInEvent, TPeerId>> {
+    pub fn into_connected(self) -> Option<PeerConnected<'a, TInEvent, TPeerId>> {
         match self {
             PeerPotentialConnect::Connected(peer) => Some(peer),
             _ => None,
@@ -1473,7 +1473,7 @@ where
 
     /// If a connection is pending, returns the `PeerPendingConnect`.
     #[inline]
-    pub fn as_pending_connect(self) -> Option<PeerPendingConnect<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TPeerId>> {
+    pub fn into_pending_connect(self) -> Option<PeerPendingConnect<'a, TTrans, TInEvent, TOutEvent, THandler, THandlerErr, TPeerId>> {
         match self {
             PeerPotentialConnect::PendingConnect(peer) => Some(peer),
             _ => None,

core/src/nodes/raw_swarm/tests.rs

@@ -131,7 +131,7 @@ fn num_incoming_negotiated() {
     swarm.listen_on("/memory".parse().unwrap()).unwrap();
 
     // no incoming yet
-    assert_eq!(swarm.num_incoming_negotiated(), 0);
+    assert_eq!(swarm.incoming_negotiated().count(), 0);
 
     let mut rt = Runtime::new().unwrap();
     let swarm = Arc::new(Mutex::new(swarm));
@@ -147,7 +147,7 @@ fn num_incoming_negotiated() {
     rt.block_on(fut).expect("tokio works");
     let swarm = swarm.lock();
     // Now there's an incoming connection
-    assert_eq!(swarm.num_incoming_negotiated(), 1);
+    assert_eq!(swarm.incoming_negotiated().count(), 1);
 }
 
 #[test]
@@ -204,7 +204,7 @@ fn querying_for_pending_peer() {
     let peer = swarm.peer(peer_id.clone());
     assert_matches!(peer, Peer::NotConnected(PeerNotConnected{ .. }));
     let addr = "/memory".parse().expect("bad multiaddr");
-    let pending_peer = peer.as_not_connected().unwrap().connect(addr, Handler::default());
+    let pending_peer = peer.into_not_connected().unwrap().connect(addr, Handler::default());
     assert_matches!(pending_peer, PeerPendingConnect { .. });
 }
 
@@ -312,7 +312,7 @@ fn known_peer_that_is_unreachable_yields_dial_error() {
         let peer = swarm1.peer(peer_id.clone());
         assert_matches!(peer, Peer::NotConnected(PeerNotConnected{ .. }));
         let addr = "/memory".parse::<Multiaddr>().expect("bad multiaddr");
-        let pending_peer = peer.as_not_connected().unwrap().connect(addr, Handler::default());
+        let pending_peer = peer.into_not_connected().unwrap().connect(addr, Handler::default());
         assert_matches!(pending_peer, PeerPendingConnect { .. });
     }
     let mut rt = Runtime::new().unwrap();
@@ -354,7 +354,7 @@ fn yields_node_error_when_there_is_an_error_after_successful_connect() {
         let mut handler = Handler::default();
         // Force an error
         handler.next_states = vec![ HandlerState::Err ];
-        peer.as_not_connected().unwrap().connect(addr, handler);
+        peer.into_not_connected().unwrap().connect(addr, handler);
     }
 
     // Ensure we run on a single thread
@@ -408,7 +408,7 @@ fn yields_node_closed_when_the_node_closes_after_successful_connect() {
         let mut handler = Handler::default();
         // Force handler to close
         handler.next_states = vec![ HandlerState::Ready(None) ];
-        peer.as_not_connected().unwrap().connect(addr, handler);
+        peer.into_not_connected().unwrap().connect(addr, handler);
     }
 
     // Ensure we run on a single thread

core/src/swarm.rs

@@ -181,7 +181,7 @@ where TBehaviour: NetworkBehaviour,
     pub fn dial(me: &mut Self, peer_id: PeerId) {
         let addrs = me.behaviour.addresses_of_peer(&peer_id);
         let handler = me.behaviour.new_handler().into_node_handler_builder();
-        if let Some(peer) = me.raw_swarm.peer(peer_id).as_not_connected() {
+        if let Some(peer) = me.raw_swarm.peer(peer_id).into_not_connected() {
             let _ = peer.connect_iter(addrs, handler);
         }
     }
@@ -294,7 +294,7 @@ where TBehaviour: NetworkBehaviour,
                     Swarm::dial(self, peer_id)
                 },
                 Async::Ready(NetworkBehaviourAction::SendEvent { peer_id, event }) => {
-                    if let Some(mut peer) = self.raw_swarm.peer(peer_id).as_connected() {
+                    if let Some(mut peer) = self.raw_swarm.peer(peer_id).into_connected() {
                         peer.send_event(event);
                     }
                 },

core/src/transport/map_err.rs

@@ -58,7 +58,7 @@ where
                 let stream = MapErrListener { inner: stream, map };
                 Ok((stream, listen_addr))
             }
-            Err(err) => Err(err.map(move |err| map(err))),
+            Err(err) => Err(err.map(map)),
         }
     }
 
@@ -67,7 +67,7 @@ where
 
         match self.transport.dial(addr) {
             Ok(future) => Ok(MapErrDial { inner: future, map: Some(map) }),
-            Err(err) => Err(err.map(move |err| map(err))),
+            Err(err) => Err(err.map(map)),
         }
     }
 

core/src/upgrade/error.rs

@@ -41,7 +41,7 @@ impl<E> UpgradeError<E> {
         }
     }
 
-    pub fn from_err<T>(self) -> UpgradeError<T>
+    pub fn into_err<T>(self) -> UpgradeError<T>
     where
         T: From<E>
     {

misc/core-derive/tests/test.rs

@@ -47,6 +47,7 @@ fn one_field() {
         }
     }
 
+    #[allow(dead_code)]
     fn foo<TSubstream: libp2p::tokio_io::AsyncRead + libp2p::tokio_io::AsyncWrite>() {
         require_net_behaviour::<Foo<TSubstream>>();
     }
@@ -71,6 +72,7 @@ fn two_fields() {
         }
     }
 
+    #[allow(dead_code)]
     fn foo<TSubstream: libp2p::tokio_io::AsyncRead + libp2p::tokio_io::AsyncWrite>() {
         require_net_behaviour::<Foo<TSubstream>>();
     }
@@ -103,6 +105,7 @@ fn three_fields() {
         }
     }
 
+    #[allow(dead_code)]
     fn foo<TSubstream: libp2p::tokio_io::AsyncRead + libp2p::tokio_io::AsyncWrite>() {
         require_net_behaviour::<Foo<TSubstream>>();
     }
@@ -132,6 +135,7 @@ fn custom_polling() {
         fn foo<T>(&mut self) -> libp2p::futures::Async<libp2p::core::swarm::NetworkBehaviourAction<T, ()>> { libp2p::futures::Async::NotReady }
     }
 
+    #[allow(dead_code)]
     fn foo<TSubstream: libp2p::tokio_io::AsyncRead + libp2p::tokio_io::AsyncWrite>() {
         require_net_behaviour::<Foo<TSubstream>>();
     }
@@ -157,6 +161,7 @@ fn custom_event_no_polling() {
         }
     }
 
+    #[allow(dead_code)]
     fn foo<TSubstream: libp2p::tokio_io::AsyncRead + libp2p::tokio_io::AsyncWrite>() {
         require_net_behaviour::<Foo<TSubstream>>();
     }
@@ -186,6 +191,7 @@ fn custom_event_and_polling() {
         fn foo<T>(&mut self) -> libp2p::futures::Async<libp2p::core::swarm::NetworkBehaviourAction<T, String>> { libp2p::futures::Async::NotReady }
     }
 
+    #[allow(dead_code)]
     fn foo<TSubstream: libp2p::tokio_io::AsyncRead + libp2p::tokio_io::AsyncWrite>() {
         require_net_behaviour::<Foo<TSubstream>>();
     }

misc/mdns/src/lib.rs

@@ -48,9 +48,9 @@ extern crate void;
 extern crate tokio;
 
 /// Hardcoded name of the mDNS service. Part of the mDNS libp2p specifications.
-const SERVICE_NAME: &'static [u8] = b"_p2p._udp.local";
+const SERVICE_NAME: &[u8] = b"_p2p._udp.local";
 /// Hardcoded name of the service used for DNS-SD.
-const META_QUERY_SERVICE: &'static [u8] = b"_services._dns-sd._udp.local";
+const META_QUERY_SERVICE: &[u8] = b"_services._dns-sd._udp.local";
 
 pub use self::behaviour::{Mdns, MdnsEvent};
 pub use self::service::MdnsService;

misc/multistream-select/src/dialer_select.rs

@@ -75,7 +75,7 @@ where
 {
     let protocols = protocols.into_iter();
     DialerSelectSeq {
-        inner: DialerSelectSeqState::AwaitDialer { dialer_fut: Dialer::new(inner), protocols }
+        inner: DialerSelectSeqState::AwaitDialer { dialer_fut: Dialer::dial(inner), protocols }
     }
 }
 
@@ -240,7 +240,7 @@ where
 {
     let protocols = protocols.into_iter();
     DialerSelectPar {
-        inner: DialerSelectParState::AwaitDialer { dialer_fut: Dialer::new(inner), protocols }
+        inner: DialerSelectParState::AwaitDialer { dialer_fut: Dialer::dial(inner), protocols }
     }
 }
 

misc/multistream-select/src/lib.rs

@@ -72,7 +72,7 @@ mod length_delimited;
 mod listener_select;
 mod tests;
 
-pub mod protocol;
+mod protocol;
 
 pub use self::dialer_select::{dialer_select_proto, DialerSelectFuture};
 pub use self::error::ProtocolChoiceError;

misc/multistream-select/src/listener_select.rs

@@ -55,8 +55,8 @@ where
 {
     ListenerSelectFuture {
         inner: ListenerSelectState::AwaitListener {
-            listener_fut: Listener::new(inner),
+            listener_fut: Listener::listen(inner),
-            protocols: protocols
+            protocols
         }
     }
 }

misc/multistream-select/src/protocol/dialer.rs

@@ -44,7 +44,7 @@ where
     R: AsyncRead + AsyncWrite,
     N: AsRef<[u8]>
 {
-    pub fn new(inner: R) -> DialerFuture<R, N> {
+    pub fn dial(inner: R) -> DialerFuture<R, N> {
         let codec = MessageEncoder(std::marker::PhantomData);
         let sender = LengthDelimited::new(inner, codec);
         DialerFuture {
@@ -223,7 +223,7 @@ mod tests {
 
         let client = TcpStream::connect(&listener_addr)
             .from_err()
-            .and_then(move |stream| Dialer::new(stream))
+            .and_then(move |stream| Dialer::dial(stream))
             .and_then(move |dialer| {
                 let p = b"invalid_name";
                 dialer.send(DialerToListenerMessage::ProtocolRequest { name: p })

misc/multistream-select/src/protocol/listener.rs

@@ -46,7 +46,7 @@ where
 {
     /// Takes ownership of a socket and starts the handshake. If the handshake succeeds, the
     /// future returns a `Listener`.
-    pub fn new(inner: R) -> ListenerFuture<R, N> {
+    pub fn listen(inner: R) -> ListenerFuture<R, N> {
         let codec = MessageEncoder(std::marker::PhantomData);
         let inner = LengthDelimited::new(inner, codec);
         ListenerFuture {
@@ -258,7 +258,7 @@ mod tests {
             .incoming()
             .into_future()
             .map_err(|(e, _)| e.into())
-            .and_then(move |(connec, _)| Listener::new(connec.unwrap()))
+            .and_then(move |(connec, _)| Listener::listen(connec.unwrap()))
             .and_then(|listener| {
                 let proto_name = Bytes::from("invalid-proto");
                 listener.send(ListenerToDialerMessage::ProtocolAck { name: proto_name })
@@ -266,7 +266,7 @@ mod tests {
 
         let client = TcpStream::connect(&listener_addr)
             .from_err()
-            .and_then(move |stream| Dialer::<_, Bytes>::new(stream));
+            .and_then(move |stream| Dialer::<_, Bytes>::dial(stream));
 
         let mut rt = Runtime::new().unwrap();
         match rt.block_on(server.join(client)) {

misc/multistream-select/src/tests.rs

@@ -52,7 +52,7 @@ fn negotiate_with_self_succeeds() {
         .incoming()
         .into_future()
         .map_err(|(e, _)| e.into())
-        .and_then(move |(connec, _)| Listener::new(connec.unwrap()))
+        .and_then(move |(connec, _)| Listener::listen(connec.unwrap()))
         .and_then(|l| l.into_future().map_err(|(e, _)| e))
         .and_then(|(msg, rest)| {
             let proto = match msg {
@@ -64,7 +64,7 @@ fn negotiate_with_self_succeeds() {
 
     let client = TcpStream::connect(&listener_addr)
         .from_err()
-        .and_then(move |stream| Dialer::new(stream))
+        .and_then(move |stream| Dialer::dial(stream))
         .and_then(move |dialer| {
             let p = b"/hello/1.0.0";
             dialer.send(DialerToListenerMessage::ProtocolRequest { name: p })

misc/rw-stream-sink/src/lib.rs

@@ -57,10 +57,7 @@ where
     /// Wraps around `inner`.
     #[inline]
     pub fn new(inner: S) -> RwStreamSink<S> {
-        RwStreamSink {
+        RwStreamSink { inner, current_item: None }
-            inner: inner,
-            current_item: None,
-        }
     }
 }
 

muxers/mplex/src/codec.rs

@@ -177,25 +177,25 @@ impl Encoder for Codec {
     fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(), Self::Error> {
         let (header, data) = match item {
             Elem::Open { substream_id } => {
-                ((substream_id as u64) << 3, Bytes::new())
+                (u64::from(substream_id) << 3, Bytes::new())
             },
             Elem::Data { substream_id, endpoint: Endpoint::Listener, data } => {
-                ((substream_id as u64) << 3 | 1, data)
+                (u64::from(substream_id) << 3 | 1, data)
             },
             Elem::Data { substream_id, endpoint: Endpoint::Dialer, data } => {
-                ((substream_id as u64) << 3 | 2, data)
+                (u64::from(substream_id) << 3 | 2, data)
             },
             Elem::Close { substream_id, endpoint: Endpoint::Listener } => {
-                ((substream_id as u64) << 3 | 3, Bytes::new())
+                (u64::from(substream_id) << 3 | 3, Bytes::new())
             },
             Elem::Close { substream_id, endpoint: Endpoint::Dialer } => {
-                ((substream_id as u64) << 3 | 4, Bytes::new())
+                (u64::from(substream_id) << 3 | 4, Bytes::new())
             },
             Elem::Reset { substream_id, endpoint: Endpoint::Listener } => {
-                ((substream_id as u64) << 3 | 5, Bytes::new())
+                (u64::from(substream_id) << 3 | 5, Bytes::new())
             },
             Elem::Reset { substream_id, endpoint: Endpoint::Dialer } => {
-                ((substream_id as u64) << 3 | 6, Bytes::new())
+                (u64::from(substream_id) << 3 | 6, Bytes::new())
             },
         };
 

muxers/mplex/src/lib.rs

@@ -459,7 +459,7 @@ where C: AsyncRead + AsyncWrite
     fn read_substream(&self, substream: &mut Self::Substream, buf: &mut [u8]) -> Poll<usize, IoError> {
         loop {
             // First, transfer from `current_data`.
-            if substream.current_data.len() != 0 {
+            if !substream.current_data.is_empty() {
                 let len = cmp::min(substream.current_data.len(), buf.len());
                 buf[..len].copy_from_slice(&substream.current_data.split_to(len));
                 return Ok(Async::Ready(len));
@@ -549,7 +549,7 @@ where C: AsyncRead + AsyncWrite
     #[inline]
     fn shutdown(&self, _: Shutdown) -> Poll<(), IoError> {
         let inner = &mut *self.inner.lock();
-        let () = try_ready!(inner.inner.close_notify(&inner.notifier_write, 0));
+        try_ready!(inner.inner.close_notify(&inner.notifier_write, 0));
         inner.is_shutdown = true;
         Ok(Async::Ready(()))
     }

protocols/floodsub/src/topic.rs

@@ -35,7 +35,7 @@ impl TopicHash {
     /// Builds a new `TopicHash` from the given hash.
     #[inline]
     pub fn from_raw(hash: String) -> TopicHash {
-        TopicHash { hash: hash }
+        TopicHash { hash }
     }
 
     #[inline]
@@ -94,7 +94,7 @@ impl TopicBuilder {
         let mut builder = rpc_proto::TopicDescriptor::new();
         builder.set_name(name.into());
 
-        TopicBuilder { builder: builder }
+        TopicBuilder { builder }
     }
 
     /// Turns the builder into an actual `Topic`.

protocols/identify/src/protocol.rs

@@ -208,7 +208,7 @@ where T: AsyncRead + AsyncWrite,
             Ok(v) => v,
             Err(err) => {
                 debug!("Failed to parse protobuf message; error = {:?}", err);
-                return Err(err.into());
+                return Err(err)
             }
         };
 
@@ -248,7 +248,7 @@ fn parse_proto_msg(msg: BytesMut) -> Result<(IdentifyInfo, Multiaddr), IoError>
                 public_key: PublicKey::from_protobuf_encoding(msg.get_publicKey())?,
                 protocol_version: msg.take_protocolVersion(),
                 agent_version: msg.take_agentVersion(),
-                listen_addrs: listen_addrs,
+                listen_addrs,
                 protocols: msg.take_protocols().into_vec(),
             };
 

protocols/kad/src/protocol.rs

@@ -112,9 +112,9 @@ impl KadPeer {
         let connection_ty = peer.get_connection().into();
 
         Ok(KadPeer {
-            node_id: node_id,
+            node_id,
             multiaddrs: addrs,
-            connection_ty: connection_ty,
+            connection_ty
         })
     }
 }

protocols/secio/src/codec/decode.rs

@@ -102,7 +102,7 @@ where
 
         if !self.nonce.is_empty() {
             let n = min(data_buf.len(), self.nonce.len());
-            if &data_buf[.. n] != &self.nonce[.. n] {
+            if data_buf[.. n] != self.nonce[.. n] {
                 return Err(SecioError::NonceVerificationFailed)
             }
             self.nonce.drain(.. n);

protocols/secio/src/handshake.rs

@@ -549,7 +549,7 @@ where
             let (encoding_cipher, encoding_hmac) = {
                 let (iv, rest) = local_infos.split_at(iv_size);
                 let (cipher_key, mac_key) = rest.split_at(cipher_key_size);
-                let hmac = Hmac::from_key(context.state.remote.chosen_hash.into(), mac_key);
+                let hmac = Hmac::from_key(context.state.remote.chosen_hash, mac_key);
                 let cipher = ctr(chosen_cipher, cipher_key, iv);
                 (cipher, hmac)
             };
@@ -557,7 +557,7 @@ where
             let (decoding_cipher, decoding_hmac) = {
                 let (iv, rest) = remote_infos.split_at(iv_size);
                 let (cipher_key, mac_key) = rest.split_at(cipher_key_size);
-                let hmac = Hmac::from_key(context.state.remote.chosen_hash.into(), mac_key);
+                let hmac = Hmac::from_key(context.state.remote.chosen_hash, mac_key);
                 let cipher = ctr(chosen_cipher, cipher_key, iv);
                 (cipher, hmac)
             };

src/lib.rs

@@ -279,7 +279,7 @@ impl CommonTransport {
     pub fn new() -> CommonTransport {
         let inner = websocket::BrowserWsConfig::new();
         CommonTransport {
-            inner: CommonTransportInner { inner: inner }
+            inner: CommonTransportInner { inner }
         }
     }
 }

transports/dns/src/lib.rs

@@ -246,7 +246,7 @@ where
     fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
         let ty = self.ty;
         let addrs = try_ready!(self.inner.poll().map_err(|error| {
-            let domain_name = self.name.take().unwrap_or(String::new());
+            let domain_name = self.name.take().unwrap_or_default();
             DnsErr::ResolveError { domain_name, error }
         }));
 
@@ -260,7 +260,7 @@ where
             });
         match addrs.next() {
             Some(a) => Ok(Async::Ready(a)),
-            None => Err(DnsErr::ResolveFail(self.name.take().unwrap_or(String::new())))
+            None => Err(DnsErr::ResolveFail(self.name.take().unwrap_or_default()))
         }
     }
 }