Fix more warnings for different feature combinations

This patch helps to clean up warnings by:

* adding some more `#[cfg(feature = "...")]` annotations.
* Moving `#[test]` and `#[tokio::test]` to be first in order to work
  better with rust-analyzer's proc macro server.

As best as I can tell I didn't accidentally remove APIs, but I wouldn't
mind if someone reviewed with that in mind.

Author: erickt

src/client/legacy/client.rs

@@ -1512,6 +1512,8 @@ impl Builder {
     {
         #[cfg(feature = "http2")]
         self.h2_builder.timer(timer);
+        #[cfg(not(feature = "http2"))]
+        let _ = timer;
         self
     }
 
@@ -1568,7 +1570,7 @@ impl Builder {
     }
 
     /// Build a client with this configuration and the default `HttpConnector`.
-    #[cfg(feature = "tokio")]
+    #[cfg(all(feature = "tokio"))]
     pub fn build_http<B>(&self) -> Client<HttpConnector, B>
     where
         B: Body + Send,

src/client/legacy/connect/http.rs

@@ -1074,9 +1074,9 @@ mod tests {
     }
 
     // NOTE: pnet crate that we use in this test doesn't compile on Windows
+    #[tokio::test]
     #[cfg(any(target_os = "linux", target_os = "macos"))]
     #[cfg_attr(miri, ignore)]
-    #[tokio::test]
     async fn local_address() {
         use std::net::{IpAddr, TcpListener};
 
@@ -1112,8 +1112,8 @@ mod tests {
     }
 
     // NOTE: pnet crate that we use in this test doesn't compile on Windows
-    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
     #[tokio::test]
+    #[cfg(any(target_os = "android", target_os = "fuchsia", target_os = "linux"))]
     #[ignore = "setting `SO_BINDTODEVICE` requires the `CAP_NET_RAW` capability (works when running as root)"]
     async fn interface() {
         use socket2::{Domain, Protocol, Socket, Type};

src/common/rewind.rs

@@ -1,3 +1,5 @@
+#![cfg(any(feature = "http1", feature = "http2"))]
+
 use std::{cmp, io};
 
 use bytes::{Buf, Bytes};

src/server/conn/auto/mod.rs

@@ -80,12 +80,16 @@ impl<E> Builder<E> {
     /// # Example
     ///
     /// ```
+    /// # #[cfg(all(feature = "tokio", feature = "http2"))]
+    /// # fn run() {
     /// use hyper_util::{
     ///     rt::TokioExecutor,
     ///     server::conn::auto,
     /// };
     ///
     /// auto::Builder::new(TokioExecutor::new());
+    /// # }
+    /// # fn main() {}
     /// ```
     pub fn new(executor: E) -> Self {
         Self {
@@ -179,7 +183,7 @@ impl<E> Builder<E> {
     /// auto::Builder::new(TokioExecutor::new())
     ///     .title_case_headers(true);
     /// ```
-    #[cfg(feature = "http1")]
+    #[cfg(all(feature = "tokio", feature = "http1"))]
     pub fn title_case_headers(mut self, enabled: bool) -> Self {
         self.http1.title_case_headers(enabled);
         self
@@ -203,7 +207,7 @@ impl<E> Builder<E> {
     /// auto::Builder::new(TokioExecutor::new())
     ///     .preserve_header_case(true);
     /// ```
-    #[cfg(feature = "http1")]
+    #[cfg(all(feature = "tokio", feature = "http1"))]
     pub fn preserve_header_case(mut self, enabled: bool) -> Self {
         self.http1.preserve_header_case(enabled);
         self
@@ -1124,17 +1128,24 @@ impl<E> Http2Builder<'_, E> {
     }
 }
 
-#[cfg(test)]
+#[cfg(all(test, feature = "tokio"))]
 mod tests {
-    use crate::{
-        rt::{TokioExecutor, TokioIo},
-        server::conn::auto,
-    };
+    use crate::rt::{TokioExecutor, TokioIo};
+    use crate::server::conn::auto;
     use http::{Request, Response};
+    #[cfg(all(feature = "http1", feature = "http2", not(miri)))]
     use http_body::Body;
-    use http_body_util::{BodyExt, Empty, Full};
-    use hyper::{body, body::Bytes, client, service::service_fn};
-    use std::{convert::Infallible, error::Error as StdError, net::SocketAddr, time::Duration};
+    use http_body_util::Full;
+    #[cfg(all(feature = "http1", feature = "http2", not(miri)))]
+    use http_body_util::{BodyExt, Empty};
+    #[cfg(all(feature = "http1", feature = "http2", not(miri)))]
+    use hyper::client;
+    use hyper::service::service_fn;
+    use hyper::{body, body::Bytes};
+    use std::convert::Infallible;
+    #[cfg(all(feature = "http1", feature = "http2", not(miri)))]
+    use std::error::Error as StdError;
+    use std::{net::SocketAddr, time::Duration};
     use tokio::{
         net::{TcpListener, TcpStream},
         pin,
@@ -1143,6 +1154,7 @@ mod tests {
     const BODY: &[u8] = b"Hello, world!";
 
     #[test]
+    #[cfg(all(feature = "http1", feature = "http2"))]
     fn configuration() {
         // One liner.
         auto::Builder::new(TokioExecutor::new())
@@ -1184,8 +1196,8 @@ mod tests {
             .http1_only();
     }
 
-    #[cfg(not(miri))]
     #[tokio::test]
+    #[cfg(all(feature = "http1", feature = "http2", not(miri)))]
     async fn http1() {
         let addr = start_server(false, false).await;
         let mut sender = connect_h1(addr).await;
@@ -1200,8 +1212,8 @@ mod tests {
         assert_eq!(body, BODY);
     }
 
-    #[cfg(not(miri))]
     #[tokio::test]
+    #[cfg(all(feature = "http1", feature = "http2", not(miri)))]
     async fn http2() {
         let addr = start_server(false, false).await;
         let mut sender = connect_h2(addr).await;
@@ -1216,8 +1228,8 @@ mod tests {
         assert_eq!(body, BODY);
     }
 
-    #[cfg(not(miri))]
     #[tokio::test]
+    #[cfg(all(feature = "http1", feature = "http2", not(miri)))]
     async fn http2_only() {
         let addr = start_server(false, true).await;
         let mut sender = connect_h2(addr).await;
@@ -1232,8 +1244,8 @@ mod tests {
         assert_eq!(body, BODY);
     }
 
-    #[cfg(not(miri))]
     #[tokio::test]
+    #[cfg(all(feature = "http1", feature = "http2", not(miri)))]
     async fn http2_only_fail_if_client_is_http1() {
         let addr = start_server(false, true).await;
         let mut sender = connect_h1(addr).await;
@@ -1244,8 +1256,8 @@ mod tests {
             .expect_err("should fail");
     }
 
-    #[cfg(not(miri))]
     #[tokio::test]
+    #[cfg(all(feature = "http1", feature = "http2", not(miri)))]
     async fn http1_only() {
         let addr = start_server(true, false).await;
         let mut sender = connect_h1(addr).await;
@@ -1260,8 +1272,8 @@ mod tests {
         assert_eq!(body, BODY);
     }
 
-    #[cfg(not(miri))]
     #[tokio::test]
+    #[cfg(all(feature = "http1", feature = "http2", not(miri)))]
     async fn http1_only_fail_if_client_is_http2() {
         let addr = start_server(true, false).await;
         let mut sender = connect_h2(addr).await;
@@ -1306,6 +1318,7 @@ mod tests {
         assert_eq!(connection_error.kind(), std::io::ErrorKind::Interrupted);
     }
 
+    #[cfg(all(feature = "http1", feature = "http2", not(miri)))]
     async fn connect_h1<B>(addr: SocketAddr) -> client::conn::http1::SendRequest<B>
     where
         B: Body + Send + 'static,
@@ -1320,6 +1333,7 @@ mod tests {
         sender
     }
 
+    #[cfg(all(feature = "http1", feature = "http2", not(miri)))]
     async fn connect_h2<B>(addr: SocketAddr) -> client::conn::http2::SendRequest<B>
     where
         B: Body + Unpin + Send + 'static,
@@ -1337,6 +1351,7 @@ mod tests {
         sender
     }
 
+    #[cfg(all(feature = "http1", feature = "http2", not(miri)))]
     async fn start_server(h1_only: bool, h2_only: bool) -> SocketAddr {
         let addr: SocketAddr = ([127, 0, 0, 1], 0).into();
         let listener = TcpListener::bind(addr).await.unwrap();

tests/legacy_client.rs

@@ -1,9 +1,15 @@
-#![cfg(all(feature = "client-legacy", any(feature = "http1", feature = "http2")))]
+#![cfg(all(
+    feature = "client-legacy",
+    feature = "tokio",
+    any(feature = "http1", feature = "http2")
+))]
 
 mod test_utils;
 
 use std::io::{Read, Write};
-use std::net::{SocketAddr, TcpListener};
+#[cfg(feature = "http2")]
+use std::net::SocketAddr;
+use std::net::TcpListener;
 use std::pin::Pin;
 use std::sync::atomic::Ordering;
 use std::sync::Arc;
@@ -16,15 +22,19 @@ use futures_util::future::{self, FutureExt, TryFutureExt};
 use futures_util::stream::StreamExt;
 use futures_util::{self, Stream};
 use http_body_util::BodyExt;
-use http_body_util::{Empty, Full, StreamBody};
+#[cfg(feature = "http2")]
+use http_body_util::Full;
+use http_body_util::{Empty, StreamBody};
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 
 use hyper::body::Bytes;
 use hyper::body::Frame;
 use hyper::Request;
 use hyper_util::client::legacy::connect::{capture_connection, HttpConnector};
 use hyper_util::client::legacy::Client;
-use hyper_util::rt::{TokioExecutor, TokioIo};
+use hyper_util::rt::TokioExecutor;
+#[cfg(feature = "http2")]
+use hyper_util::rt::TokioIo;
 
 use test_utils::{DebugConnector, DebugStream};
 
@@ -815,7 +825,7 @@ fn client_upgrade() {
 }
 
 #[cfg(not(miri))]
-#[cfg(feature = "server")]
+#[cfg(all(feature = "server", feature = "http1", feature = "http2"))]
 #[test]
 fn client_http2_upgrade() {
     use http::{Method, Response, Version};
@@ -1346,8 +1356,8 @@ impl tower_service::Service<hyper::Uri> for MockConnector {
 // Test for connection error propagation with PR #184.
 // Simulates a connection failure by setting failed=true and returning a custom io::Error.
 // Verifies the error propagates through hyper’s client as a hyper::Error(Io, ...).
-#[cfg(feature = "http1")]
 #[tokio::test]
+#[cfg(feature = "http1")]
 async fn test_connection_error_propagation_pr184() {
     // Define the error message for the simulated connection failure.
     // Reused for creating the error and verifying the result.
@@ -1404,8 +1414,8 @@ async fn test_connection_error_propagation_pr184() {
 // Simulates a connection that returns EOF immediately, causing hyper’s HTTP/1.1 parser
 // to fail with IncompleteMessage due to no response data.
 // Uses MockConnector with conn_error=None to keep failed=false, ensuring EOF behavior.
-#[cfg(feature = "http1")]
 #[tokio::test]
+#[cfg(feature = "http1")]
 async fn test_incomplete_message_error_pr184() {
     // Create an empty IoBuilder to simulate a connection with no data.
     // No write or read expectations, so poll_read returns EOF (Poll::Ready(Ok(0))).
@@ -1464,8 +1474,8 @@ async fn test_incomplete_message_error_pr184() {
 // Test for a successful HTTP/1.1 connection using a mock connector.
 // Simulates a server that accepts a request and responds with a 200 OK.
 // Verifies the client correctly sends the request and receives the response.
-#[cfg(feature = "http1")]
 #[tokio::test]
+#[cfg(feature = "http1")]
 async fn test_successful_connection() {
     // Define the expected server response: a valid HTTP/1.1 200 OK with no body.
     let response = b"HTTP/1.1 200 OK\r\nContent-Length: 0\r\n\r\n";

tests/proxy.rs

@@ -1,4 +1,4 @@
-#![cfg(all(feature = "client-legacy", feature = "client-proxy"))]
+#![cfg(all(feature = "client-legacy", feature = "client-proxy", feature = "tokio"))]
 
 use tokio::io::{AsyncReadExt, AsyncWriteExt};
 use tokio::net::{TcpListener, TcpStream};