refactor: avoid unnecessary .expect()s for empty HeaderMap (#768)

* Avoid unnecessary .expect()s for empty HeaderMap

This change removes the Result::expect() calls in the constructors for
an empty HeaderMap. These calls were provably not going to fail at
runtime but rustc's inliner wasn't smart enough to figure that out:
strings analysis of compiled binaries showed that the error message to
the expect() still showed up in generated code.

There are no behavioral differences as a result of this change.

* Move new_empty() body into `Default` impl

This gives us one fewer named method since we can use default() in place
of new_empty(). It preserves the property that `HeaderMap::new()`
constrains the generic type to `T=HeaderValue`.

Author: akonradi-signal

src/header/map.rs

@@ -445,8 +445,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 +514,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 +2171,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,