clippy warnings

examples/state/src/main.rs

@@ -46,7 +46,7 @@ impl Handler<ws::Message> for MyWebSocket {
             ws::Message::Ping(msg) => ctx.pong(&msg),
             ws::Message::Text(text) => ctx.text(text),
             ws::Message::Binary(bin) => ctx.binary(bin),
-            ws::Message::Closed | ws::Message::Error => {
+            ws::Message::Close(_) | ws::Message::Error => {
                 ctx.stop();
             }
             _ => (),

examples/websocket-chat/src/main.rs

@@ -161,10 +161,9 @@ impl Handler<ws::Message> for WsChatSession {
             },
             ws::Message::Binary(bin) =>
                 println!("Unexpected binary"),
-            ws::Message::Closed | ws::Message::Error => {
+            ws::Message::Close(_) | ws::Message::Error => {
                 ctx.stop();
             }
-            _ => (),
         }
     }
 }

examples/websocket/src/main.rs

@@ -35,7 +35,7 @@ impl Handler<ws::Message> for MyWebSocket {
             ws::Message::Ping(msg) => ctx.pong(&msg),
             ws::Message::Text(text) => ctx.text(text),
             ws::Message::Binary(bin) => ctx.binary(bin),
-            ws::Message::Closed | ws::Message::Error => {
+            ws::Message::Close(_) | ws::Message::Error => {
                 ctx.stop();
             }
             _ => (),

src/application.rs

@@ -149,7 +149,7 @@ impl<S> Application<S> where S: 'static {
     pub fn with_state(state: S) -> Application<S> {
         Application {
             parts: Some(ApplicationParts {
-                state: state,
+                state,
                 prefix: "/".to_owned(),
                 settings: ServerSettings::default(),
                 default: Resource::default_not_found(),
@@ -361,17 +361,17 @@ impl<S> Application<S> where S: 'static {
                 default: parts.default,
                 encoding: parts.encoding,
                 router: router.clone(),
-                resources: resources,
                 handlers: parts.handlers,
+                resources,
             }
         ));
 
         HttpApplication {
             state: Rc::new(parts.state),
             prefix: prefix.to_owned(),
-            inner: inner,
             router: router.clone(),
             middlewares: Rc::new(parts.middlewares),
+            inner,
         }
     }
 

src/client/parser.rs

@@ -176,12 +176,12 @@ impl HttpResponseParser {
         if let Some(decoder) = decoder {
             Ok(Async::Ready(
                 (ClientResponse::new(
-                    ClientMessage{status: status, version: version,
+                    ClientMessage{status, version,
                                   headers: hdrs, cookies: None}), Some(decoder))))
         } else {
             Ok(Async::Ready(
                 (ClientResponse::new(
-                    ClientMessage{status: status, version: version,
+                    ClientMessage{status, version,
                                   headers: hdrs, cookies: None}), None)))
         }
     }

src/client/pipeline.rs

@@ -63,16 +63,13 @@ impl SendRequest {
     pub(crate) fn with_connector(req: ClientRequest, conn: Addr<Unsync, ClientConnector>)
                                  -> SendRequest
     {
-        SendRequest{
-            req: req,
-            state: State::New,
-            conn: conn}
+        SendRequest{req, conn, state: State::New}
     }
 
     pub(crate) fn with_connection(req: ClientRequest, conn: Connection) -> SendRequest
     {
         SendRequest{
-            req: req,
+            req,
             state: State::Connection(conn),
             conn: ClientConnector::from_registry()}
     }
@@ -103,7 +100,7 @@ impl Future for SendRequest {
                     Err(_) => return Err(SendRequestError::Connector(
                         ClientConnectorError::Disconnected))
                 },
-                State::Connection(stream) => {
+                State::Connection(conn) => {
                     let mut writer = HttpClientWriter::new(SharedBytes::default());
                     writer.start(&mut self.req)?;
 
@@ -114,9 +111,7 @@ impl Future for SendRequest {
                     };
 
                     let mut pl = Box::new(Pipeline {
-                        body: body,
-                        conn: stream,
-                        writer: writer,
+                        body, conn, writer,
                         parser: Some(HttpResponseParser::default()),
                         parser_buf: BytesMut::new(),
                         disconnected: false,
@@ -221,11 +216,10 @@ impl Pipeline {
         let mut need_run = false;
 
         // need write?
-        match self.poll_write()
+        if let Async::NotReady = self.poll_write()
             .map_err(|e| io::Error::new(io::ErrorKind::Other, format!("{}", e)))?
         {
-            Async::NotReady => need_run = true,
-            _ => (),
+            need_run = true;
         }
 
         // need read?

src/client/writer.rs

@@ -1,4 +1,6 @@
+#![cfg_attr(feature = "cargo-clippy", allow(redundant_field_names))]
 #![allow(dead_code)]
+
 use std::io::{self, Write};
 use std::cell::RefCell;
 use std::fmt::Write as FmtWrite;
@@ -48,14 +50,14 @@ pub(crate) struct HttpClientWriter {
 
 impl HttpClientWriter {
 
-    pub fn new(buf: SharedBytes) -> HttpClientWriter {
-        let encoder = ContentEncoder::Identity(TransferEncoding::eof(buf.clone()));
+    pub fn new(buffer: SharedBytes) -> HttpClientWriter {
+        let encoder = ContentEncoder::Identity(TransferEncoding::eof(buffer.clone()));
         HttpClientWriter {
             flags: Flags::empty(),
             written: 0,
             headers_size: 0,
-            buffer: buf,
-            encoder: encoder,
+            buffer,
+            encoder,
             low: LOW_WATERMARK,
             high: HIGH_WATERMARK,
         }

src/context.rs

@@ -230,10 +230,7 @@ pub struct Drain<A> {
 
 impl<A> Drain<A> {
     pub fn new(fut: oneshot::Receiver<()>) -> Self {
-        Drain {
-            fut: fut,
-            _a: PhantomData
-        }
+        Drain { fut, _a: PhantomData }
     }
 }
 

src/error.rs

@@ -90,7 +90,7 @@ impl<T: ResponseError> From<T> for Error {
         } else {
             None
         };
-        Error { cause: Box::new(err), backtrace: backtrace }
+        Error { cause: Box::new(err), backtrace }
     }
 }
 
@@ -566,10 +566,10 @@ unsafe impl<T> Sync for InternalError<T> {}
 unsafe impl<T> Send for InternalError<T> {}
 
 impl<T> InternalError<T> {
-    pub fn new(err: T, status: StatusCode) -> Self {
+    pub fn new(cause: T, status: StatusCode) -> Self {
         InternalError {
-            cause: err,
-            status: status,
+            cause,
+            status,
             backtrace: Backtrace::new(),
         }
     }

src/fs.rs

@@ -105,10 +105,7 @@ pub struct Directory{
 
 impl Directory {
     pub fn new(base: PathBuf, path: PathBuf) -> Directory {
-        Directory {
-            base: base,
-            path: path
-        }
+        Directory { base, path }
     }
 
     fn can_list(&self, entry: &io::Result<DirEntry>) -> bool {

src/handler.rs

@@ -215,7 +215,7 @@ impl<S, H, R> WrapHandler<S, H, R>
           S: 'static,
 {
     pub fn new(h: H) -> Self {
-        WrapHandler{h: h, s: PhantomData}
+        WrapHandler{h, s: PhantomData}
     }
 }
 
@@ -225,7 +225,7 @@ impl<S, H, R> RouteHandler<S> for WrapHandler<S, H, R>
           S: 'static,
 {
     fn handle(&mut self, req: HttpRequest<S>) -> Reply {
-        let req2 = req.clone_without_state();
+        let req2 = req.without_state();
         match self.h.handle(req).respond_to(req2) {
             Ok(reply) => reply.into(),
             Err(err) => Reply::response(err.into()),
@@ -266,7 +266,7 @@ impl<S, H, F, R, E> RouteHandler<S> for AsyncHandler<S, H, F, R, E>
           S: 'static,
 {
     fn handle(&mut self, req: HttpRequest<S>) -> Reply {
-        let req2 = req.clone_without_state();
+        let req2 = req.without_state();
         let fut = (self.h)(req)
             .map_err(|e| e.into())
             .then(move |r| {
@@ -345,10 +345,10 @@ impl NormalizePath {
     /// Create new `NormalizePath` instance
     pub fn new(append: bool, merge: bool, redirect: StatusCode) -> NormalizePath {
         NormalizePath {
-            append: append,
-            merge: merge,
+            append,
+            merge,
+            redirect,
             re_merge: Regex::new("//+").unwrap(),
-            redirect: redirect,
             not_found: StatusCode::NOT_FOUND,
         }
     }

src/httprequest.rs

@@ -106,16 +106,16 @@ impl HttpRequest<()> {
     {
         HttpRequest(
             SharedHttpMessage::from_message(HttpMessage {
-                method: method,
-                uri: uri,
-                version: version,
-                headers: headers,
+                method,
+                uri,
+                version,
+                headers,
+                payload,
                 params: Params::new(),
                 query: Params::new(),
                 query_loaded: false,
                 cookies: None,
                 addr: None,
-                payload: payload,
                 extensions: Extensions::new(),
                 info: None,
             }),
@@ -153,7 +153,7 @@ impl<S> HttpRequest<S> {
 
     #[inline]
     /// Construct new http request without state.
-    pub(crate) fn clone_without_state(&self) -> HttpRequest {
+    pub(crate) fn without_state(&self) -> HttpRequest {
         HttpRequest(self.0.clone(), None, None)
     }
 
@@ -483,7 +483,7 @@ impl<S> HttpRequest<S> {
     /// # fn main() {}
     /// ```
     pub fn body(self) -> RequestBody {
-        RequestBody::from(self)
+        RequestBody::new(self.without_state())
     }
 
     /// Return stream to http payload processes as multipart.
@@ -553,7 +553,7 @@ impl<S> HttpRequest<S> {
     /// # fn main() {}
     /// ```
     pub fn urlencoded(self) -> UrlEncoded {
-        UrlEncoded::from(self)
+        UrlEncoded::new(self.without_state())
     }
 
     /// Parse `application/json` encoded body.
@@ -677,9 +677,9 @@ pub struct UrlEncoded {
 }
 
 impl UrlEncoded {
-    pub fn from<S>(req: HttpRequest<S>) -> UrlEncoded {
+    pub fn new(req: HttpRequest) -> UrlEncoded {
         UrlEncoded {
-            req: Some(req.clone_without_state()),
+            req: Some(req),
             limit: 262_144,
             fut: None,
         }
@@ -762,10 +762,10 @@ pub struct RequestBody {
 impl RequestBody {
 
     /// Create `RequestBody` for request.
-    pub fn from<S>(req: HttpRequest<S>) -> RequestBody {
+    pub fn new(req: HttpRequest) -> RequestBody {
         RequestBody {
             limit: 262_144,
-            req: Some(req.clone_without_state()),
+            req: Some(req),
             fut: None,
         }
  }

src/httpresponse.rs

@@ -659,11 +659,11 @@ impl InnerHttpResponse {
     #[inline]
     fn new(status: StatusCode, body: Body) -> InnerHttpResponse {
         InnerHttpResponse {
+            status,
+            body,
             version: None,
             headers: HeaderMap::with_capacity(16),
-            status: status,
             reason: None,
-            body: body,
             chunked: None,
             encoding: None,
             connection_type: None,

src/info.rs

@@ -110,8 +110,8 @@ impl<'a> ConnectionInfo<'a> {
         ConnectionInfo {
             scheme: scheme.unwrap_or("http"),
             host: host.unwrap_or("localhost"),
-            remote: remote,
-            peer: peer,
+            remote,
+            peer,
         }
     }
 

src/lib.rs

@@ -32,7 +32,7 @@
 //! * Supported *HTTP/1.x* and *HTTP/2.0* protocols
 //! * Streaming and pipelining
 //! * Keep-alive and slow requests handling
-//! * *WebSockets* server/client
+//! * `WebSockets` server/client
 //! * Transparent content compression/decompression (br, gzip, deflate)
 //! * Configurable request routing
 //! * Multipart streams

src/middleware/defaultheaders.rs

@@ -95,7 +95,7 @@ impl DefaultHeadersBuilder {
     /// Finishes building and returns the built `DefaultHeaders` middleware.
     pub fn finish(&mut self) -> DefaultHeaders {
         let headers = self.headers.take().expect("cannot reuse middleware builder");
-        DefaultHeaders{ ct: self.ct, headers: headers }
+        DefaultHeaders{ ct: self.ct, headers }
     }
 }
 

src/middleware/session.rs

@@ -377,8 +377,8 @@ impl<S> SessionBackend<S> for CookieSessionBackend {
         FutOk(
             CookieSession {
                 changed: false,
-                state: state,
                 inner: Rc::clone(&self.0),
+                state,
             })
     }
 }

src/multipart.rs

@@ -95,8 +95,8 @@ impl<S> Multipart<S> where S: Stream<Item=Bytes, Error=PayloadError> {
                 safety: Safety::new(),
                 inner: Some(Rc::new(RefCell::new(
                     InnerMultipart {
+                        boundary,
                         payload: PayloadRef::new(PayloadHelper::new(stream)),
-                        boundary: boundary,
                         state: InnerState::FirstBoundary,
                         item: InnerMultipartItem::None,
                     })))
@@ -369,12 +369,7 @@ impl<S> Field<S> where S: Stream<Item=Bytes, Error=PayloadError> {
 
     fn new(safety: Safety, headers: HeaderMap,
            ct: mime::Mime, inner: Rc<RefCell<InnerField<S>>>) -> Self {
-        Field {
-            ct: ct,
-            headers: headers,
-            inner: inner,
-            safety: safety,
-        }
+        Field {ct, headers, inner, safety}
     }
 
     pub fn headers(&self) -> &HeaderMap {
@@ -443,8 +438,8 @@ impl<S> InnerField<S> where S: Stream<Item=Bytes, Error=PayloadError> {
         };
 
         Ok(InnerField {
+            boundary,
             payload: Some(payload),
-            boundary: boundary,
             eof: false,
             length: len })
     }
@@ -596,7 +591,7 @@ impl Safety {
         Safety {
             task: None,
             level: Rc::strong_count(&payload),
-            payload: payload,
+            payload,
         }
     }
 
@@ -612,7 +607,7 @@ impl Clone for Safety {
         Safety {
             task: Some(current_task()),
             level: Rc::strong_count(&payload),
-            payload: payload,
+            payload,
         }
     }
 }

src/payload.rs

@@ -232,8 +232,8 @@ impl Inner {
 
     fn new(eof: bool) -> Self {
         Inner {
+            eof,
             len: 0,
-            eof: eof,
             err: None,
             task: None,
             items: VecDeque::new(),

src/pipeline.rs

@@ -72,7 +72,7 @@ struct PipelineInfo<S> {
 impl<S> PipelineInfo<S> {
     fn new(req: HttpRequest<S>) -> PipelineInfo<S> {
         PipelineInfo {
-            req: req,
+            req,
             count: 0,
             mws: Rc::new(Vec::new()),
             error: None,
@@ -108,9 +108,8 @@ impl<S: 'static, H: PipelineHandler<S>> Pipeline<S, H> {
                handler: Rc<RefCell<H>>) -> Pipeline<S, H>
     {
         let mut info = PipelineInfo {
-            req: req,
+            req, mws,
             count: 0,
-            mws: mws,
             error: None,
             context: None,
             disconnected: None,
@@ -307,7 +306,7 @@ impl<S: 'static, H> WaitingResponse<S, H> {
                 RunMiddlewares::init(info, resp),
             ReplyItem::Future(fut) =>
                 PipelineState::Handler(
-                    WaitingResponse { fut: fut, _s: PhantomData, _h: PhantomData }),
+                    WaitingResponse { fut, _s: PhantomData, _h: PhantomData }),
         }
     }
 
@@ -355,7 +354,7 @@ impl<S: 'static, H> RunMiddlewares<S, H> {
                 },
                 Ok(Response::Future(fut)) => {
                     return PipelineState::RunMiddlewares(
-                        RunMiddlewares { curr: curr, fut: Some(fut),
+                        RunMiddlewares { curr, fut: Some(fut),
                                          _s: PhantomData, _h: PhantomData })
                 },
             };
@@ -444,7 +443,7 @@ impl<S: 'static, H> ProcessResponse<S, H> {
     #[inline]
     fn init(resp: HttpResponse) -> PipelineState<S, H> {
         PipelineState::Response(
-            ProcessResponse{ resp: resp,
+            ProcessResponse{ resp,
                              iostate: IOState::Response,
                              running: RunningState::Running,
                              drain: None, _s: PhantomData, _h: PhantomData})
@@ -644,7 +643,7 @@ impl<S: 'static, H> FinishingMiddlewares<S, H> {
         if info.count == 0 {
             Completed::init(info)
         } else {
-            let mut state = FinishingMiddlewares{resp: resp, fut: None,
+            let mut state = FinishingMiddlewares{resp, fut: None,
                                                  _s: PhantomData, _h: PhantomData};
             if let Some(st) = state.poll(info) {
                 st

src/route.rs

@@ -179,14 +179,10 @@ impl<S: 'static> Compose<S> {
            mws: Rc<Vec<Box<Middleware<S>>>>,
            handler: InnerHandler<S>) -> Self
     {
-        let mut info = ComposeInfo {
-            count: 0,
-            req: req,
-            mws: mws,
-            handler: handler };
+        let mut info = ComposeInfo { count: 0, req, mws, handler };
         let state = StartMiddlewares::init(&mut info);
 
-        Compose {state: state, info: info}
+        Compose {state, info}
     }
 }
 
@@ -308,7 +304,7 @@ impl<S: 'static> WaitingResponse<S> {
                 RunMiddlewares::init(info, resp),
             ReplyItem::Future(fut) =>
                 ComposeState::Handler(
-                    WaitingResponse { fut: fut, _s: PhantomData }),
+                    WaitingResponse { fut, _s: PhantomData }),
         }
     }
 
@@ -353,7 +349,7 @@ impl<S: 'static> RunMiddlewares<S> {
                 },
                 Ok(MiddlewareResponse::Future(fut)) => {
                     return ComposeState::RunMiddlewares(
-                        RunMiddlewares { curr: curr, fut: Some(fut), _s: PhantomData })
+                        RunMiddlewares { curr, fut: Some(fut), _s: PhantomData })
                 },
             };
         }

src/router.rs

@@ -46,13 +46,9 @@ impl Router {
             }
         }
 
-        let len = prefix.len();
+        let prefix_len = prefix.len();
         (Router(Rc::new(
-            Inner{ prefix: prefix,
-                   prefix_len: len,
-                   named: named,
-                   patterns: patterns,
-                   srv: settings })), resources)
+            Inner{ prefix, prefix_len, named, patterns, srv: settings })), resources)
     }
 
     /// Router prefix
@@ -168,10 +164,10 @@ impl Pattern {
         };
 
         Pattern {
-            tp: tp,
+            tp,
+            pattern,
+            elements,
             name: name.into(),
-            pattern: pattern,
-            elements: elements,
         }
     }
 

src/server/channel.rs

@@ -237,7 +237,7 @@ pub(crate) struct WrapperStream<T> where T: AsyncRead + AsyncWrite + 'static {
 
 impl<T> WrapperStream<T> where T: AsyncRead + AsyncWrite + 'static {
     pub fn new(io: T) -> Self {
-        WrapperStream{io: io}
+        WrapperStream{ io }
     }
 }
 

src/server/encoding.rs

@@ -309,7 +309,7 @@ pub(crate) struct EncodedPayload {
 
 impl EncodedPayload {
     pub fn new(inner: PayloadSender, enc: ContentEncoding) -> EncodedPayload {
-        EncodedPayload{ inner: inner, error: false, payload: PayloadStream::new(enc) }
+        EncodedPayload{ inner, error: false, payload: PayloadStream::new(enc) }
     }
 }
 
@@ -821,10 +821,7 @@ impl AcceptEncoding {
                 Err(_) => 0.0,
             }
         };
-        Some(AcceptEncoding {
-            encoding: encoding,
-            quality: quality,
-        })
+        Some(AcceptEncoding{ encoding, quality })
     }
 
     /// Parse a raw Accept-Encoding header value into an ordered list.

src/server/h1.rs

@@ -1,3 +1,5 @@
+#![cfg_attr(feature = "cargo-clippy", allow(redundant_field_names))]
+
 use std::{self, io};
 use std::rc::Rc;
 use std::net::SocketAddr;
@@ -62,18 +64,20 @@ struct Entry {
 impl<T, H> Http1<T, H>
     where T: IoStream, H: HttpHandler + 'static
 {
-    pub fn new(h: Rc<WorkerSettings<H>>, stream: T, addr: Option<SocketAddr>, buf: BytesMut)
-               -> Self
+    pub fn new(settings: Rc<WorkerSettings<H>>,
+               stream: T,
+               addr: Option<SocketAddr>, read_buf: BytesMut) -> Self
     {
-        let bytes = h.get_shared_bytes();
+        let bytes = settings.get_shared_bytes();
         Http1{ flags: Flags::KEEPALIVE,
-               settings: h,
-               addr: addr,
                stream: H1Writer::new(stream, bytes),
                reader: Reader::new(),
-               read_buf: buf,
                tasks: VecDeque::new(),
-               keepalive_timer: None }
+               keepalive_timer: None,
+               addr,
+               read_buf,
+               settings,
+        }
     }
 
     pub fn settings(&self) -> &WorkerSettings<H> {
@@ -540,7 +544,7 @@ impl Reader {
             let (psender, payload) = Payload::new(false);
             let info = PayloadInfo {
                 tx: PayloadType::new(&msg.get_mut().headers, psender),
-                decoder: decoder,
+                decoder,
             };
             msg.get_mut().payload = Some(payload);
             Ok(Async::Ready((HttpRequest::from_message(msg), Some(info))))

src/server/h1writer.rs

@@ -1,3 +1,5 @@
+#![cfg_attr(feature = "cargo-clippy", allow(redundant_field_names))]
+
 use std::{io, mem};
 use bytes::BufMut;
 use futures::{Async, Poll};
@@ -39,11 +41,11 @@ impl<T: AsyncWrite> H1Writer<T> {
     pub fn new(stream: T, buf: SharedBytes) -> H1Writer<T> {
         H1Writer {
             flags: Flags::empty(),
-            stream: stream,
             encoder: ContentEncoder::empty(buf.clone()),
             written: 0,
             headers_size: 0,
             buffer: buf,
+            stream,
         }
     }
 

src/server/h2.rs

@@ -1,3 +1,5 @@
+#![cfg_attr(feature = "cargo-clippy", allow(redundant_field_names))]
+
 use std::{io, cmp, mem};
 use std::rc::Rc;
 use std::io::{Read, Write};
@@ -53,15 +55,17 @@ impl<T, H> Http2<T, H>
     where T: AsyncRead + AsyncWrite + 'static,
           H: HttpHandler + 'static
 {
-    pub fn new(h: Rc<WorkerSettings<H>>, io: T, addr: Option<SocketAddr>, buf: Bytes) -> Self
+    pub fn new(settings: Rc<WorkerSettings<H>>,
+               io: T,
+               addr: Option<SocketAddr>, buf: Bytes) -> Self
     {
         Http2{ flags: Flags::empty(),
-               settings: h,
-               addr: addr,
                tasks: VecDeque::new(),
                state: State::Handshake(
                    server::handshake(IoWrapper{unread: Some(buf), inner: io})),
                keepalive_timer: None,
+               addr,
+               settings,
         }
     }
 
@@ -286,10 +290,10 @@ impl Entry {
 
         Entry {task: task.unwrap_or_else(|| Pipeline::error(HTTPNotFound)),
                payload: psender,
-               recv: recv,
                stream: H2Writer::new(resp, settings.get_shared_bytes()),
                flags: EntryFlags::empty(),
                capacity: 0,
+               recv,
         }
     }
 

src/server/h2writer.rs

@@ -1,3 +1,5 @@
+#![cfg_attr(feature = "cargo-clippy", allow(redundant_field_names))]
+
 use std::{io, cmp};
 use bytes::{Bytes, BytesMut};
 use futures::{Async, Poll};
@@ -38,7 +40,7 @@ impl H2Writer {
 
     pub fn new(respond: SendResponse<Bytes>, buf: SharedBytes) -> H2Writer {
         H2Writer {
-            respond: respond,
+            respond,
             stream: None,
             encoder: ContentEncoder::empty(buf.clone()),
             flags: Flags::empty(),

src/server/settings.rs

@@ -36,11 +36,7 @@ impl ServerSettings {
         } else {
             "localhost".to_owned()
         };
-        ServerSettings {
-            addr: addr,
-            secure: secure,
-            host: host,
-        }
+        ServerSettings { addr, secure, host }
     }
 
     /// Returns the socket address of the local half of this TCP connection

src/server/worker.rs

@@ -62,7 +62,7 @@ impl<H: HttpHandler + 'static> Worker<H> {
         Worker {
             settings: Rc::new(WorkerSettings::new(h, keep_alive)),
             hnd: Arbiter::handle().clone(),
-            handler: handler,
+            handler,
         }
     }
 

src/test.rs

@@ -94,12 +94,12 @@ impl TestServer {
             let _ = sys.run();
         });
 
-        let (sys, addr) = rx.recv().unwrap();
+        let (server_sys, addr) = rx.recv().unwrap();
         TestServer {
-            addr: addr,
+            addr,
             thread: Some(join),
             system: System::new("actix-test"),
-            server_sys: sys,
+            server_sys,
         }
     }
 
@@ -131,12 +131,12 @@ impl TestServer {
             let _ = sys.run();
         });
 
-        let (sys, addr) = rx.recv().unwrap();
+        let (server_sys, addr) = rx.recv().unwrap();
         TestServer {
-            addr: addr,
+            addr,
+            server_sys,
             thread: Some(join),
             system: System::new("actix-test"),
-            server_sys: sys,
         }
     }
 
@@ -346,7 +346,7 @@ impl<S> TestRequest<S> {
     /// Start HttpRequest build process with application state
     pub fn with_state(state: S) -> TestRequest<S> {
         TestRequest {
-            state: state,
+            state,
             method: Method::GET,
             uri: Uri::from_str("/").unwrap(),
             version: Version::HTTP_11,
@@ -434,7 +434,7 @@ impl<S> TestRequest<S> {
         let req = self.finish();
         let resp = h.handle(req.clone());
 
-        match resp.respond_to(req.clone_without_state()) {
+        match resp.respond_to(req.without_state()) {
             Ok(resp) => {
                 match resp.into().into() {
                     ReplyItem::Message(resp) => Ok(resp),
@@ -461,7 +461,7 @@ impl<S> TestRequest<S> {
         let mut core = Core::new().unwrap();
         match core.run(fut) {
             Ok(r) => {
-                match r.respond_to(req.clone_without_state()) {
+                match r.respond_to(req.without_state()) {
                     Ok(reply) => match reply.into().into() {
                         ReplyItem::Message(resp) => Ok(resp),
                         _ => panic!("Nested async replies are not supported"),

src/ws/client.rs

@@ -130,7 +130,7 @@ impl WsClient {
             http_err: None,
             origin: None,
             protocols: None,
-            conn: conn,
+            conn,
         };
         cl.request.uri(uri.as_ref());
         cl
@@ -253,7 +253,7 @@ impl WsHandshake {
                     io::ErrorKind::Other, "disconnected").into()))));
 
             WsHandshake {
-                key: key,
+                key,
                 inner: None,
                 request: Some(request.with_connector(conn.clone())),
                 tx: Some(tx),
@@ -261,7 +261,7 @@ impl WsHandshake {
             }
         } else {
             WsHandshake {
-                key: key,
+                key,
                 inner: None,
                 request: None,
                 tx: None,
@@ -340,7 +340,7 @@ impl Future for WsHandshake {
 
         let inner = Rc::new(UnsafeCell::new(inner));
         Ok(Async::Ready(
-            (WsClientReader{inner: Rc::clone(&inner)}, WsClientWriter{inner: inner})))
+            (WsClientReader{inner: Rc::clone(&inner)}, WsClientWriter{inner})))
     }
 }
 

src/ws/frame.rs

@@ -146,13 +146,7 @@ impl Frame {
         }
 
         Ok(Async::Ready(Some(Frame {
-            finished: finished,
-            rsv1: rsv1,
-            rsv2: rsv2,
-            rsv3: rsv3,
-            opcode: opcode,
-            payload: data.into(),
-        })))
+            finished, rsv1, rsv2, rsv3, opcode, payload: data.into() })))
     }
 
     /// Generate binary representation