Merge branch 'master' into const-statuscode-from_u16

Author: seanmonstar

.github/FUNDING.yml

@@ -0,0 +1 @@
+github: seanmonstar

Cargo.toml

@@ -43,7 +43,7 @@ itoa = "1"
 
 [dev-dependencies]
 quickcheck = "1"
-rand = "0.8.0"
+rand = "0.9.1"
 serde = "1.0"
 serde_json = "1.0"
 doc-comment = "0.3"

src/extensions.rs

@@ -1,4 +1,4 @@
-use std::any::{Any, TypeId};
+use std::any::{type_name, Any, TypeId};
 use std::collections::HashMap;
 use std::fmt;
 use std::hash::{BuildHasherDefault, Hasher};
@@ -267,7 +267,21 @@ impl Extensions {
 
 impl fmt::Debug for Extensions {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Extensions").finish()
+        struct TypeName(&'static str);
+        impl fmt::Debug for TypeName {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                f.write_str(self.0)
+            }
+        }
+
+        let mut set = f.debug_set();
+        if let Some(map) = &self.map {
+            set.entries(
+                map.values()
+                    .map(|any_clone| TypeName(any_clone.as_ref().type_name())),
+            );
+        }
+        set.finish()
     }
 }
 
@@ -276,6 +290,7 @@ trait AnyClone: Any {
     fn as_any(&self) -> &dyn Any;
     fn as_any_mut(&mut self) -> &mut dyn Any;
     fn into_any(self: Box<Self>) -> Box<dyn Any>;
+    fn type_name(&self) -> &'static str;
 }
 
 impl<T: Clone + Send + Sync + 'static> AnyClone for T {
@@ -294,6 +309,10 @@ impl<T: Clone + Send + Sync + 'static> AnyClone for T {
     fn into_any(self: Box<Self>) -> Box<dyn Any> {
         self
     }
+
+    fn type_name(&self) -> &'static str {
+        type_name::<T>()
+    }
 }
 
 impl Clone for Box<dyn AnyClone + Send + Sync> {
@@ -308,13 +327,23 @@ fn test_extensions() {
     struct MyType(i32);
 
     let mut extensions = Extensions::new();
+    assert_eq!(format!("{extensions:?}"), "{}");
 
     extensions.insert(5i32);
     extensions.insert(MyType(10));
 
     assert_eq!(extensions.get(), Some(&5i32));
     assert_eq!(extensions.get_mut(), Some(&mut 5i32));
 
+    let dbg = format!("{extensions:?}");
+    // map order is NOT deterministic
+    assert!(
+        (dbg == "{http::extensions::test_extensions::MyType, i32}")
+            || (dbg == "{i32, http::extensions::test_extensions::MyType}"),
+        "{}",
+        dbg
+    );
+
     let ext2 = extensions.clone();
 
     assert_eq!(extensions.remove::<i32>(), Some(5i32));

src/header/map.rs

@@ -14,11 +14,47 @@ use super::HeaderValue;
 pub use self::as_header_name::AsHeaderName;
 pub use self::into_header_name::IntoHeaderName;
 
-/// A set of HTTP headers
+/// A specialized [multimap](<https://en.wikipedia.org/wiki/Multimap>) for
+/// header names and values.
 ///
-/// `HeaderMap` is a multimap of [`HeaderName`] to values.
+/// # Overview
+///
+/// `HeaderMap` is designed specifically for efficient manipulation of HTTP
+/// headers. It supports multiple values per header name and provides
+/// specialized APIs for insertion, retrieval, and iteration.
+///
+/// The internal implementation is optimized for common usage patterns in HTTP,
+/// and may change across versions. For example, the current implementation uses
+/// [Robin Hood
+/// hashing](<https://en.wikipedia.org/wiki/Hash_table#Robin_Hood_hashing>) to
+/// store entries compactly and enable high load factors with good performance.
+/// However, the collision resolution strategy and storage mechanism are not
+/// part of the public API and may be altered in future releases.
+///
+/// # Iteration order
+///
+/// Unless otherwise specified, the order in which items are returned by
+/// iterators from `HeaderMap` methods is arbitrary; there is no guaranteed
+/// ordering among the elements yielded by such an iterator. Changes to the
+/// iteration order are not considered breaking changes, so users must not rely
+/// on any incidental order produced by such an iterator. However, for a given
+/// crate version, the iteration order will be consistent across all platforms.
+///
+/// # Adaptive hashing
+///
+/// `HeaderMap` uses an adaptive strategy for hashing to maintain fast lookups
+/// while resisting hash collision attacks. The default hash function
+/// prioritizes performance. In scenarios where high collision rates are
+/// detected—typically indicative of denial-of-service attacks—the
+/// implementation switches to a more secure, collision-resistant hash function.
+///
+/// # Limitations
+///
+/// A `HeaderMap` can store at most 32,768 entries \(header name/value pairs\).
+/// Attempting to exceed this limit will result in a panic.
 ///
 /// [`HeaderName`]: struct.HeaderName.html
+/// [`HeaderMap`]: struct.HeaderMap.html
 ///
 /// # Examples
 ///
@@ -445,8 +481,21 @@ impl HeaderMap {
     /// assert!(map.is_empty());
     /// assert_eq!(0, map.capacity());
     /// ```
+    #[inline]
     pub fn new() -> Self {
-        HeaderMap::try_with_capacity(0).unwrap()
+        Self::default()
+    }
+}
+
+impl<T> Default for HeaderMap<T> {
+    fn default() -> Self {
+        HeaderMap {
+            mask: 0,
+            indices: Box::new([]), // as a ZST, this doesn't actually allocate anything
+            entries: Vec::new(),
+            extra_values: Vec::new(),
+            danger: Danger::Green,
+        }
     }
 }
 
@@ -501,13 +550,7 @@ impl<T> HeaderMap<T> {
     /// ```
     pub fn try_with_capacity(capacity: usize) -> Result<HeaderMap<T>, MaxSizeReached> {
         if capacity == 0 {
-            Ok(HeaderMap {
-                mask: 0,
-                indices: Box::new([]), // as a ZST, this doesn't actually allocate anything
-                entries: Vec::new(),
-                extra_values: Vec::new(),
-                danger: Danger::Green,
-            })
+            Ok(Self::default())
         } else {
             let raw_cap = match to_raw_capacity(capacity).checked_next_power_of_two() {
                 Some(c) => c,
@@ -2164,12 +2207,6 @@ impl<T: fmt::Debug> fmt::Debug for HeaderMap<T> {
     }
 }
 
-impl<T> Default for HeaderMap<T> {
-    fn default() -> Self {
-        HeaderMap::try_with_capacity(0).expect("zero capacity should never fail")
-    }
-}
-
 impl<K, T> ops::Index<K> for HeaderMap<T>
 where
     K: AsHeaderName,
@@ -2315,15 +2352,15 @@ impl<'a, T> IterMut<'a, T> {
             self.cursor = Some(Cursor::Head);
         }
 
-        let entry = unsafe { &mut (*self.map).entries[self.entry] };
+        let entry = &mut unsafe { &mut *self.map }.entries[self.entry];
 
         match self.cursor.unwrap() {
             Head => {
                 self.cursor = entry.links.map(|l| Values(l.next));
                 Some((&entry.key, &mut entry.value as *mut _))
             }
             Values(idx) => {
-                let extra = unsafe { &mut (*self.map).extra_values[idx] };
+                let extra = &mut unsafe { &mut (*self.map) }.extra_values[idx];
 
                 match extra.next {
                     Link::Entry(_) => self.cursor = None,
@@ -2963,7 +3000,7 @@ impl<'a, T: 'a> Iterator for ValueIterMut<'a, T> {
     fn next(&mut self) -> Option<Self::Item> {
         use self::Cursor::*;
 
-        let entry = unsafe { &mut (*self.map).entries[self.index] };
+        let entry = &mut unsafe { &mut *self.map }.entries[self.index];
 
         match self.front {
             Some(Head) => {
@@ -2983,7 +3020,7 @@ impl<'a, T: 'a> Iterator for ValueIterMut<'a, T> {
                 Some(&mut entry.value)
             }
             Some(Values(idx)) => {
-                let extra = unsafe { &mut (*self.map).extra_values[idx] };
+                let extra = &mut unsafe { &mut *self.map }.extra_values[idx];
 
                 if self.front == self.back {
                     self.front = None;
@@ -3006,7 +3043,7 @@ impl<'a, T: 'a> DoubleEndedIterator for ValueIterMut<'a, T> {
     fn next_back(&mut self) -> Option<Self::Item> {
         use self::Cursor::*;
 
-        let entry = unsafe { &mut (*self.map).entries[self.index] };
+        let entry = &mut unsafe { &mut *self.map }.entries[self.index];
 
         match self.back {
             Some(Head) => {
@@ -3015,7 +3052,7 @@ impl<'a, T: 'a> DoubleEndedIterator for ValueIterMut<'a, T> {
                 Some(&mut entry.value)
             }
             Some(Values(idx)) => {
-                let extra = unsafe { &mut (*self.map).extra_values[idx] };
+                let extra = &mut unsafe { &mut *self.map }.extra_values[idx];
 
                 if self.front == self.back {
                     self.front = None;

src/header/mod.rs

@@ -28,47 +28,13 @@
 //!
 //! # `HeaderMap`
 //!
-//! `HeaderMap` is a map structure of header names highly optimized for use
-//! cases common with HTTP. It is a [multimap] structure, where each header name
-//! may have multiple associated header values. Given this, some of the APIs
-//! diverge from [`HashMap`].
+//! The [`HeaderMap`] type is a specialized
+//! [multimap](<https://en.wikipedia.org/wiki/Multimap>) structure for storing
+//! header names and values. It is designed specifically for efficient
+//! manipulation of HTTP headers. It supports multiple values per header name
+//! and provides specialized APIs for insertion, retrieval, and iteration.
 //!
-//! ## Overview
-//!
-//! Just like `HashMap` in Rust's stdlib, `HeaderMap` is based on [Robin Hood
-//! hashing]. This algorithm tends to reduce the worst case search times in the
-//! table and enables high load factors without seriously affecting performance.
-//! Internally, keys and values are stored in vectors. As such, each insertion
-//! will not incur allocation overhead. However, once the underlying vector
-//! storage is full, a larger vector must be allocated and all values copied.
-//!
-//! ## Deterministic ordering
-//!
-//! Unlike Rust's `HashMap`, values in `HeaderMap` are deterministically
-//! ordered. Roughly, values are ordered by insertion. This means that a
-//! function that deterministically operates on a header map can rely on the
-//! iteration order to remain consistent across processes and platforms.
-//!
-//! ## Adaptive hashing
-//!
-//! `HeaderMap` uses an adaptive hashing strategy in order to efficiently handle
-//! most common cases. All standard headers have statically computed hash values
-//! which removes the need to perform any hashing of these headers at runtime.
-//! The default hash function emphasizes performance over robustness. However,
-//! `HeaderMap` detects high collision rates and switches to a secure hash
-//! function in those events. The threshold is set such that only denial of
-//! service attacks should trigger it.
-//!
-//! ## Limitations
-//!
-//! `HeaderMap` can store a maximum of 32,768 headers (header name / value
-//! pairs). Attempting to insert more will result in a panic.
-//!
-//! [`HeaderName`]: struct.HeaderName.html
-//! [`HeaderMap`]: struct.HeaderMap.html
-//! [multimap]: https://en.wikipedia.org/wiki/Multimap
-//! [`HashMap`]: https://doc.rust-lang.org/std/collections/struct.HashMap.html
-//! [Robin Hood hashing]: https://en.wikipedia.org/wiki/Hash_table#Robin_Hood_hashing
+//! [*See also the `HeaderMap` type.*](HeaderMap)
 
 mod map;
 mod name;

src/version.rs

@@ -43,13 +43,14 @@ impl Version {
 }
 
 #[derive(PartialEq, PartialOrd, Copy, Clone, Eq, Ord, Hash)]
+#[non_exhaustive]
 enum Http {
     Http09,
     Http10,
     Http11,
     H2,
     H3,
-    __NonExhaustive,
+    //__NonExhaustive,
 }
 
 impl Default for Version {
@@ -69,7 +70,7 @@ impl fmt::Debug for Version {
             Http11 => "HTTP/1.1",
             H2 => "HTTP/2.0",
             H3 => "HTTP/3.0",
-            __NonExhaustive => unreachable!(),
+            //__NonExhaustive => unreachable!(),
         })
     }
 }

tests/header_map_fuzz.rs

@@ -2,8 +2,8 @@ use http::header::*;
 use http::*;
 
 use quickcheck::{Arbitrary, Gen, QuickCheck, TestResult};
+use rand::prelude::IndexedRandom;
 use rand::rngs::StdRng;
-use rand::seq::SliceRandom;
 use rand::{Rng, SeedableRng};
 
 use std::collections::HashMap;
@@ -76,12 +76,12 @@ impl Fuzz {
 
         let mut steps = vec![];
         let mut expect = AltMap::default();
-        let num = rng.gen_range(5..500);
+        let num = rng.random_range(5..500);
 
         let weight = Weight {
-            insert: rng.gen_range(1..10),
-            remove: rng.gen_range(1..10),
-            append: rng.gen_range(1..10),
+            insert: rng.random_range(1..10),
+            remove: rng.random_range(1..10),
+            append: rng.random_range(1..10),
         };
 
         while steps.len() < num {
@@ -112,7 +112,7 @@ impl Fuzz {
 
 impl Arbitrary for Fuzz {
     fn arbitrary(_: &mut Gen) -> Self {
-        Self::new(rand::thread_rng().gen())
+        Self::new(rand::rng().random())
     }
 }
 
@@ -130,7 +130,7 @@ impl AltMap {
     fn gen_action(&mut self, weight: &Weight, rng: &mut StdRng) -> Action {
         let sum = weight.insert + weight.remove + weight.append;
 
-        let mut num = rng.gen_range(0..sum);
+        let mut num = rng.random_range(0..sum);
 
         if num < weight.insert {
             return self.gen_insert(rng);
@@ -180,7 +180,7 @@ impl AltMap {
 
     /// Negative numbers weigh finding an existing header higher
     fn gen_name(&self, weight: i32, rng: &mut StdRng) -> HeaderName {
-        let mut existing = rng.gen_ratio(1, weight.abs() as u32);
+        let mut existing = rng.random_ratio(1, weight.abs() as u32);
 
         if weight < 0 {
             existing = !existing;
@@ -202,7 +202,7 @@ impl AltMap {
         if self.map.is_empty() {
             None
         } else {
-            let n = rng.gen_range(0..self.map.len());
+            let n = rng.random_range(0..self.map.len());
             self.map.keys().nth(n).map(Clone::clone)
         }
     }
@@ -337,7 +337,7 @@ fn gen_header_name(g: &mut StdRng) -> HeaderName {
         header::X_XSS_PROTECTION,
     ];
 
-    if g.gen_ratio(1, 2) {
+    if g.random_ratio(1, 2) {
         STANDARD_HEADERS.choose(g).unwrap().clone()
     } else {
         let value = gen_string(g, 1, 25);