fixes for nightly clippy

linkerd/addr/src/addr_match.rs

@@ -1,7 +1,7 @@
 use crate::Addr;
 use ipnet::IpNet;
 use linkerd_dns_name::{Name, Suffix};
-use std::{fmt, iter::FromIterator, net::IpAddr, sync::Arc};
+use std::{fmt, net::IpAddr, sync::Arc};
 
 #[derive(Clone, Debug, Default)]
 pub struct AddrMatch {

linkerd/app/admin/src/server/readiness.rs

@@ -8,7 +8,7 @@ pub struct Readiness(Weak<()>);
 
 /// When all latches are dropped, the process is considered ready.
 #[derive(Clone, Debug)]
-pub struct Latch(Arc<()>);
+pub struct Latch(#[allow(dead_code)] Arc<()>);
 
 impl Readiness {
     pub fn new() -> (Readiness, Latch) {

linkerd/app/gateway/src/http.rs

@@ -14,10 +14,7 @@ use linkerd_app_core::{
 };
 use linkerd_app_inbound as inbound;
 use linkerd_app_outbound as outbound;
-use std::{
-    cmp::{Eq, PartialEq},
-    fmt::Debug,
-};
+use std::fmt::Debug;
 use tokio::sync::watch;
 
 mod gateway;

linkerd/app/inbound/src/direct.rs

@@ -11,7 +11,7 @@ use linkerd_app_core::{
     transport_header::{self, NewTransportHeaderServer, SessionProtocol, TransportHeader},
     Conditional, Error, Infallible, NameAddr, Result,
 };
-use std::{convert::TryFrom, fmt::Debug};
+use std::fmt::Debug;
 use thiserror::Error;
 use tracing::{debug_span, info_span};
 

linkerd/app/integration/src/client.rs

@@ -2,13 +2,10 @@ use super::*;
 use linkerd_app_core::proxy::http::trace;
 use parking_lot::Mutex;
 use std::io;
-use std::{convert::TryFrom, sync::Arc};
 use tokio::net::TcpStream;
-use tokio::sync::{mpsc, oneshot};
 use tokio::task::JoinHandle;
 use tokio_rustls::rustls::{self, ClientConfig};
 use tracing::info_span;
-use tracing::instrument::Instrument;
 
 type ClientError = hyper::Error;
 type Request = http::Request<hyper::Body>;

linkerd/app/integration/src/controller.rs

@@ -4,14 +4,11 @@ pub use linkerd2_proxy_api::destination as pb;
 use linkerd2_proxy_api::net;
 use linkerd_app_core::proxy::http::trace;
 use parking_lot::Mutex;
-use std::collections::{HashMap, VecDeque};
+use std::collections::VecDeque;
 use std::net::IpAddr;
 use std::ops::{Bound, RangeBounds};
-use std::sync::Arc;
-use tokio::sync::mpsc;
 use tokio_stream::wrappers::UnboundedReceiverStream;
 use tonic as grpc;
-use tracing::instrument::Instrument;
 
 pub fn new() -> Controller {
     Controller::new()

linkerd/app/integration/src/identity.rs

@@ -4,8 +4,7 @@ use std::{
     collections::VecDeque,
     fs, io,
     path::{Path, PathBuf},
-    sync::Arc,
-    time::{Duration, SystemTime},
+    time::SystemTime,
 };
 
 use linkerd2_proxy_api::identity as pb;

linkerd/app/integration/src/lib.rs

@@ -23,9 +23,8 @@ mod tests;
 
 pub use self::test_env::TestEnv;
 pub use bytes::{Buf, BufMut, Bytes};
-pub use futures::{future, FutureExt, TryFuture, TryFutureExt};
-
 pub use futures::stream::{Stream, StreamExt};
+pub use futures::{future, FutureExt, TryFuture, TryFutureExt};
 pub use http::{HeaderMap, Request, Response, StatusCode};
 pub use http_body::Body as HttpBody;
 pub use linkerd_app as app;
@@ -43,7 +42,7 @@ use std::task::{Context, Poll};
 pub use std::time::Duration;
 pub use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, AsyncWriteExt, ReadBuf};
 use tokio::net::TcpListener;
-pub use tokio::sync::oneshot;
+pub use tokio::sync::{mpsc, oneshot};
 pub use tonic as grpc;
 pub use tower::Service;
 

linkerd/app/integration/src/metrics.rs

@@ -1,6 +1,5 @@
 use std::collections::HashMap;
 use std::fmt;
-use std::string::ToString;
 
 #[derive(Debug, Clone)]
 pub struct MetricMatch {

linkerd/app/integration/src/policy.rs

@@ -4,8 +4,7 @@ use api::{inbound::inbound_server_policies_server, outbound::outbound_policies_s
 use futures::stream;
 use linkerd2_proxy_api as api;
 use parking_lot::Mutex;
-use std::{collections::VecDeque, sync::Arc, time::Duration};
-use tokio::sync::mpsc;
+use std::collections::VecDeque;
 use tokio_stream::wrappers::UnboundedReceiverStream;
 use tonic as grpc;
 

linkerd/app/integration/src/proxy.rs

@@ -5,11 +5,8 @@ use linkerd_app_core::{
     transport::{listen, orig_dst, Keepalive, ListenAddr},
     Result,
 };
-use std::{
-    collections::HashSet, fmt, future::Future, net::SocketAddr, pin::Pin, task::Poll, thread,
-};
+use std::{collections::HashSet, thread};
 use tokio::net::TcpStream;
-use tracing::instrument::Instrument;
 
 pub fn new() -> Proxy {
     Proxy::default()

linkerd/app/integration/src/server.rs

@@ -1,18 +1,11 @@
 use super::*;
-use futures::TryFuture;
 use linkerd_app_core::proxy::http::trace;
 use std::{
-    collections::HashMap,
-    future::Future,
     io,
-    pin::Pin,
     sync::atomic::{AtomicUsize, Ordering},
-    sync::Arc,
-    task::{Context, Poll},
 };
-use tokio::{net::TcpStream, sync::oneshot, task::JoinHandle};
+use tokio::{net::TcpStream, task::JoinHandle};
 use tokio_rustls::{rustls::ServerConfig, TlsAcceptor};
-use tracing::instrument::Instrument;
 
 pub fn new() -> Server {
     http2()

linkerd/app/integration/src/tcp.rs

@@ -2,14 +2,9 @@ use super::*;
 use std::collections::VecDeque;
 use std::io;
 use std::net::TcpListener as StdTcpListener;
-use std::pin::Pin;
 use std::sync::atomic::{AtomicUsize, Ordering};
-use std::sync::Arc;
-use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::TcpStream;
-use tokio::sync::{mpsc, oneshot};
 use tokio::task::JoinHandle;
-use tracing::instrument::Instrument;
 
 type TcpConnSender = mpsc::UnboundedSender<(
     Option<Vec<u8>>,

linkerd/app/outbound/src/http/handle_proxy_error_headers.rs

@@ -5,7 +5,6 @@ use linkerd_app_core::{
     svc, tls,
 };
 use std::{
-    future::Future,
     pin::Pin,
     task::{Context, Poll},
 };

linkerd/app/outbound/src/tcp/endpoint.rs

@@ -1,13 +1,6 @@
 use super::{tagged_transport::TaggedTransport, *};
-use crate::{ConnectMeta, Outbound};
-use linkerd_app_core::{
-    io,
-    proxy::http,
-    svc, tls,
-    transport::{self, ClientAddr, Local, Remote, ServerAddr},
-    transport_header::SessionProtocol,
-    Error,
-};
+use crate::ConnectMeta;
+use linkerd_app_core::{proxy::http, tls, transport_header::SessionProtocol};
 
 impl<C> Outbound<C> {
     pub fn push_tcp_endpoint<T>(

linkerd/app/outbound/src/tcp/tagged_transport.rs

@@ -9,7 +9,6 @@ use linkerd_app_core::{
     Conditional, Error, Result,
 };
 use std::{
-    future::Future,
     pin::Pin,
     str::FromStr,
     task::{Context, Poll},

linkerd/duplex/src/lib.rs

@@ -48,12 +48,14 @@ struct CopyBuf {
     write_pos: usize,
 }
 
+#[allow(dead_code)]
 enum Buffered {
     NotEmpty,
     Read(usize),
     Eof,
 }
 
+#[allow(dead_code)]
 enum Drained {
     BufferEmpty,
     Partial(usize),

linkerd/identity/src/lib.rs

@@ -5,7 +5,6 @@ mod credentials;
 mod metrics;
 
 use linkerd_error::{Error, Result};
-use std::convert::From;
 use std::str::FromStr;
 
 pub use self::{

linkerd/metrics/src/fmt.rs

@@ -1,5 +1,5 @@
 use std::fmt;
-use std::marker::{PhantomData, Sized};
+use std::marker::PhantomData;
 
 /// Writes a block of metrics in prometheus-formatted output.
 pub trait FmtMetrics {

linkerd/proxy/core/src/resolve.rs

@@ -2,7 +2,6 @@ use futures::prelude::*;
 use linkerd_error::Error;
 use std::{
     fmt::Debug,
-    future::Future,
     net::SocketAddr,
     task::{Context, Poll},
 };

linkerd/proxy/dns-resolve/src/lib.rs

@@ -1,7 +1,7 @@
 #![deny(rust_2018_idioms, clippy::disallowed_methods, clippy::disallowed_types)]
 #![forbid(unsafe_code)]
 
-use futures::{future, prelude::*, stream};
+use futures::prelude::*;
 use linkerd_addr::{Addr, NameAddr};
 use linkerd_dns as dns;
 use linkerd_error::Error;

linkerd/proxy/http/src/classify/channel.rs

@@ -5,7 +5,6 @@ use linkerd_stack::{layer, ExtractParam, NewService, Service};
 use pin_project::{pin_project, pinned_drop};
 use std::{
     fmt::Debug,
-    future::Future,
     marker::PhantomData,
     pin::Pin,
     task::{Context, Poll},

linkerd/proxy/http/src/h1.rs

@@ -10,7 +10,7 @@ use http::{
 use linkerd_error::{Error, Result};
 use linkerd_http_box::BoxBody;
 use linkerd_stack::MakeConnection;
-use std::{future::Future, mem, pin::Pin, time::Duration};
+use std::{mem, pin::Pin, time::Duration};
 use tracing::{debug, trace};
 
 #[derive(Copy, Clone, Debug)]

linkerd/proxy/http/src/h2.rs

@@ -8,7 +8,6 @@ use hyper::{
 use linkerd_error::{Error, Result};
 use linkerd_stack::{MakeConnection, Service};
 use std::{
-    future::Future,
     marker::PhantomData,
     pin::Pin,
     task::{Context, Poll},

linkerd/proxy/http/src/orig_proto.rs

@@ -1,12 +1,11 @@
 use super::{h1, h2, upgrade};
-use futures::{future, prelude::*};
+use futures::prelude::*;
 use http::header::{HeaderValue, TRANSFER_ENCODING};
 use hyper::body::HttpBody;
 use linkerd_error::{Error, Result};
 use linkerd_http_box::BoxBody;
 use linkerd_stack::{layer, MakeConnection, Service};
 use std::{
-    future::Future,
     pin::Pin,
     task::{Context, Poll},
 };

linkerd/proxy/http/src/override_authority.rs

@@ -1,5 +1,5 @@
 use super::h1;
-use http::{self, header::AsHeaderName, uri::Authority};
+use http::{header::AsHeaderName, uri::Authority};
 use linkerd_stack::{layer, NewService, Param};
 use std::{
     fmt,

linkerd/proxy/resolve/src/recover.rs

@@ -1,11 +1,9 @@
 //! A middleware that recovers a resolution after some failures.
 
-use futures::stream::TryStream;
-use futures::{prelude::*, ready, FutureExt, Stream};
+use futures::{prelude::*, ready};
 use linkerd_error::{Error, Recover};
 use linkerd_proxy_core::resolve::{self, Update};
 use pin_project::pin_project;
-use std::future::Future;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 use thiserror::Error;

linkerd/proxy/server-policy/src/authz.rs

@@ -56,7 +56,7 @@ impl Suffix {
 #[cfg(feature = "proto")]
 pub mod proto {
     use super::*;
-    use crate::{authz::Network, meta::proto::InvalidMeta};
+    use crate::meta::proto::InvalidMeta;
     use linkerd2_proxy_api::{inbound as api, net::InvalidIpNetwork};
 
     #[derive(Debug, thiserror::Error)]

linkerd/proxy/tap/src/grpc/match_.rs

@@ -2,7 +2,7 @@ use crate::Inspect;
 use ipnet::{Ipv4Net, Ipv6Net};
 use linkerd2_proxy_api::net::ip_address;
 use linkerd2_proxy_api::tap::observe_request;
-use std::{boxed::Box, collections::BTreeMap, net, str::FromStr};
+use std::{collections::BTreeMap, net, str::FromStr};
 use thiserror::Error;
 
 #[derive(Clone, Debug)]

linkerd/proxy/tap/src/grpc/server.rs

@@ -8,7 +8,6 @@ use linkerd_conditional::Conditional;
 use linkerd_proxy_http::HasH2Reason;
 use linkerd_tls as tls;
 use pin_project::pin_project;
-use std::convert::TryFrom;
 use std::iter;
 use std::pin::Pin;
 use std::sync::atomic::{AtomicUsize, Ordering};

linkerd/proxy/tcp/src/forward.rs

@@ -3,7 +3,6 @@ use linkerd_duplex::Duplex;
 use linkerd_error::{Error, Result};
 use linkerd_stack::layer;
 use std::{
-    future::Future,
     pin::Pin,
     task::{Context, Poll},
 };

linkerd/reconnect/src/lib.rs

@@ -5,7 +5,7 @@
 #[cfg(test)]
 mod tests;
 
-use futures::{future, prelude::*, ready};
+use futures::{prelude::*, ready};
 use linkerd_error::{Error, Recover};
 use linkerd_stack::{layer, NewService, Service};
 use std::task::{Context, Poll};

linkerd/router/src/lib.rs

@@ -1,7 +1,7 @@
 #![deny(rust_2018_idioms, clippy::disallowed_methods, clippy::disallowed_types)]
 #![forbid(unsafe_code)]
 
-use futures::{future, prelude::*};
+use futures::prelude::*;
 use linkerd_error::Error;
 use linkerd_stack::{layer, ExtractParam, NewService, Oneshot, Service, ServiceExt};
 use std::{

linkerd/service-profiles/src/default.rs

@@ -1,5 +1,5 @@
 use crate::{GetProfile, LookupAddr, Receiver};
-use futures::{future, prelude::*};
+use futures::prelude::*;
 use linkerd_error::Error;
 use std::task::{Context, Poll};
 use tracing::debug;

linkerd/service-profiles/src/http/proxy.rs

@@ -1,6 +1,6 @@
 use super::{RequestMatch, Route};
 use crate::{Profile, Receiver, ReceiverStream};
-use futures::{future, prelude::*};
+use futures::prelude::*;
 use linkerd_error::{Error, Result};
 use linkerd_stack::{layer, NewService, Param, Proxy, Service};
 use std::{

linkerd/system/src/linux.rs

@@ -1,4 +1,4 @@
-use libc::{self, pid_t};
+use libc::pid_t;
 use procfs::{
     process::{self, LimitValue, Process},
     ProcResult,

linkerd/tls/src/client.rs

@@ -6,7 +6,6 @@ use linkerd_io as io;
 use linkerd_stack::{layer, MakeConnection, NewService, Oneshot, Param, Service, ServiceExt};
 use std::{
     fmt,
-    future::Future,
     ops::Deref,
     pin::Pin,
     str::FromStr,

linkerd/trace-context/src/lib.rs

@@ -9,7 +9,6 @@ use bytes::Bytes;
 use linkerd_error::Error;
 use rand::Rng;
 use std::collections::HashMap;
-use std::convert::TryFrom;
 use std::fmt;
 use std::time::SystemTime;
 use thiserror::Error;

linkerd/trace-context/src/service.rs

@@ -3,7 +3,6 @@ use futures::{future::Either, prelude::*};
 use linkerd_stack::layer;
 use std::{
     collections::HashMap,
-    future::Future,
     pin::Pin,
     task::{Context, Poll},
     time::SystemTime,