chore: merge upstream master into vectored write fix

Author: snowyukitty

CHANGELOG.md

@@ -1,3 +1,23 @@
+## v1.11.0 (2026-07-20)
+
+
+#### Bug Fixes
+
+* **http1:**
+  * discard content-length header when received before transfer-encoding (#4124) ([540fff91](https://github.com/hyperium/hyper/commit/540fff9180ce47ee5fab01b6cc2126eb6c286eda), closes [#4123](https://github.com/hyperium/hyper/issues/4123))
+  * use append for repeat trailer values in encoder (#4118) ([de1483d7](https://github.com/hyperium/hyper/commit/de1483d7db70477cc8799a344634ae6ee020a7db))
+  * allow up to max_headers trailers (#4108) ([f584091a](https://github.com/hyperium/hyper/commit/f584091ac096bd5dd478f73256188c3261a945b9))
+  * use append for repeat trailers (#4107) ([876effe1](https://github.com/hyperium/hyper/commit/876effe10fd8f8ad4535ade1f84e88f199f2cf6b))
+  * flush buffered data before shutdown (#4018) ([72046cc7](https://github.com/hyperium/hyper/commit/72046cc72e7aa82c439eed00850b8b1ad3f7e4dc), closes [#4022](https://github.com/hyperium/hyper/issues/4022))
+  * more strictly enforce max_buf_size when parsing (#4093) ([90ede307](https://github.com/hyperium/hyper/commit/90ede307470dba98b4e184ad88d6f5aae8b0afd7), closes [#4081](https://github.com/hyperium/hyper/issues/4081))
+* **http2:** avoid buffering `Upgraded` writes without send capacity (#4102) ([aecf5abf](https://github.com/hyperium/hyper/commit/aecf5abfbc3dc95f21ac1538db1aa3f690fa6ab6))
+
+
+#### Features
+
+* **rt:** add `ReadBufCursor::initialized_unfilled()` method (#4115) ([ccc1e850](https://github.com/hyperium/hyper/commit/ccc1e850dc0cda3e71b0acd11f60ca3d48d09034))
+
+
 ### v1.10.1 (2026-05-29)
 
 

CONTRIBUTING.md

@@ -2,11 +2,11 @@
 
 You want to contribute? You're awesome!
 
-Contributions come in all shapes and sizes. Let's take a tour of some of the different wants you could contribute.
+Contributions come in all shapes and sizes. Let's take a tour of some of the different ways you could contribute.
 
 ## [Code of Conduct](./docs/CODE_OF_CONDUCT.md)
 
-Firstly, all interactions with the project need to abide by the code of conduct. This is to make sure everyone is treated kindly.
+Firstly, all interactions with the project need to abide by the code of conduct. This makes sure everyone is treated kindly.
 
 ## [Issues](./docs/ISSUES.md)
 
@@ -29,7 +29,7 @@ By the way, consider checking the [list of easy issues](https://github.com/hyper
 
 Improving hyper's documentation is a huge help for everyone who is trying to _use_ hyper.
 
-- The API documentation (rendered at https://docs.rs/hyper) is stored as rustdoc comments directly in the source.
+- The API [documentation](https://docs.rs/hyper) is stored as rustdoc comments directly in the source.
 - The main website has [tutorial-style guides](https://hyper.rs/guides). As of v1, they are currently in a [revamp](https://github.com/hyperium/hyper/issues/3411), and would greatly benefit from being filled out.
 
 ## Help

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hyper"
-version = "1.10.1"
+version = "1.11.0"
 description = "A protective and efficient HTTP library for all."
 readme = "README.md"
 homepage = "https://hyper.rs"
@@ -141,7 +141,6 @@ panic = "allow"
 pattern_type_mismatch = "allow"
 redundant_closure_for_method_calls = "allow"
 redundant_else = "allow"
-ref_patterns = "allow" # TODO: perhaps deny?
 single_char_lifetime_names = "allow"
 struct_excessive_bools = "allow" # TODO: bogus lint?
 trivially_copy_pass_by_ref = "allow"

benches/end_to_end.rs

@@ -368,13 +368,9 @@ impl Opts {
         };
 
         let mut send_request = |req| {
-            let fut = match client {
-                Client::Http1(ref mut tx) => {
-                    futures_util::future::Either::Left(tx.send_request(req))
-                }
-                Client::Http2(ref mut tx) => {
-                    futures_util::future::Either::Right(tx.send_request(req))
-                }
+            let fut = match &mut client {
+                Client::Http1(tx) => futures_util::future::Either::Left(tx.send_request(req)),
+                Client::Http2(tx) => futures_util::future::Either::Right(tx.send_request(req)),
             };
             async {
                 let res = fut.await.expect("client wait");

src/body/incoming.rs

@@ -172,15 +172,12 @@ impl Incoming {
 
     #[cfg(feature = "ffi")]
     pub(crate) fn as_ffi_mut(&mut self) -> &mut crate::ffi::UserBody {
-        match self.kind {
-            Kind::Ffi(ref mut body) => return body,
-            _ => {
-                self.kind = Kind::Ffi(crate::ffi::UserBody::new());
-            }
+        if !matches!(self.kind, Kind::Ffi(_)) {
+            self.kind = Kind::Ffi(crate::ffi::UserBody::new());
         }
 
-        match self.kind {
-            Kind::Ffi(ref mut body) => body,
+        match &mut self.kind {
+            Kind::Ffi(body) => body,
             _ => unreachable!(),
         }
     }
@@ -208,14 +205,14 @@ impl Body for Incoming {
         )]
         cx: &mut Context<'_>,
     ) -> Poll<Option<Result<Frame<Self::Data>, Self::Error>>> {
-        match self.kind {
+        match &mut self.kind {
             Kind::Empty => Poll::Ready(None),
             #[cfg(all(feature = "http1", any(feature = "client", feature = "server")))]
             Kind::Chan {
-                content_length: ref mut len,
-                ref mut data_rx,
-                ref mut want_tx,
-                ref mut trailers_rx,
+                content_length: len,
+                data_rx,
+                want_tx,
+                trailers_rx,
             } => {
                 want_tx.send(WANT_READY);
 
@@ -234,10 +231,10 @@ impl Body for Incoming {
             }
             #[cfg(all(feature = "http2", any(feature = "client", feature = "server")))]
             Kind::H2 {
-                ref mut data_done,
-                ref ping,
-                recv: ref mut h2,
-                content_length: ref mut len,
+                data_done,
+                ping,
+                recv: h2,
+                content_length: len,
             } => {
                 if !*data_done {
                     match ready!(h2.poll_data(cx)) {
@@ -284,17 +281,17 @@ impl Body for Incoming {
             }
 
             #[cfg(feature = "ffi")]
-            Kind::Ffi(ref mut body) => body.poll_data(cx),
+            Kind::Ffi(body) => body.poll_data(cx),
         }
     }
 
     fn is_end_stream(&self) -> bool {
-        match self.kind {
+        match &self.kind {
             Kind::Empty => true,
             #[cfg(all(feature = "http1", any(feature = "client", feature = "server")))]
-            Kind::Chan { content_length, .. } => content_length == DecodedLength::ZERO,
+            Kind::Chan { content_length, .. } => *content_length == DecodedLength::ZERO,
             #[cfg(all(feature = "http2", any(feature = "client", feature = "server")))]
-            Kind::H2 { recv: ref h2, .. } => h2.is_end_stream(),
+            Kind::H2 { recv: h2, .. } => h2.is_end_stream(),
             #[cfg(feature = "ffi")]
             Kind::Ffi(..) => false,
         }
@@ -633,8 +630,8 @@ mod tests {
         drop(rx);
         assert!(tx_ready.is_woken(), "dropping rx wakes tx");
 
-        match tx_ready.poll() {
-            Poll::Ready(Err(ref e)) if e.is_closed() => (),
+        match &tx_ready.poll() {
+            Poll::Ready(Err(e)) if e.is_closed() => (),
             unexpected => panic!("tx poll ready unexpected: {:?}", unexpected),
         }
     }

src/body/length.rs

@@ -67,9 +67,9 @@ impl DecodedLength {
         any(feature = "client", feature = "server")
     ))]
     pub(crate) fn sub_if(&mut self, amt: u64) {
-        match *self {
-            DecodedLength::CHUNKED | DecodedLength::CLOSE_DELIMITED => (),
-            DecodedLength(ref mut known) => {
+        match self {
+            &mut DecodedLength::CHUNKED | &mut DecodedLength::CLOSE_DELIMITED => (),
+            DecodedLength(known) => {
                 *known -= amt;
             }
         }

src/client/dispatch.rs

@@ -266,30 +266,30 @@ fn dispatch_gone() -> crate::Error {
 impl<T, U> Callback<T, U> {
     #[cfg(feature = "http2")]
     pub(crate) fn is_canceled(&self) -> bool {
-        match *self {
-            Callback::Retry(Some(ref tx)) => tx.is_closed(),
-            Callback::NoRetry(Some(ref tx)) => tx.is_closed(),
+        match self {
+            Callback::Retry(Some(tx)) => tx.is_closed(),
+            Callback::NoRetry(Some(tx)) => tx.is_closed(),
             _ => unreachable!(),
         }
     }
 
     pub(crate) fn poll_canceled(&mut self, cx: &mut Context<'_>) -> Poll<()> {
-        match *self {
-            Callback::Retry(Some(ref mut tx)) => tx.poll_closed(cx),
-            Callback::NoRetry(Some(ref mut tx)) => tx.poll_closed(cx),
+        match self {
+            Callback::Retry(Some(tx)) => tx.poll_closed(cx),
+            Callback::NoRetry(Some(tx)) => tx.poll_closed(cx),
             _ => unreachable!(),
         }
     }
 
     pub(crate) fn send(mut self, val: Result<U, TrySendError<T>>) {
-        match self {
-            Callback::Retry(ref mut tx) => {
+        match &mut self {
+            Callback::Retry(tx) => {
                 let _ = tx
                     .take()
                     .expect("callback sender not dropped before send")
                     .send(val);
             }
-            Callback::NoRetry(ref mut tx) => {
+            Callback::NoRetry(tx) => {
                 let _ = tx
                     .take()
                     .expect("callback sender not dropped before send")

src/common/time.rs

@@ -32,37 +32,37 @@ impl fmt::Debug for Time {
 impl Time {
     #[cfg(all(any(feature = "client", feature = "server"), feature = "http2"))]
     pub(crate) fn sleep(&self, duration: Duration) -> Pin<Box<dyn Sleep>> {
-        match *self {
+        match &self {
             Time::Empty => {
                 panic!("You must supply a timer.")
             }
-            Time::Timer(ref t) => t.sleep(duration),
+            Time::Timer(t) => t.sleep(duration),
         }
     }
 
     #[cfg(all(feature = "server", feature = "http1"))]
     pub(crate) fn sleep_until(&self, deadline: Instant) -> Pin<Box<dyn Sleep>> {
-        match *self {
+        match &self {
             Time::Empty => {
                 panic!("You must supply a timer.")
             }
-            Time::Timer(ref t) => t.sleep_until(deadline),
+            Time::Timer(t) => t.sleep_until(deadline),
         }
     }
 
     pub(crate) fn now(&self) -> Instant {
-        match *self {
+        match &self {
             Time::Empty => Instant::now(),
-            Time::Timer(ref t) => t.now(),
+            Time::Timer(t) => t.now(),
         }
     }
 
     pub(crate) fn reset(&self, sleep: &mut Pin<Box<dyn Sleep>>, new_deadline: Instant) {
-        match *self {
+        match &self {
             Time::Empty => {
                 panic!("You must supply a timer.")
             }
-            Time::Timer(ref t) => t.reset(sleep, new_deadline),
+            Time::Timer(t) => t.reset(sleep, new_deadline),
         }
     }
 

src/error.rs

@@ -602,7 +602,7 @@ impl fmt::Debug for Error {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut f = f.debug_tuple("hyper::Error");
         f.field(&self.inner.kind);
-        if let Some(ref cause) = self.inner.cause {
+        if let Some(cause) = &self.inner.cause {
             f.field(cause);
         }
         f.finish()

src/ffi/client.rs

@@ -147,9 +147,9 @@ ffi_fn! {
         // Update request with original-case map of headers
         req.finalize_request();
 
-        let fut = match non_null! { &mut *conn ?= ptr::null_mut() }.tx {
-            Tx::Http1(ref mut tx) => futures_util::future::Either::Left(tx.send_request(req.0)),
-            Tx::Http2(ref mut tx) => futures_util::future::Either::Right(tx.send_request(req.0)),
+        let fut = match &mut non_null! { &mut *conn ?= ptr::null_mut() }.tx {
+            Tx::Http1(tx) => futures_util::future::Either::Left(tx.send_request(req.0)),
+            Tx::Http2(tx) => futures_util::future::Either::Right(tx.send_request(req.0)),
         };
 
         let fut = async move {