chore: disallow e bindings

robjtede · robjtede · commit 538c1bea3491 · 2024-08-10T05:15:49.000+01:00
diff --git a/.clippy.toml b/.clippy.toml
@@ -0,0 +1,7 @@
+disallowed-names = [
+    "e", # no single letter error bindings
+]
+disallowed-methods = [
+    "std::cell::RefCell::default()",
+    "std::rc::Rc::default()",
+]
diff --git a/actix-files/src/service.rs b/actix-files/src/service.rs
@@ -79,7 +79,7 @@ impl FilesService {
 
         let (req, _) = req.into_parts();
 
-        (self.renderer)(&dir, &req).unwrap_or_else(|e| ServiceResponse::from_err(e, req))
+        (self.renderer)(&dir, &req).unwrap_or_else(|err| ServiceResponse::from_err(err, req))
     }
 }
 
diff --git a/actix-http-test/src/lib.rs b/actix-http-test/src/lib.rs
@@ -106,7 +106,7 @@ pub async fn test_server_with_addr<F: ServerServiceFactory<TcpStream>>(
             builder.set_verify(SslVerifyMode::NONE);
             let _ = builder
                 .set_alpn_protos(b"\x02h2\x08http/1.1")
-                .map_err(|e| log::error!("Can not set alpn protocol: {:?}", e));
+                .map_err(|err| log::error!("Can not set ALPN protocol: {err}"));
 
             Connector::new()
                 .conn_lifetime(Duration::from_secs(0))
diff --git a/actix-http/src/h1/encoder.rs b/actix-http/src/h1/encoder.rs
@@ -313,7 +313,7 @@ impl MessageType for RequestHeadType {
                 _ => return Err(io::Error::new(io::ErrorKind::Other, "unsupported version")),
             }
         )
-        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+        .map_err(|err| io::Error::new(io::ErrorKind::Other, err))
     }
 }
 
@@ -433,7 +433,7 @@ impl TransferEncoding {
                     buf.extend_from_slice(b"0\r\n\r\n");
                 } else {
                     writeln!(helpers::MutWriter(buf), "{:X}\r", msg.len())
-                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+                        .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
 
                     buf.reserve(msg.len() + 2);
                     buf.extend_from_slice(msg);
diff --git a/actix-http/src/h1/service.rs b/actix-http/src/h1/service.rs
@@ -480,23 +480,23 @@ where
         let cfg = self.cfg.clone();
 
         Box::pin(async move {
-            let expect = expect
-                .await
-                .map_err(|e| error!("Init http expect service error: {:?}", e))?;
+            let expect = expect.await.map_err(|err| {
+                tracing::error!("Initialization of HTTP expect service error: {err:?}");
+            })?;
 
             let upgrade = match upgrade {
                 Some(upgrade) => {
-                    let upgrade = upgrade
-                        .await
-                        .map_err(|e| error!("Init http upgrade service error: {:?}", e))?;
+                    let upgrade = upgrade.await.map_err(|err| {
+                        tracing::error!("Initialization of HTTP upgrade service error: {err:?}");
+                    })?;
                     Some(upgrade)
                 }
                 None => None,
             };
 
             let service = service
                 .await
-                .map_err(|e| error!("Init http service error: {:?}", e))?;
+                .map_err(|err| error!("Initialization of HTTP service error: {err:?}"))?;
 
             Ok(H1ServiceHandler::new(
                 cfg,
diff --git a/actix-http/src/service.rs b/actix-http/src/service.rs
@@ -775,23 +775,23 @@ where
         let cfg = self.cfg.clone();
 
         Box::pin(async move {
-            let expect = expect
-                .await
-                .map_err(|e| error!("Init http expect service error: {:?}", e))?;
+            let expect = expect.await.map_err(|err| {
+                tracing::error!("Initialization of HTTP expect service error: {err:?}");
+            })?;
 
             let upgrade = match upgrade {
                 Some(upgrade) => {
-                    let upgrade = upgrade
-                        .await
-                        .map_err(|e| error!("Init http upgrade service error: {:?}", e))?;
+                    let upgrade = upgrade.await.map_err(|err| {
+                        tracing::error!("Initialization of HTTP upgrade service error: {err:?}");
+                    })?;
                     Some(upgrade)
                 }
                 None => None,
             };
 
-            let service = service
-                .await
-                .map_err(|e| error!("Init http service error: {:?}", e))?;
+            let service = service.await.map_err(|err| {
+                tracing::error!("Initialization of HTTP service error: {err:?}");
+            })?;
 
             Ok(HttpServiceHandler::new(
                 cfg,
diff --git a/actix-http/src/ws/dispatcher.rs b/actix-http/src/ws/dispatcher.rs
@@ -114,14 +114,14 @@ mod inner {
     {
         fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
             match *self {
-                DispatcherError::Service(ref e) => {
-                    write!(fmt, "DispatcherError::Service({:?})", e)
+                DispatcherError::Service(ref err) => {
+                    write!(fmt, "DispatcherError::Service({err:?})")
                 }
-                DispatcherError::Encoder(ref e) => {
-                    write!(fmt, "DispatcherError::Encoder({:?})", e)
+                DispatcherError::Encoder(ref err) => {
+                    write!(fmt, "DispatcherError::Encoder({err:?})")
                 }
-                DispatcherError::Decoder(ref e) => {
-                    write!(fmt, "DispatcherError::Decoder({:?})", e)
+                DispatcherError::Decoder(ref err) => {
+                    write!(fmt, "DispatcherError::Decoder({err:?})")
                 }
             }
         }
@@ -136,9 +136,9 @@ mod inner {
     {
         fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
             match *self {
-                DispatcherError::Service(ref e) => write!(fmt, "{}", e),
-                DispatcherError::Encoder(ref e) => write!(fmt, "{:?}", e),
-                DispatcherError::Decoder(ref e) => write!(fmt, "{:?}", e),
+                DispatcherError::Service(ref err) => write!(fmt, "{err}"),
+                DispatcherError::Encoder(ref err) => write!(fmt, "{err:?}"),
+                DispatcherError::Decoder(ref err) => write!(fmt, "{err:?}"),
             }
         }
     }
diff --git a/actix-multipart-derive/src/lib.rs b/actix-multipart-derive/src/lib.rs
@@ -5,6 +5,7 @@
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
 #![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![allow(clippy::disallowed_names)] // false positives in some macro expansions
 
 use std::collections::HashSet;
 
@@ -35,6 +36,7 @@ struct MultipartFormAttrs {
     duplicate_field: DuplicateField,
 }
 
+#[allow(clippy::disallowed_names)] // false positive in macro expansion
 #[derive(FromField, Default)]
 #[darling(attributes(multipart), default)]
 struct FieldAttrs {
diff --git a/actix-router/src/path.rs b/actix-router/src/path.rs
@@ -143,9 +143,9 @@ impl<T: ResourcePath> Path<T> {
         for (seg_name, val) in self.segments.iter() {
             if name == seg_name {
                 return match val {
-                    PathItem::Static(ref s) => Some(s),
-                    PathItem::Segment(s, e) => {
-                        Some(&self.path.path()[(*s as usize)..(*e as usize)])
+                    PathItem::Static(ref seg) => Some(seg),
+                    PathItem::Segment(start, end) => {
+                        Some(&self.path.path()[(*start as usize)..(*end as usize)])
                     }
                 };
             }
@@ -193,8 +193,10 @@ impl<'a, T: ResourcePath> Iterator for PathIter<'a, T> {
         if self.idx < self.params.segment_count() {
             let idx = self.idx;
             let res = match self.params.segments[idx].1 {
-                PathItem::Static(ref s) => s,
-                PathItem::Segment(s, e) => &self.params.path.path()[(s as usize)..(e as usize)],
+                PathItem::Static(ref seg) => seg,
+                PathItem::Segment(start, end) => {
+                    &self.params.path.path()[(start as usize)..(end as usize)]
+                }
             };
             self.idx += 1;
             return Some((&self.params.segments[idx].0, res));
@@ -217,8 +219,8 @@ impl<T: ResourcePath> Index<usize> for Path<T> {
 
     fn index(&self, idx: usize) -> &str {
         match self.segments[idx].1 {
-            PathItem::Static(ref s) => s,
-            PathItem::Segment(s, e) => &self.path.path()[(s as usize)..(e as usize)],
+            PathItem::Static(ref seg) => seg,
+            PathItem::Segment(start, end) => &self.path.path()[(start as usize)..(end as usize)],
         }
     }
 }
diff --git a/actix-web-actors/src/ws.rs b/actix-web-actors/src/ws.rs
@@ -796,11 +796,8 @@ where
             Some(frm) => {
                 let msg = match frm {
                     Frame::Text(data) => {
-                        Message::Text(ByteString::try_from(data).map_err(|e| {
-                            ProtocolError::Io(io::Error::new(
-                                io::ErrorKind::Other,
-                                format!("{}", e),
-                            ))
+                        Message::Text(ByteString::try_from(data).map_err(|err| {
+                            ProtocolError::Io(io::Error::new(io::ErrorKind::Other, err))
                         })?)
                     }
                     Frame::Binary(data) => Message::Binary(data),
diff --git a/actix-web/src/app.rs b/actix-web/src/app.rs
@@ -269,9 +269,9 @@ where
             + 'static,
         U::InitError: fmt::Debug,
     {
-        let svc = svc
-            .into_factory()
-            .map_init_err(|e| log::error!("Can not construct default service: {:?}", e));
+        let svc = svc.into_factory().map_init_err(|err| {
+            log::error!("Can not construct default service: {err:?}");
+        });
 
         self.default = Some(Rc::new(boxed::factory(svc)));
 
diff --git a/actix-web/src/resource.rs b/actix-web/src/resource.rs
@@ -358,10 +358,9 @@ where
         U::InitError: fmt::Debug,
     {
         // create and configure default resource
-        self.default = boxed::factory(
-            f.into_factory()
-                .map_init_err(|e| log::error!("Can not construct default service: {:?}", e)),
-        );
+        self.default = boxed::factory(f.into_factory().map_init_err(|err| {
+            log::error!("Can not construct default service: {err:?}");
+        }));
 
         self
     }
diff --git a/actix-web/src/scope.rs b/actix-web/src/scope.rs
@@ -278,7 +278,9 @@ where
     {
         // create and configure default resource
         self.default = Some(Rc::new(boxed::factory(f.into_factory().map_init_err(
-            |e| log::error!("Can not construct default service: {:?}", e),
+            |err| {
+                log::error!("Can not construct default service: {err:?}");
+            },
         ))));
 
         self
diff --git a/actix-web/src/types/json.rs b/actix-web/src/types/json.rs
@@ -398,7 +398,7 @@ impl<T: DeserializeOwned> JsonBody<T> {
                     _res: PhantomData,
                 }
             }
-            JsonBody::Error(e) => JsonBody::Error(e),
+            JsonBody::Error(err) => JsonBody::Error(err),
         }
     }
 }
@@ -434,7 +434,7 @@ impl<T: DeserializeOwned> Future for JsonBody<T> {
                     }
                 }
             },
-            JsonBody::Error(e) => Poll::Ready(Err(e.take().unwrap())),
+            JsonBody::Error(err) => Poll::Ready(Err(err.take().unwrap())),
         }
     }
 }
diff --git a/actix-web/src/types/path.rs b/actix-web/src/types/path.rs
@@ -89,8 +89,8 @@ where
                     );
 
                     if let Some(error_handler) = error_handler {
-                        let e = PathError::Deserialize(err);
-                        (error_handler)(e, req)
+                        let err = PathError::Deserialize(err);
+                        (error_handler)(err, req)
                     } else {
                         ErrorNotFound(err)
                     }
diff --git a/actix-web/src/types/query.rs b/actix-web/src/types/query.rs
@@ -2,7 +2,7 @@
 
 use std::{fmt, ops, sync::Arc};
 
-use actix_utils::future::{err, ok, Ready};
+use actix_utils::future::{ok, ready, Ready};
 use serde::de::DeserializeOwned;
 
 use crate::{dev::Payload, error::QueryPayloadError, Error, FromRequest, HttpRequest};
@@ -118,22 +118,22 @@ impl<T: DeserializeOwned> FromRequest for Query<T> {
 
         serde_urlencoded::from_str::<T>(req.query_string())
             .map(|val| ok(Query(val)))
-            .unwrap_or_else(move |e| {
-                let e = QueryPayloadError::Deserialize(e);
+            .unwrap_or_else(move |err| {
+                let err = QueryPayloadError::Deserialize(err);
 
                 log::debug!(
                     "Failed during Query extractor deserialization. \
                      Request path: {:?}",
                     req.path()
                 );
 
-                let e = if let Some(error_handler) = error_handler {
-                    (error_handler)(e, req)
+                let err = if let Some(error_handler) = error_handler {
+                    (error_handler)(err, req)
                 } else {
-                    e.into()
+                    err.into()
                 };
 
-                err(e)
+                ready(Err(err))
             })
     }
 }
diff --git a/awc/src/client/error.rs b/awc/src/client/error.rs
@@ -54,11 +54,11 @@ impl std::error::Error for ConnectError {}
 impl From<actix_tls::connect::ConnectError> for ConnectError {
     fn from(err: actix_tls::connect::ConnectError) -> ConnectError {
         match err {
-            actix_tls::connect::ConnectError::Resolver(e) => ConnectError::Resolver(e),
+            actix_tls::connect::ConnectError::Resolver(err) => ConnectError::Resolver(err),
             actix_tls::connect::ConnectError::NoRecords => ConnectError::NoRecords,
             actix_tls::connect::ConnectError::InvalidInput => panic!(),
             actix_tls::connect::ConnectError::Unresolved => ConnectError::Unresolved,
-            actix_tls::connect::ConnectError::Io(e) => ConnectError::Io(e),
+            actix_tls::connect::ConnectError::Io(err) => ConnectError::Io(err),
         }
     }
 }
diff --git a/awc/src/client/pool.rs b/awc/src/client/pool.rs
@@ -31,7 +31,7 @@ use super::{
     Connect,
 };
 
-#[derive(Hash, Eq, PartialEq, Clone, Debug)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Key {
     authority: Authority,
 }
@@ -42,8 +42,8 @@ impl From<Authority> for Key {
     }
 }
 
+/// Connections pool to reuse I/O per [`Authority`].
 #[doc(hidden)]
-/// Connections pool for reuse Io type for certain [`http::uri::Authority`] as key.
 pub struct ConnectionPool<S, Io>
 where
     Io: AsyncWrite + Unpin + 'static,
@@ -52,7 +52,7 @@ where
     inner: ConnectionPoolInner<Io>,
 }
 
-/// wrapper type for check the ref count of Rc.
+/// Wrapper type for check the ref count of Rc.
 pub struct ConnectionPoolInner<Io>(Rc<ConnectionPoolInnerPriv<Io>>)
 where
     Io: AsyncWrite + Unpin + 'static;
@@ -63,7 +63,7 @@ where
 {
     fn new(config: ConnectorConfig) -> Self {
         let permits = Arc::new(Semaphore::new(config.limit));
-        let available = RefCell::new(HashMap::default());
+        let available = RefCell::new(HashMap::new());
 
         Self(Rc::new(ConnectionPoolInnerPriv {
             config,
@@ -72,7 +72,7 @@ where
         }))
     }
 
-    /// spawn a async for graceful shutdown h1 Io type with a timeout.
+    /// Spawns a graceful shutdown task for the underlying I/O with a timeout.
     fn close(&self, conn: ConnectionInnerType<Io>) {
         if let Some(timeout) = self.config.disconnect_timeout {
             if let ConnectionInnerType::H1(io) = conn {
diff --git a/awc/src/frozen.rs b/awc/src/frozen.rs
diff --git a/awc/src/request.rs b/awc/src/request.rs
diff --git a/awc/src/sender.rs b/awc/src/sender.rs
diff --git a/awc/src/ws.rs b/awc/src/ws.rs

Original file line number	Diff line number	Diff line change
`@@ -79,7 +79,7 @@ impl FilesService {`
`79`	`79`
`80`	`80`	`let (req, _) = req.into_parts();`
`81`	`81`
`82`		`- (self.renderer)(&dir, &req).unwrap_or_else(\|e\| ServiceResponse::from_err(e, req))`
	`82`	`+ (self.renderer)(&dir, &req).unwrap_or_else(\|err\| ServiceResponse::from_err(err, req))`
`83`	`83`	`}`
`84`	`84`	`}`
`85`	`85`
Original file line number	Diff line number	Diff line change
`@@ -313,7 +313,7 @@ impl MessageType for RequestHeadType {`
`313`	`313`	`_ => return Err(io::Error::new(io::ErrorKind::Other, "unsupported version")),`
`314`	`314`	`}`
`315`	`315`	`)`
`316`		`- .map_err(\|e\| io::Error::new(io::ErrorKind::Other, e))`
	`316`	`+ .map_err(\|err\| io::Error::new(io::ErrorKind::Other, err))`
`317`	`317`	`}`
`318`	`318`	`}`
`319`	`319`
`@@ -433,7 +433,7 @@ impl TransferEncoding {`
`433`	`433`	`buf.extend_from_slice(b"0\r\n\r\n");`
`434`	`434`	`} else {`
`435`	`435`	`writeln!(helpers::MutWriter(buf), "{:X}\r", msg.len())`
`436`		`- .map_err(\|e\| io::Error::new(io::ErrorKind::Other, e))?;`
	`436`	`+ .map_err(\|err\| io::Error::new(io::ErrorKind::Other, err))?;`
`437`	`437`
`438`	`438`	`buf.reserve(msg.len() + 2);`
`439`	`439`	`buf.extend_from_slice(msg);`
Original file line number	Diff line number	Diff line change
`@@ -114,14 +114,14 @@ mod inner {`
`114`	`114`	`{`
`115`	`115`	`fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {`
`116`	`116`	`match *self {`
`117`		`- DispatcherError::Service(ref e) => {`
`118`		`- write!(fmt, "DispatcherError::Service({:?})", e)`
	`117`	`+ DispatcherError::Service(ref err) => {`
	`118`	`+ write!(fmt, "DispatcherError::Service({err:?})")`
`119`	`119`	`}`
`120`		`- DispatcherError::Encoder(ref e) => {`
`121`		`- write!(fmt, "DispatcherError::Encoder({:?})", e)`
	`120`	`+ DispatcherError::Encoder(ref err) => {`
	`121`	`+ write!(fmt, "DispatcherError::Encoder({err:?})")`
`122`	`122`	`}`
`123`		`- DispatcherError::Decoder(ref e) => {`
`124`		`- write!(fmt, "DispatcherError::Decoder({:?})", e)`
	`123`	`+ DispatcherError::Decoder(ref err) => {`
	`124`	`+ write!(fmt, "DispatcherError::Decoder({err:?})")`
`125`	`125`	`}`
`126`	`126`	`}`
`127`	`127`	`}`
`@@ -136,9 +136,9 @@ mod inner {`
`136`	`136`	`{`
`137`	`137`	`fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {`
`138`	`138`	`match *self {`
`139`		`- DispatcherError::Service(ref e) => write!(fmt, "{}", e),`
`140`		`- DispatcherError::Encoder(ref e) => write!(fmt, "{:?}", e),`
`141`		`- DispatcherError::Decoder(ref e) => write!(fmt, "{:?}", e),`
	`139`	`+ DispatcherError::Service(ref err) => write!(fmt, "{err}"),`
	`140`	`+ DispatcherError::Encoder(ref err) => write!(fmt, "{err:?}"),`
	`141`	`+ DispatcherError::Decoder(ref err) => write!(fmt, "{err:?}"),`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`	`}`