fluencelabs/rust-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/rust-libp2p synced 2025-06-10 16:41:21 +00:00
Code Issues Projects Releases Wiki Activity

Fix some rustc/clippy warnings. (#895)

Browse Source
This commit is contained in:
Toralf Wittner
2019-01-30 15:41:54 +01:00
committed by GitHub
parent a77da73010
commit e23b2733e2
25 changed files with 63 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
core/src/either.rs
View File

@ -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)
}
}
}

2
core/src/nodes/handled_node_tasks/tests.rs
View File

@ -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,

14
core/src/nodes/raw_swarm.rs
View File

@ -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,

12
core/src/nodes/raw_swarm/tests.rs
View File

@ -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

4
core/src/swarm.rs
View File

@ -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);
}
},

4
core/src/transport/map_err.rs
View File

@ -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)),
}
}

2
core/src/upgrade/error.rs
View File

@ -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>
{

6
misc/core-derive/tests/test.rs
View File

@ -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>>();
}

4
misc/mdns/src/lib.rs
View File

@ -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;

4
misc/multistream-select/src/dialer_select.rs
View File

@ -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 }
}
}

2
misc/multistream-select/src/lib.rs
View File

@ -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;

4
misc/multistream-select/src/listener_select.rs
View File

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

4
misc/multistream-select/src/protocol/dialer.rs
View File

@ -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 })

6
misc/multistream-select/src/protocol/listener.rs
View File

@ -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)) {

4
misc/multistream-select/src/tests.rs
View File

@ -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 })

5
misc/rw-stream-sink/src/lib.rs
View File

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

14
muxers/mplex/src/codec.rs
View File

@ -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())
},
};

4
muxers/mplex/src/lib.rs
View File

@ -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(()))
}

4
protocols/floodsub/src/topic.rs
View File

@ -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`.

4
protocols/identify/src/protocol.rs
View File

@ -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(),
};

4
protocols/kad/src/protocol.rs
View File

@ -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
})
}
}

2
protocols/secio/src/codec/decode.rs
View File

@ -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);

4
protocols/secio/src/handshake.rs
View File

@ -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)
};

2
src/lib.rs
View File

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

4
transports/dns/src/lib.rs
View File

@ -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()))
}
}
}