feat: Make Response const-constructable

This allows the following code to work:
```rust
const BAD_REQUEST_RESPONSE: Response<Empty<Bytes>> = Response::from_parts(
    {
        let mut parts = Parts::new();
        parts.status = StatusCode::BAD_REQUEST;
        parts
    },
    Empty::<Bytes>::new(),
);
```

Author: Kriskras99

src/extensions.rs

@@ -41,7 +41,7 @@ pub struct Extensions {
 impl Extensions {
     /// Create an empty `Extensions`.
     #[inline]
-    pub fn new() -> Extensions {
+    pub const fn new() -> Extensions {
         Extensions { map: None }
     }
 

src/header/map.rs

@@ -45,7 +45,9 @@ pub use self::into_header_name::IntoHeaderName;
 pub struct HeaderMap<T = HeaderValue> {
     // Used to mask values to get an index
     mask: Size,
-    indices: Box<[Pos]>,
+    // Invariant: indices should not be grown, appended, truncated or shrunk.
+    // It should be a Box<[Pos]> but that is not const constructable.
+    indices: Vec<Pos>,
     entries: Vec<Bucket<T>>,
     extra_values: Vec<ExtraValue<T>>,
     danger: Danger,
@@ -446,16 +448,25 @@ impl HeaderMap {
     /// assert_eq!(0, map.capacity());
     /// ```
     #[inline]
-    pub fn new() -> Self {
-        Self::default()
+    pub const fn new() -> Self {
+        // Can't use HeaderMap::default as it's not const
+        HeaderMap {
+            mask: 0,
+            indices: Vec::new(),
+            entries: Vec::new(),
+            extra_values: Vec::new(),
+            danger: Danger::Green,
+        }
     }
 }
 
 impl<T> Default for HeaderMap<T> {
     fn default() -> Self {
+        // Can't use HeaderMap::new as it's only implemented for T = HeaderValue,
+        // widening its implementation would cause inference issues.
         HeaderMap {
             mask: 0,
-            indices: Box::new([]), // as a ZST, this doesn't actually allocate anything
+            indices: Vec::new(),
             entries: Vec::new(),
             extra_values: Vec::new(),
             danger: Danger::Green,
@@ -527,7 +538,7 @@ impl<T> HeaderMap<T> {
 
             Ok(HeaderMap {
                 mask: (raw_cap - 1) as Size,
-                indices: vec![Pos::none(); raw_cap].into_boxed_slice(),
+                indices: vec![Pos::none(); raw_cap],
                 entries: Vec::with_capacity(usable_capacity(raw_cap)),
                 extra_values: Vec::new(),
                 danger: Danger::Green,
@@ -726,7 +737,7 @@ impl<T> HeaderMap<T> {
 
             if self.entries.is_empty() {
                 self.mask = raw_cap as Size - 1;
-                self.indices = vec![Pos::none(); raw_cap].into_boxed_slice();
+                self.indices = vec![Pos::none(); raw_cap];
                 self.entries = Vec::with_capacity(usable_capacity(raw_cap));
             } else {
                 self.try_grow(raw_cap)?;
@@ -1727,7 +1738,7 @@ impl<T> HeaderMap<T> {
             if len == 0 {
                 let new_raw_cap = 8;
                 self.mask = 8 - 1;
-                self.indices = vec![Pos::none(); new_raw_cap].into_boxed_slice();
+                self.indices = vec![Pos::none(); new_raw_cap];
                 self.entries = Vec::with_capacity(usable_capacity(new_raw_cap));
             } else {
                 let raw_cap = self.indices.len();
@@ -1758,10 +1769,7 @@ impl<T> HeaderMap<T> {
 
         // visit the entries in an order where we can simply reinsert them
         // into self.indices without any bucket stealing.
-        let old_indices = mem::replace(
-            &mut self.indices,
-            vec![Pos::none(); new_raw_cap].into_boxed_slice(),
-        );
+        let old_indices = mem::replace(&mut self.indices, vec![Pos::none(); new_raw_cap]);
         self.mask = new_raw_cap.wrapping_sub(1) as Size;
 
         for &pos in &old_indices[first_ideal..] {

src/response.rs

@@ -186,7 +186,7 @@ pub struct Response<T> {
 ///
 /// The HTTP response head consists of a status, version, and a set of
 /// header fields.
-#[derive(Clone)]
+#[derive(Clone, Default)]
 #[non_exhaustive]
 pub struct Parts {
     /// The response's status
@@ -249,7 +249,7 @@ impl<T> Response<T> {
     /// assert_eq!(*response.body(), "hello world");
     /// ```
     #[inline]
-    pub fn new(body: T) -> Response<T> {
+    pub const fn new(body: T) -> Response<T> {
         Response {
             head: Parts::new(),
             body,
@@ -272,7 +272,7 @@ impl<T> Response<T> {
     /// assert_eq!(*response.body(), "hello world");
     /// ```
     #[inline]
-    pub fn from_parts(parts: Parts, body: T) -> Response<T> {
+    pub const fn from_parts(parts: Parts, body: T) -> Response<T> {
         Response { head: parts, body }
     }
 
@@ -286,7 +286,7 @@ impl<T> Response<T> {
     /// assert_eq!(response.status(), StatusCode::OK);
     /// ```
     #[inline]
-    pub fn status(&self) -> StatusCode {
+    pub const fn status(&self) -> StatusCode {
         self.head.status
     }
 
@@ -315,7 +315,7 @@ impl<T> Response<T> {
     /// assert_eq!(response.version(), Version::HTTP_11);
     /// ```
     #[inline]
-    pub fn version(&self) -> Version {
+    pub const fn version(&self) -> Version {
         self.head.version
     }
 
@@ -344,7 +344,7 @@ impl<T> Response<T> {
     /// assert!(response.headers().is_empty());
     /// ```
     #[inline]
-    pub fn headers(&self) -> &HeaderMap<HeaderValue> {
+    pub const fn headers(&self) -> &HeaderMap<HeaderValue> {
         &self.head.headers
     }
 
@@ -374,7 +374,7 @@ impl<T> Response<T> {
     /// assert!(response.extensions().get::<i32>().is_none());
     /// ```
     #[inline]
-    pub fn extensions(&self) -> &Extensions {
+    pub const fn extensions(&self) -> &Extensions {
         &self.head.extensions
     }
 
@@ -404,7 +404,7 @@ impl<T> Response<T> {
     /// assert!(response.body().is_empty());
     /// ```
     #[inline]
-    pub fn body(&self) -> &T {
+    pub const fn body(&self) -> &T {
         &self.body
     }
 
@@ -500,12 +500,12 @@ impl<T: fmt::Debug> fmt::Debug for Response<T> {
 
 impl Parts {
     /// Creates a new default instance of `Parts`
-    fn new() -> Parts {
+    pub const fn new() -> Parts {
         Parts {
             status: StatusCode::default(),
             version: Version::default(),
-            headers: HeaderMap::default(),
-            extensions: Extensions::default(),
+            headers: HeaderMap::new(),
+            extensions: Extensions::new(),
         }
     }
 }

src/status.rs

@@ -70,18 +70,17 @@ impl StatusCode {
     /// assert!(err.is_err());
     /// ```
     #[inline]
-    pub fn from_u16(src: u16) -> Result<StatusCode, InvalidStatusCode> {
-        if !(100..1000).contains(&src) {
-            return Err(InvalidStatusCode::new());
+    pub const fn from_u16(src: u16) -> Result<StatusCode, InvalidStatusCode> {
+        if matches!(src, 100..=999) {
+            if let Some(code) = NonZeroU16::new(src) {
+                return Ok(StatusCode(code));
+            }
         }
-
-        NonZeroU16::new(src)
-            .map(StatusCode)
-            .ok_or_else(InvalidStatusCode::new)
+        Err(InvalidStatusCode::new())
     }
 
     /// Converts a `&[u8]` to a status code.
-    pub fn from_bytes(src: &[u8]) -> Result<StatusCode, InvalidStatusCode> {
+    pub const fn from_bytes(src: &[u8]) -> Result<StatusCode, InvalidStatusCode> {
         if src.len() != 3 {
             return Err(InvalidStatusCode::new());
         }
@@ -95,9 +94,11 @@ impl StatusCode {
         }
 
         let status = (a * 100) + (b * 10) + c;
-        NonZeroU16::new(status)
-            .map(StatusCode)
-            .ok_or_else(InvalidStatusCode::new)
+        if let Some(code) = NonZeroU16::new(status) {
+            Ok(StatusCode(code))
+        } else {
+            Err(InvalidStatusCode::new())
+        }
     }
 
     /// Returns the `u16` corresponding to this `StatusCode`.
@@ -168,38 +169,47 @@ impl StatusCode {
     /// let status = http::StatusCode::OK;
     /// assert_eq!(status.canonical_reason(), Some("OK"));
     /// ```
-    pub fn canonical_reason(&self) -> Option<&'static str> {
+    pub const fn canonical_reason(&self) -> Option<&'static str> {
         canonical_reason(self.0.get())
     }
 
     /// Check if status is within 100-199.
     #[inline]
-    pub fn is_informational(&self) -> bool {
-        (100..200).contains(&self.0.get())
+    pub const fn is_informational(&self) -> bool {
+        matches!(self.0.get(), 100..=199)
     }
 
     /// Check if status is within 200-299.
     #[inline]
-    pub fn is_success(&self) -> bool {
-        (200..300).contains(&self.0.get())
+    pub const fn is_success(&self) -> bool {
+        matches!(self.0.get(), 200..=299)
     }
 
     /// Check if status is within 300-399.
     #[inline]
-    pub fn is_redirection(&self) -> bool {
-        (300..400).contains(&self.0.get())
+    pub const fn is_redirection(&self) -> bool {
+        matches!(self.0.get(), 300..=399)
     }
 
     /// Check if status is within 400-499.
     #[inline]
-    pub fn is_client_error(&self) -> bool {
-        (400..500).contains(&self.0.get())
+    pub const fn is_client_error(&self) -> bool {
+        matches!(self.0.get(), 400..=499)
     }
 
     /// Check if status is within 500-599.
     #[inline]
-    pub fn is_server_error(&self) -> bool {
-        (500..600).contains(&self.0.get())
+    pub const fn is_server_error(&self) -> bool {
+        matches!(self.0.get(), 500..=599)
+    }
+
+    /// Returns the "default value" for a type.
+    ///
+    /// This is implemented as an associated function in addition
+    /// to the [`Default`] trait, to allow `const` usage.
+    #[inline]
+    pub const fn default() -> StatusCode {
+        StatusCode::OK
     }
 }
 
@@ -231,7 +241,7 @@ impl fmt::Display for StatusCode {
 impl Default for StatusCode {
     #[inline]
     fn default() -> StatusCode {
-        StatusCode::OK
+        StatusCode::default()
     }
 }
 
@@ -313,7 +323,7 @@ macro_rules! status_codes {
 
         }
 
-        fn canonical_reason(num: u16) -> Option<&'static str> {
+        const fn canonical_reason(num: u16) -> Option<&'static str> {
             match num {
                 $(
                 $num => Some($phrase),
@@ -523,7 +533,7 @@ status_codes! {
 }
 
 impl InvalidStatusCode {
-    fn new() -> InvalidStatusCode {
+    const fn new() -> InvalidStatusCode {
         InvalidStatusCode { _priv: () }
     }
 }

src/version.rs

@@ -40,6 +40,14 @@ impl Version {
 
     /// `HTTP/3.0`
     pub const HTTP_3: Version = Version(Http::H3);
+
+    /// Returns the "default value" for a type.
+    ///
+    /// This is implemented as an associated function in addition
+    /// to the [`Default`] trait, to allow `const` usage.
+    pub const fn default() -> Version {
+        Version::HTTP_11
+    }
 }
 
 #[derive(PartialEq, PartialOrd, Copy, Clone, Eq, Ord, Hash)]
@@ -55,7 +63,7 @@ enum Http {
 impl Default for Version {
     #[inline]
     fn default() -> Version {
-        Version::HTTP_11
+        Version::default()
     }
 }