re-export HeaderMap, HeaderName, HeaderValue under their names from http crate

and get rid of the aliases. this crate doesnt even expose trailers, when we do it can
just be a method called trailers(&self) -> &HeaderMap, no big deal.

Author: pchickey

src/http/fields.rs

@@ -1,25 +1,24 @@
-pub use http::header::{HeaderMap as Fields, HeaderName as FieldName, HeaderValue as FieldValue};
-pub type Headers = Fields;
-pub type Trailers = Fields;
+pub use http::header::{HeaderMap, HeaderName, HeaderValue};
 
 use super::{Error, Result};
-use wasi::http::types::Fields as WasiFields;
+use wasi::http::types::Fields;
 
-pub(crate) fn fields_from_wasi(wasi_fields: WasiFields) -> Result<Fields> {
-    let mut output = Fields::new();
+pub(crate) fn header_map_from_wasi(wasi_fields: Fields) -> Result<HeaderMap> {
+    let mut output = HeaderMap::new();
     for (key, value) in wasi_fields.entries() {
-        let key = FieldName::from_bytes(key.as_bytes())
+        let key = HeaderName::from_bytes(key.as_bytes())
             .map_err(|e| Error::from(e).context("header name {key}"))?;
-        let value = FieldValue::from_bytes(&value)
+        let value = HeaderValue::from_bytes(&value)
             .map_err(|e| Error::from(e).context("header value for {key}"))?;
         output.append(key, value);
     }
     Ok(output)
 }
 
-pub(crate) fn fields_to_wasi(fields: &Fields) -> Result<WasiFields> {
-    let wasi_fields = WasiFields::new();
-    for (key, value) in fields {
+#[allow(dead_code)]
+pub(crate) fn header_map_to_wasi(header_map: &HeaderMap) -> Result<Fields> {
+    let wasi_fields = Fields::new();
+    for (key, value) in header_map {
         wasi_fields
             .append(&key.as_str().to_owned(), &value.as_bytes().to_owned())
             .map_err(|e| Error::from(e).context("header named {key}"))?;

src/http/mod.rs

@@ -6,13 +6,13 @@ pub use http::uri::Uri;
 pub use body::{Body, IntoBody};
 pub use client::Client;
 pub use error::{Error, Result};
-pub use fields::{FieldName, FieldValue, Fields, Headers, Trailers};
+pub use fields::{HeaderMap, HeaderName, HeaderValue};
 pub use method::Method;
 pub use request::Request;
 pub use response::Response;
 pub use status_code::StatusCode;
 
-pub(crate) use fields::fields_from_wasi;
+pub(crate) use fields::header_map_from_wasi;
 
 pub mod body;
 

src/http/response.rs

@@ -1,7 +1,7 @@
 use wasi::http::types::{IncomingBody as WasiIncomingBody, IncomingResponse};
 use wasi::io::streams::{InputStream, StreamError};
 
-use super::{fields_from_wasi, Body, Headers, StatusCode};
+use super::{header_map_from_wasi, Body, HeaderMap, StatusCode};
 use crate::io::AsyncRead;
 use crate::runtime::Reactor;
 
@@ -11,7 +11,7 @@ const CHUNK_SIZE: u64 = 2048;
 /// An HTTP response
 #[derive(Debug)]
 pub struct Response<B: Body> {
-    headers: Headers,
+    headers: HeaderMap,
     status: StatusCode,
     body: B,
 }
@@ -46,7 +46,7 @@ pub struct Response<B: Body> {
 
 impl Response<IncomingBody> {
     pub(crate) fn try_from_incoming_response(incoming: IncomingResponse) -> super::Result<Self> {
-        let headers: Headers = fields_from_wasi(incoming.headers())?;
+        let headers: HeaderMap = header_map_from_wasi(incoming.headers())?;
         let status = incoming.status().into();
 
         // `body_stream` is a child of `incoming_body` which means we cannot
@@ -80,12 +80,12 @@ impl<B: Body> Response<B> {
     }
 
     /// Get the HTTP headers from the impl
-    pub fn headers(&self) -> &Headers {
+    pub fn headers(&self) -> &HeaderMap {
         &self.headers
     }
 
     /// Mutably get the HTTP headers from the impl
-    pub fn headers_mut(&mut self) -> &mut Headers {
+    pub fn headers_mut(&mut self) -> &mut HeaderMap {
         &mut self.headers
     }