`HeaderName` implements `Borrow<str>` but doesn't hash like `str`

[paullegranddc]

Issue

HeaderName implements Borrow<str>, but it's Hash implementation can give different results compared to hashing the string we receive from calling borrow() on it.

Example :

let build_hasher = BuildHasherDefault::<DefaultHasher>::default();

let accept_charset = http::header::ACCEPT_CHARSET;
let borrowed: &str = accept_charset.borrow();
assert!(borrowed == "accept-charset");
assert!(build_hasher.hash_one(borrowed) != build_hasher.hash_one(accept_charset));

This is unexpected, as the stdlib documentation for Borrow says

In particular Eq, Ord and Hash must be equivalent for borrowed and owned values

This causes issues if you put a HeaderName as the key of a "normal" hashmap, because indexing by &str will compile, but be a bug since the hash don't match.

Potential fix

Either:

• add a custom Hash implementation for HeaderName that hashes to the str value of the header

impl Hash for HeaderName {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.as_str().hash(state);
    }
}

• remove the Borrow trait implementation. As mentioned in the stdlib documentation, AsRef is sufficient if the guarantees that Borrow should gives cannot be respected. Of course that would be a breaking change...

[seanmonstar]

Hm, that's unfortunate. I think we never should have implemented Borrow in the first place. The purpose of the type is to be able to compare and hash faster on more common headers. So, I don't want to make those variants slower. But removing the implementation would be a breaking change. I'm not sure there's a fix.

[paullegranddc]

I ran the header_map benchmarks (locally, so deltas are a bit random sometimes as I had other stuff running) between the current baseline, and a branch where I replace the default Hash for HeaderName to something that hashes the string value.

Positive delta means the "string hash" variant is slower.

Almost all benches hashing standard headers are slower (up to 30% slower). I guess the default fieldless enum hash just writes the integer discriminant which is always faster than hashing a string ☹️

Benchmark                                      [header_map] 
------------------------------------------------------------
basic::get_100_std                                    -0.3% 
basic::get_10_custom_short                            -2.4% 
basic::get_10_of_20_std                               -0.9% 
basic::hn_hdrs_set_11_get_with_miss                  +12.5% 
basic::hn_hdrs_set_8_get_many                        +14.2% 
basic::hn_hdrs_set_8_get_miss                        +19.4% 
basic::insert_100_custom_headers                      -1.2% 
basic::insert_4_std_get_30                            +5.9% 
basic::insert_500_custom_headers                      +2.3% 
basic::insert_6_std_get_6                            +19.9% 
basic::insert_79_custom_std_headers                   -0.4% 
basic::insert_all_std_headers                        +34.6% 
basic::insert_one_100_char_header                     +3.7% 
basic::insert_one_15_char_header                     +17.8% 
basic::insert_one_25_char_header                     +17.3% 
basic::insert_one_50_char_header                     +18.5% 
basic::new_insert_get_host                            +5.7% 
basic::set_10_get_1_custom_long                      +12.8% 
basic::set_10_get_1_custom_med                        +1.9% 
basic::set_10_get_1_custom_short                      +6.8% 
basic::set_10_get_1_custom_very_long                  +6.0% 
basic::set_10_get_1_std                              +22.7% 
basic::set_20_get_1_custom_long                      +18.5% 
basic::set_20_get_1_custom_med                       -12.1% 
basic::set_20_get_1_custom_short                      +2.2% 
basic::set_20_get_1_custom_very_long                  -1.8% 
basic::set_20_get_1_std                              +27.2% 
basic::set_8_get_1_std                               +22.4%