Merge #353: Tighten Linter (Check and Clippy)

josecelano · josecelano · commit 8c7dc5efbfcf · 2023-08-03T12:02:44.000+01:00
eb838dd dev: tighten lint for build and clippy (Cameron Garnham) Pull request description: ACKs for top commit: josecelano: ACK eb838dd Tree-SHA512: c2872448c2cfa392e7fc60e429fe500d73f3b0546e913ced576a584ba8f3b9832714c4de0c469bc41b3212a4f735f180a0afdf234fde913c9bfb9dd7cc67434c
diff --git a/.cargo/config.toml b/.cargo/config.toml
@@ -3,3 +3,23 @@ cov = "llvm-cov"
 cov-lcov = "llvm-cov --lcov --output-path=./.coverage/lcov.info"
 cov-html = "llvm-cov --html"
 time = "build --timings --all-targets"
+
+[build]
+rustflags = [
+    "-D",
+    "warnings",
+    "-D",
+    "future-incompatible",
+    "-D",
+    "let-underscore",
+    "-D",
+    "nonstandard-style",
+    "-D",
+    "rust-2018-compatibility",
+    "-D",
+    "rust-2018-idioms",
+    "-D",
+    "rust-2021-compatibility",
+    "-D",
+    "unused",
+]
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -2,7 +2,22 @@
     "[rust]": {
         "editor.formatOnSave": true
     },
-    "rust-analyzer.checkOnSave.command": "clippy",
-    "rust-analyzer.checkOnSave.allTargets": true,
-    "rust-analyzer.checkOnSave.extraArgs": ["--","-W","clippy::pedantic"],
+    "rust-analyzer.checkOnSave": true,
+    "rust-analyzer.check.command": "clippy",
+    "rust-analyzer.check.allTargets": true,
+    "rust-analyzer.check.extraArgs": [
+      "--",
+      "-D",
+      "clippy::correctness",
+      "-D",
+      "clippy::suspicious",
+      "-W",
+      "clippy::complexity",
+      "-W",
+      "clippy::perf",
+      "-W",
+      "clippy::style",
+      "-W",
+      "clippy::pedantic",
+    ],
 }
diff --git a/packages/located-error/src/lib.rs b/packages/located-error/src/lib.rs
@@ -128,7 +128,7 @@ mod tests {
     fn error_should_include_location() {
         let e = TestError::Test;
 
-        let b: LocatedError<TestError> = Located(e).into();
+        let b: LocatedError<'_, TestError> = Located(e).into();
         let l = get_caller_location();
 
         assert_eq!(b.location.file(), l.file());
diff --git a/src/servers/apis/server.rs b/src/servers/apis/server.rs
@@ -128,7 +128,7 @@ impl ApiServer<Running> {
             .send(0)
             .map_err(|_| Error::Error("Task killer channel was closed.".to_string()))?;
 
-        let _: Result<(), tokio::task::JoinError> = self.state.task.await;
+        drop(self.state.task.await);
 
         Ok(ApiServer {
             cfg: self.cfg,
diff --git a/src/servers/apis/v1/context/auth_key/resources.rs b/src/servers/apis/v1/context/auth_key/resources.rs
@@ -27,6 +27,7 @@ impl From<AuthKey> for auth::ExpiringKey {
     }
 }
 
+#[allow(deprecated)]
 impl From<auth::ExpiringKey> for AuthKey {
     fn from(auth_key: auth::ExpiringKey) -> Self {
         AuthKey {
@@ -63,6 +64,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn it_should_be_convertible_into_an_auth_key() {
         let auth_key_resource = AuthKey {
             key: "IaWDneuFNZi8IB4MPA3qW1CD0M30EZSM".to_string(), // cspell:disable-line
@@ -80,6 +82,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn it_should_be_convertible_from_an_auth_key() {
         let auth_key = auth::ExpiringKey {
             key: "IaWDneuFNZi8IB4MPA3qW1CD0M30EZSM".parse::<Key>().unwrap(), // cspell:disable-line
@@ -97,6 +100,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn it_should_be_convertible_into_json() {
         assert_eq!(
             serde_json::to_string(&AuthKey {
diff --git a/src/servers/http/v1/query.rs b/src/servers/http/v1/query.rs
@@ -137,7 +137,7 @@ impl From<Vec<(&str, &str)>> for Query {
 }
 
 impl std::fmt::Display for Query {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let query = self
             .params
             .iter_all()
@@ -185,7 +185,7 @@ impl FromStr for NameValuePair {
 }
 
 impl std::fmt::Display for NameValuePair {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}={}", self.name, self.value)
     }
 }
@@ -208,7 +208,7 @@ impl FieldValuePairSet {
 }
 
 impl std::fmt::Display for FieldValuePairSet {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let query = self
             .pairs
             .iter()
diff --git a/src/servers/http/v1/requests/announce.rs b/src/servers/http/v1/requests/announce.rs
@@ -166,7 +166,7 @@ impl FromStr for Event {
 }
 
 impl fmt::Display for Event {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Event::Started => write!(f, "started"),
             Event::Stopped => write!(f, "stopped"),
@@ -194,7 +194,7 @@ pub enum Compact {
 }
 
 impl fmt::Display for Compact {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Compact::Accepted => write!(f, "1"),
             Compact::NotAccepted => write!(f, "0"),
@@ -264,12 +264,10 @@ fn extract_info_hash(query: &Query) -> Result<InfoHash, ParseAnnounceQueryError>
                 })?,
             )
         }
-        None => {
-            return Err(ParseAnnounceQueryError::MissingParam {
-                location: Location::caller(),
-                param_name: INFO_HASH.to_owned(),
-            })
-        }
+        None => Err(ParseAnnounceQueryError::MissingParam {
+            location: Location::caller(),
+            param_name: INFO_HASH.to_owned(),
+        }),
     }
 }
 
@@ -282,12 +280,10 @@ fn extract_peer_id(query: &Query) -> Result<peer::Id, ParseAnnounceQueryError> {
                 source: Located(err).into(),
             })?,
         ),
-        None => {
-            return Err(ParseAnnounceQueryError::MissingParam {
-                location: Location::caller(),
-                param_name: PEER_ID.to_owned(),
-            })
-        }
+        None => Err(ParseAnnounceQueryError::MissingParam {
+            location: Location::caller(),
+            param_name: PEER_ID.to_owned(),
+        }),
     }
 }
 
@@ -298,12 +294,10 @@ fn extract_port(query: &Query) -> Result<u16, ParseAnnounceQueryError> {
             param_value: raw_param.clone(),
             location: Location::caller(),
         })?),
-        None => {
-            return Err(ParseAnnounceQueryError::MissingParam {
-                location: Location::caller(),
-                param_name: PORT.to_owned(),
-            })
-        }
+        None => Err(ParseAnnounceQueryError::MissingParam {
+            location: Location::caller(),
+            param_name: PORT.to_owned(),
+        }),
     }
 }
 
diff --git a/src/servers/http/v1/requests/scrape.rs b/src/servers/http/v1/requests/scrape.rs
@@ -74,12 +74,10 @@ fn extract_info_hashes(query: &Query) -> Result<Vec<InfoHash>, ParseScrapeQueryE
 
             Ok(info_hashes)
         }
-        None => {
-            return Err(ParseScrapeQueryError::MissingParam {
-                location: Location::caller(),
-                param_name: INFO_HASH.to_owned(),
-            })
-        }
+        None => Err(ParseScrapeQueryError::MissingParam {
+            location: Location::caller(),
+            param_name: INFO_HASH.to_owned(),
+        }),
     }
 }
 
diff --git a/src/servers/http/v1/responses/announce.rs b/src/servers/http/v1/responses/announce.rs
@@ -116,7 +116,7 @@ pub struct Peer {
 
 impl Peer {
     #[must_use]
-    pub fn ben_map(&self) -> BencodeMut {
+    pub fn ben_map(&self) -> BencodeMut<'_> {
         ben_map! {
             "peer id" => ben_bytes!(self.peer_id.clone().to_vec()),
             "ip" => ben_bytes!(self.ip.to_string()),
diff --git a/src/servers/udp/handlers.rs b/src/servers/udp/handlers.rs
@@ -104,6 +104,7 @@ pub async fn handle_connect(remote_addr: SocketAddr, request: &ConnectRequest, t
 /// # Errors
 ///
 /// Will return `Error` if unable to `authenticate_request`.
+#[allow(deprecated)]
 pub async fn authenticate(info_hash: &InfoHash, tracker: &Tracker) -> Result<(), Error> {
     tracker
         .authenticate_request(info_hash, &None)
@@ -225,6 +226,7 @@ pub async fn handle_scrape(remote_addr: SocketAddr, request: &ScrapeRequest, tra
         let info_hash = file.0;
         let swarm_metadata = file.1;
 
+        #[allow(deprecated)]
         let scrape_entry = if tracker.authenticate_request(info_hash, &None).await.is_ok() {
             #[allow(clippy::cast_possible_truncation)]
             TorrentScrapeStatistics {
diff --git a/src/servers/udp/server.rs b/src/servers/udp/server.rs
@@ -143,7 +143,7 @@ impl UdpServer<Running> {
     pub async fn stop(self) -> Result<UdpServer<Stopped>, Error> {
         self.state.stop_job_sender.send(1).map_err(|e| Error::Error(e.to_string()))?;
 
-        let _: Result<(), tokio::task::JoinError> = self.state.job.await;
+        drop(self.state.job.await);
 
         let stopped_api_server: UdpServer<Stopped> = UdpServer {
             cfg: self.cfg,
diff --git a/src/shared/bit_torrent/info_hash.rs b/src/shared/bit_torrent/info_hash.rs
@@ -167,7 +167,7 @@ impl InfoHash {
 }
 
 impl std::fmt::Display for InfoHash {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut chars = [0u8; 40];
         binascii::bin2hex(&self.0, &mut chars).expect("failed to hexlify");
         write!(f, "{}", std::str::from_utf8(&chars).unwrap())
@@ -195,7 +195,7 @@ impl Ord for InfoHash {
 
 impl std::cmp::PartialOrd<InfoHash> for InfoHash {
     fn partial_cmp(&self, other: &InfoHash) -> Option<std::cmp::Ordering> {
-        self.0.partial_cmp(&other.0)
+        Some(self.cmp(other))
     }
 }
 
@@ -271,7 +271,7 @@ struct InfoHashVisitor;
 impl<'v> serde::de::Visitor<'v> for InfoHashVisitor {
     type Value = InfoHash;
 
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(formatter, "a 40 character long hash")
     }
 
diff --git a/src/shared/clock/time_extent.rs b/src/shared/clock/time_extent.rs
@@ -285,10 +285,7 @@ pub type DefaultTimeExtentMaker = StoppedTimeExtentMaker;
 
 #[cfg(test)]
 mod test {
-    use crate::shared::clock::time_extent::{
-        checked_duration_from_nanos, Base, DefaultTimeExtentMaker, Extent, Make, Multiplier, Product, TimeExtent, MAX, ZERO,
-    };
-    use crate::shared::clock::{Current, DurationSinceUnixEpoch, StoppedTime};
+    use crate::shared::clock::time_extent::TimeExtent;
 
     const TIME_EXTENT_VAL: TimeExtent = TimeExtent::from_sec(2, &239_812_388_723);
 
diff --git a/src/tracker/mod.rs b/src/tracker/mod.rs
@@ -732,10 +732,11 @@ impl Tracker {
 
         // todo: move this action to a separate worker
         if self.config.persistent_torrent_completed_stat && stats_updated {
-            let _: Result<(), databases::error::Error> = self
-                .database
-                .save_persistent_torrent(info_hash, torrent_entry.completed)
-                .await;
+            drop(
+                self.database
+                    .save_persistent_torrent(info_hash, torrent_entry.completed)
+                    .await,
+            );
         }
 
         let (seeders, completed, leechers) = torrent_entry.get_stats();
@@ -966,10 +967,10 @@ impl Tracker {
             return Ok(());
         }
 
-        return Err(Error::TorrentNotWhitelisted {
+        Err(Error::TorrentNotWhitelisted {
             info_hash: *info_hash,
             location: Location::caller(),
-        });
+        })
     }
 
     /// It adds a torrent to the whitelist.
diff --git a/tests/servers/http/requests/announce.rs b/tests/servers/http/requests/announce.rs
@@ -21,7 +21,7 @@ pub struct Query {
 }
 
 impl fmt::Display for Query {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.build())
     }
 }
@@ -57,7 +57,7 @@ pub enum Event {
 }
 
 impl fmt::Display for Event {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             //Event::Started => write!(f, "started"),
             //Event::Stopped => write!(f, "stopped"),
@@ -74,7 +74,7 @@ pub enum Compact {
 }
 
 impl fmt::Display for Compact {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Compact::Accepted => write!(f, "1"),
             Compact::NotAccepted => write!(f, "0"),
@@ -163,7 +163,7 @@ pub struct QueryParams {
 }
 
 impl std::fmt::Display for QueryParams {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let mut params = vec![];
 
         if let Some(info_hash) = &self.info_hash {
diff --git a/tests/servers/http/requests/scrape.rs b/tests/servers/http/requests/scrape.rs
@@ -10,7 +10,7 @@ pub struct Query {
 }
 
 impl fmt::Display for Query {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.build())
     }
 }
@@ -93,7 +93,7 @@ impl QueryParams {
 }
 
 impl std::fmt::Display for QueryParams {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         let query = self
             .info_hash
             .iter()
diff --git a/tests/servers/mod.rs b/tests/servers/mod.rs
@@ -1,5 +1,3 @@
-extern crate rand;
-
 mod api;
 mod http;
 mod udp;

Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,7 @@ impl From<AuthKey> for auth::ExpiringKey {`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
	`30`	`+#[allow(deprecated)]`
`30`	`31`	`impl From<auth::ExpiringKey> for AuthKey {`
`31`	`32`	`fn from(auth_key: auth::ExpiringKey) -> Self {`
`32`	`33`	`AuthKey {`
`@@ -63,6 +64,7 @@ mod tests {`
`63`	`64`	`}`
`64`	`65`
`65`	`66`	`#[test]`
	`67`	`+ #[allow(deprecated)]`
`66`	`68`	`fn it_should_be_convertible_into_an_auth_key() {`
`67`	`69`	`let auth_key_resource = AuthKey {`
`68`	`70`	`key: "IaWDneuFNZi8IB4MPA3qW1CD0M30EZSM".to_string(), // cspell:disable-line`
`@@ -80,6 +82,7 @@ mod tests {`
`80`	`82`	`}`
`81`	`83`
`82`	`84`	`#[test]`
	`85`	`+ #[allow(deprecated)]`
`83`	`86`	`fn it_should_be_convertible_from_an_auth_key() {`
`84`	`87`	`let auth_key = auth::ExpiringKey {`
`85`	`88`	`key: "IaWDneuFNZi8IB4MPA3qW1CD0M30EZSM".parse::<Key>().unwrap(), // cspell:disable-line`
`@@ -97,6 +100,7 @@ mod tests {`
`97`	`100`	`}`
`98`	`101`
`99`	`102`	`#[test]`
	`103`	`+ #[allow(deprecated)]`
`100`	`104`	`fn it_should_be_convertible_into_json() {`
`101`	`105`	`assert_eq!(`
`102`	`106`	`serde_json::to_string(&AuthKey {`
Original file line number	Diff line number	Diff line change
`@@ -137,7 +137,7 @@ impl From<Vec<(&str, &str)>> for Query {`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`impl std::fmt::Display for Query {`
`140`		`- fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {`
	`140`	`+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`141`	`141`	`let query = self`
`142`	`142`	`.params`
`143`	`143`	`.iter_all()`
`@@ -185,7 +185,7 @@ impl FromStr for NameValuePair {`
`185`	`185`	`}`
`186`	`186`
`187`	`187`	`impl std::fmt::Display for NameValuePair {`
`188`		`- fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {`
	`188`	`+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`189`	`189`	`write!(f, "{}={}", self.name, self.value)`
`190`	`190`	`}`
`191`	`191`	`}`
`@@ -208,7 +208,7 @@ impl FieldValuePairSet {`
`208`	`208`	`}`
`209`	`209`
`210`	`210`	`impl std::fmt::Display for FieldValuePairSet {`
`211`		`- fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {`
	`211`	`+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`212`	`212`	`let query = self`
`213`	`213`	`.pairs`
`214`	`214`	`.iter()`
Original file line number	Diff line number	Diff line change
`@@ -74,12 +74,10 @@ fn extract_info_hashes(query: &Query) -> Result<Vec<InfoHash>, ParseScrapeQueryE`
`74`	`74`
`75`	`75`	`Ok(info_hashes)`
`76`	`76`	`}`
`77`		`- None => {`
`78`		`- return Err(ParseScrapeQueryError::MissingParam {`
`79`		`- location: Location::caller(),`
`80`		`- param_name: INFO_HASH.to_owned(),`
`81`		`- })`
`82`		`- }`
	`77`	`+ None => Err(ParseScrapeQueryError::MissingParam {`
	`78`	`+ location: Location::caller(),`
	`79`	`+ param_name: INFO_HASH.to_owned(),`
	`80`	`+ }),`
`83`	`81`	`}`
`84`	`82`	`}`
`85`	`83`