enable clippy for tower-http and fix current issues

.github/workflows/CI.yml

@@ -93,6 +93,20 @@ jobs:
         tool: [email protected]
     - run: cargo fmt --all --check
 
+  clippy:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - uses: dtolnay/rust-toolchain@stable
+      with:
+        components: clippy
+    - name: Install protoc
+      uses: taiki-e/install-action@v2
+      with:
+        tool: [email protected]
+    - run: cargo clippy --workspace --all-features --all-targets
+
   deny-check:
     name: cargo-deny check
     runs-on: ubuntu-latest

Cargo.toml

@@ -3,3 +3,4 @@ members = [
   "tower-http",
   "examples/*",
 ]
+resolver = "2"

tower-http/src/classify/grpc_errors_as_failures.rs

@@ -262,7 +262,7 @@ impl fmt::Display for GrpcFailureClass {
     }
 }
 
-#[allow(clippy::if_let_some_result)]
+#[allow(clippy::match_result_ok)]
 pub(crate) fn classify_grpc_metadata(
     headers: &HeaderMap,
     success_codes: GrpcCodeBitmask,

tower-http/src/compression/future.rs

@@ -73,6 +73,7 @@ where
                 CompressionBody::new(BodyInner::zstd(WrapBody::new(body, self.quality)))
             }
             #[cfg(feature = "fs")]
+            #[allow(unreachable_patterns)]
             (true, _) => {
                 // This should never happen because the `AcceptEncoding` struct which is used to determine
                 // `self.encoding` will only enable the different compression algorithms if the

tower-http/src/compression/mod.rs

@@ -277,7 +277,7 @@ mod tests {
                 let mut guard = self.0.write().unwrap();
                 let should_compress = *guard % 2 != 0;
                 *guard += 1;
-                dbg!(should_compress)
+                should_compress
             }
         }
 

tower-http/src/content_encoding.rs

@@ -148,7 +148,7 @@ impl QValue {
         let mut c = s.chars();
         // Parse "q=" (case-insensitively).
         match c.next() {
-            Some('q') | Some('Q') => (),
+            Some('q' | 'Q') => (),
             _ => return None,
         };
         match c.next() {
@@ -272,7 +272,7 @@ mod tests {
     #[test]
     fn no_accept_encoding_header() {
         let encoding =
-            Encoding::from_headers(&http::HeaderMap::new(), SupportedEncodingsAll::default());
+            Encoding::from_headers(&http::HeaderMap::new(), SupportedEncodingsAll);
         assert_eq!(Encoding::Identity, encoding);
     }
 
@@ -283,7 +283,7 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Gzip, encoding);
     }
 
@@ -294,7 +294,7 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip,br"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
     }
 
@@ -305,7 +305,7 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip,deflate,br"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
     }
 
@@ -316,7 +316,7 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0.5,br"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
     }
 
@@ -327,7 +327,7 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0.5,deflate,br"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
     }
 
@@ -342,7 +342,7 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("br"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
     }
 
@@ -357,7 +357,7 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("br"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
     }
 
@@ -376,7 +376,7 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("br"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
     }
 
@@ -387,23 +387,23 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0.5,br;q=0.8"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0.8,br;q=0.5"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Gzip, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0.995,br;q=0.999"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
     }
 
@@ -414,31 +414,31 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0.5,deflate;q=0.6,br;q=0.8"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0.8,deflate;q=0.6,br;q=0.5"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Gzip, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0.6,deflate;q=0.8,br;q=0.5"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Deflate, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0.995,deflate;q=0.997,br;q=0.999"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
     }
 
@@ -449,7 +449,7 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("invalid,gzip"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Gzip, encoding);
     }
 
@@ -460,23 +460,23 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Identity, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0."),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Identity, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0,br;q=0.5"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
     }
 
@@ -487,15 +487,15 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gZiP"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Gzip, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0.5,br;Q=0.8"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
     }
 
@@ -506,7 +506,7 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static(" gzip\t; q=0.5 ,\tbr ;\tq=0.8\t"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Brotli, encoding);
     }
 
@@ -517,15 +517,15 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q =0.5"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Identity, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q= 0.5"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Identity, encoding);
     }
 
@@ -536,47 +536,47 @@ mod tests {
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=-0.1"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Identity, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=00.5"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Identity, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=0.5000"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Identity, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=.5"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Identity, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=1.01"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Identity, encoding);
 
         let mut headers = http::HeaderMap::new();
         headers.append(
             http::header::ACCEPT_ENCODING,
             http::HeaderValue::from_static("gzip;q=1.001"),
         );
-        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll::default());
+        let encoding = Encoding::from_headers(&headers, SupportedEncodingsAll);
         assert_eq!(Encoding::Identity, encoding);
     }
 }

tower-http/src/cors/allow_private_network.rs

@@ -39,6 +39,7 @@ impl AllowPrivateNetwork {
         Self(AllowPrivateNetworkInner::Predicate(Arc::new(f)))
     }
 
+    #[allow(clippy::borrow_interior_mutable_const)]
     pub(super) fn to_header(
         &self,
         origin: Option<&HeaderValue>,
@@ -52,6 +53,7 @@ impl AllowPrivateNetwork {
         const ALLOW_PRIVATE_NETWORK: HeaderName =
             HeaderName::from_static("access-control-allow-private-network");
 
+        #[allow(clippy::declare_interior_mutable_const)]
         const TRUE: HeaderValue = HeaderValue::from_static("true");
 
         // Cheapest fallback: allow_private_network hasn't been set
@@ -110,6 +112,7 @@ impl Default for AllowPrivateNetworkInner {
 }
 
 #[cfg(test)]
+#[allow(clippy::borrow_interior_mutable_const)]
 mod tests {
     use super::AllowPrivateNetwork;
     use crate::cors::CorsLayer;
@@ -119,12 +122,15 @@ mod tests {
     use tower::{BoxError, ServiceBuilder, ServiceExt};
     use tower_service::Service;
 
+    #[allow(clippy::declare_interior_mutable_const)]
     const REQUEST_PRIVATE_NETWORK: HeaderName =
         HeaderName::from_static("access-control-request-private-network");
 
+    #[allow(clippy::declare_interior_mutable_const)]
     const ALLOW_PRIVATE_NETWORK: HeaderName =
         HeaderName::from_static("access-control-allow-private-network");
 
+    #[allow(clippy::declare_interior_mutable_const)]
     const TRUE: HeaderValue = HeaderValue::from_static("true");
 
     #[tokio::test]

tower-http/src/lib.rs

@@ -183,7 +183,6 @@
     clippy::todo,
     clippy::empty_enum,
     clippy::enum_glob_use,
-    clippy::pub_enum_variant_names,
     clippy::mem_forget,
     clippy::unused_self,
     clippy::filter_map_next,
@@ -211,7 +210,7 @@
     nonstandard_style,
     missing_docs
 )]
-#![deny(unreachable_pub, private_in_public)]
+#![deny(unreachable_pub)]
 #![allow(
     elided_lifetimes_in_paths,
     // TODO: Remove this once the MSRV bumps to 1.42.0 or above.