Upgrade to 2018 Edition (#331)

* 2018 edition, babey!

* run `cargo fix --edition-idioms`

* yes, we do intend to drop the iterator, thanks rustc!

* cargo fmt

* aggressive min rustc version bump to fix travis

* 1.37 is not out, oops

Author: davidbarsky

.travis.yml

@@ -14,7 +14,7 @@ matrix:
         - rustup target add wasm32-unknown-unknown
         - cargo build --target=wasm32-unknown-unknown
     # minimum rustc version
-    - rust: 1.30.0
+    - rust: 1.36.0
       script: cargo build
 
 script:

Cargo.toml

@@ -20,6 +20,7 @@ A set of types for representing HTTP requests and responses.
 """
 keywords = ["http"]
 categories = ["web-programming"]
+edition = "2018"
 
 # 0.2.x isn't ready just yet
 publish = false

benches/header_map/basic.rs

@@ -2,13 +2,13 @@ macro_rules! bench {
     ($name:ident($map:ident, $b:ident) $body:expr) => {
         mod $name {
             #[allow(unused_imports)]
-            use test::{self, Bencher};
-            use seahash::SeaHasher;
+            use super::custom_hdr;
             use fnv::FnvHasher;
-            use std::hash::BuildHasherDefault;
             use http::header::*;
+            use seahash::SeaHasher;
+            use std::hash::BuildHasherDefault;
             #[allow(unused_imports)]
-            use super::custom_hdr;
+            use test::{self, Bencher};
 
             #[bench]
             fn header_map($b: &mut Bencher) {
@@ -25,7 +25,7 @@ macro_rules! bench {
 
             #[bench]
             fn vec_map($b: &mut Bencher) {
-                use vec_map::VecMap;
+                use crate::vec_map::VecMap;
 
                 let $map = || VecMap::with_capacity(0);
                 $body
@@ -208,7 +208,6 @@ bench!(set_10_get_1_custom_short(new_map, b) {
     })
 });
 
-
 bench!(set_10_get_1_custom_med(new_map, b) {
     let hdrs = super::med_custom_hdr(10);
 
@@ -474,38 +473,48 @@ bench!(hn_hdrs_set_11_get_with_miss(new_map, b) {
 use http::header::*;
 
 fn custom_hdr(n: usize) -> Vec<HeaderName> {
-    (0..n).map(|i| {
-        let s = format!("x-custom-{}", i);
-        s.parse().unwrap()
-    }).collect()
+    (0..n)
+        .map(|i| {
+            let s = format!("x-custom-{}", i);
+            s.parse().unwrap()
+        })
+        .collect()
 }
 
 fn med_custom_hdr(n: usize) -> Vec<HeaderName> {
-    (0..n).map(|i| {
-        let s = format!("content-length-{}", i);
-        s.parse().unwrap()
-    }).collect()
+    (0..n)
+        .map(|i| {
+            let s = format!("content-length-{}", i);
+            s.parse().unwrap()
+        })
+        .collect()
 }
 
 fn long_custom_hdr(n: usize) -> Vec<HeaderName> {
-    (0..n).map(|i| {
-        let s = format!("access-control-allow-headers-{}", i);
-        s.parse().unwrap()
-    }).collect()
+    (0..n)
+        .map(|i| {
+            let s = format!("access-control-allow-headers-{}", i);
+            s.parse().unwrap()
+        })
+        .collect()
 }
 
 fn very_long_custom_hdr(n: usize) -> Vec<HeaderName> {
-    (0..n).map(|i| {
-        let s = format!("access-control-allow-access-control-allow-headers-{}", i);
-        s.parse().unwrap()
-    }).collect()
+    (0..n)
+        .map(|i| {
+            let s = format!("access-control-allow-access-control-allow-headers-{}", i);
+            s.parse().unwrap()
+        })
+        .collect()
 }
 
 fn custom_std(n: usize) -> Vec<HeaderName> {
-    (0..n).map(|i| {
-        let s = format!("{}-{}", STD[i % STD.len()].as_str(), i);
-        s.parse().unwrap()
-    }).collect()
+    (0..n)
+        .map(|i| {
+            let s = format!("{}-{}", STD[i % STD.len()].as_str(), i);
+            s.parse().unwrap()
+        })
+        .collect()
 }
 
 const STD: &'static [HeaderName] = &[

benches/header_map/mod.rs

@@ -1,10 +1,6 @@
 #![feature(test)]
 
-extern crate http;
 extern crate test;
-extern crate indexmap;
-extern crate seahash;
-extern crate fnv;
 
 mod basic;
 mod vec_map;

benches/header_map/vec_map.rs

@@ -9,20 +9,20 @@ impl<K: PartialEq, V> VecMap<K, V> {
     #[inline]
     pub fn with_capacity(cap: usize) -> VecMap<K, V> {
         VecMap {
-            vec: Vec::with_capacity(cap)
+            vec: Vec::with_capacity(cap),
         }
     }
 
     #[inline]
     pub fn insert(&mut self, key: K, value: V) {
         match self.find(&key) {
             Some(pos) => self.vec[pos] = (key, value),
-            None => self.vec.push((key, value))
+            None => self.vec.push((key, value)),
         }
     }
 
     #[inline]
-    pub fn entry(&mut self, key: K) -> Entry<K, V> {
+    pub fn entry(&mut self, key: K) -> Entry<'_, K, V> {
         match self.find(&key) {
             Some(pos) => Entry::Occupied(OccupiedEntry {
                 vec: self,
@@ -31,7 +31,7 @@ impl<K: PartialEq, V> VecMap<K, V> {
             None => Entry::Vacant(VacantEntry {
                 vec: self,
                 key: key,
-            })
+            }),
         }
     }
 
@@ -51,15 +51,19 @@ impl<K: PartialEq, V> VecMap<K, V> {
     }
 
     #[inline]
-    pub fn len(&self) -> usize { self.vec.len() }
+    pub fn len(&self) -> usize {
+        self.vec.len()
+    }
 
     #[inline]
-    pub fn iter(&self) -> ::std::slice::Iter<(K, V)> {
+    pub fn iter(&self) -> ::std::slice::Iter<'_, (K, V)> {
         self.vec.iter()
     }
     #[inline]
     pub fn remove<K2: PartialEq<K> + ?Sized>(&mut self, key: &K2) -> Option<V> {
-        self.find(key).map(|pos| self.vec.remove(pos)).map(|(_, v)| v)
+        self.find(key)
+            .map(|pos| self.vec.remove(pos))
+            .map(|(_, v)| v)
     }
     #[inline]
     pub fn clear(&mut self) {
@@ -74,10 +78,10 @@ impl<K: PartialEq, V> VecMap<K, V> {
 
 pub enum Entry<'a, K: 'a, V: 'a> {
     Vacant(VacantEntry<'a, K, V>),
-    Occupied(OccupiedEntry<'a, K, V>)
+    Occupied(OccupiedEntry<'a, K, V>),
 }
 
-pub struct VacantEntry<'a, K: 'a, V: 'a> {
+pub struct VacantEntry<'a, K, V> {
     vec: &'a mut VecMap<K, V>,
     key: K,
 }
@@ -91,7 +95,7 @@ impl<'a, K, V> VacantEntry<'a, K, V> {
     }
 }
 
-pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
+pub struct OccupiedEntry<'a, K, V> {
     vec: &'a mut VecMap<K, V>,
     pos: usize,
 }

benches/header_value.rs

@@ -1,7 +1,5 @@
 #![feature(test)]
 
-extern crate bytes;
-extern crate http;
 extern crate test;
 
 use bytes::Bytes;
@@ -11,7 +9,6 @@ use test::Bencher;
 static SHORT: &'static [u8] = b"localhost";
 static LONG: &'static [u8] = b"Mozilla/5.0 (X11; CrOS x86_64 9592.71.0) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/60.0.3112.80 Safari/537.36";
 
-
 #[bench]
 fn from_shared_short(b: &mut Bencher) {
     b.bytes = SHORT.len() as u64;
@@ -30,25 +27,20 @@ fn from_shared_long(b: &mut Bencher) {
     });
 }
 
-
 #[bench]
 fn from_shared_unchecked_short(b: &mut Bencher) {
     b.bytes = SHORT.len() as u64;
     let bytes = Bytes::from_static(SHORT);
-    b.iter(|| {
-        unsafe {
-            HeaderValue::from_shared_unchecked(bytes.clone());
-        }
+    b.iter(|| unsafe {
+        HeaderValue::from_shared_unchecked(bytes.clone());
     });
 }
 
 #[bench]
 fn from_shared_unchecked_long(b: &mut Bencher) {
     b.bytes = LONG.len() as u64;
     let bytes = Bytes::from_static(LONG);
-    b.iter(|| {
-        unsafe {
-            HeaderValue::from_shared_unchecked(bytes.clone());
-        }
+    b.iter(|| unsafe {
+        HeaderValue::from_shared_unchecked(bytes.clone());
     });
 }

benches/uri.rs

@@ -1,6 +1,5 @@
 #![feature(test)]
 
-extern crate http;
 extern crate test;
 
 use http::Uri;

src/byte_str.rs

@@ -10,20 +10,27 @@ pub(crate) struct ByteStr {
 impl ByteStr {
     #[inline]
     pub fn new() -> ByteStr {
-        ByteStr { bytes: Bytes::new() }
+        ByteStr {
+            bytes: Bytes::new(),
+        }
     }
 
     #[inline]
     pub fn from_static(val: &'static str) -> ByteStr {
-        ByteStr { bytes: Bytes::from_static(val.as_bytes()) }
+        ByteStr {
+            bytes: Bytes::from_static(val.as_bytes()),
+        }
     }
 
     #[inline]
     pub unsafe fn from_utf8_unchecked(bytes: Bytes) -> ByteStr {
         if cfg!(debug_assertions) {
             match str::from_utf8(&bytes) {
                 Ok(_) => (),
-                Err(err) => panic!("ByteStr::from_utf8_unchecked() with invalid bytes; error = {}, bytes = {:?}", err, bytes),
+                Err(err) => panic!(
+                    "ByteStr::from_utf8_unchecked() with invalid bytes; error = {}, bytes = {:?}",
+                    err, bytes
+                ),
             }
         }
         ByteStr { bytes: bytes }
@@ -43,14 +50,18 @@ impl ops::Deref for ByteStr {
 impl From<String> for ByteStr {
     #[inline]
     fn from(src: String) -> ByteStr {
-        ByteStr { bytes: Bytes::from(src) }
+        ByteStr {
+            bytes: Bytes::from(src),
+        }
     }
 }
 
 impl<'a> From<&'a str> for ByteStr {
     #[inline]
     fn from(src: &'a str) -> ByteStr {
-        ByteStr { bytes: Bytes::from(src) }
+        ByteStr {
+            bytes: Bytes::from(src),
+        }
     }
 }
 

src/convert.rs

@@ -1,9 +1,9 @@
-use Error;
-use header::{HeaderName, HeaderValue};
-use method::Method;
-use sealed::Sealed;
-use status::StatusCode;
-use uri::{Scheme, Authority, PathAndQuery, Uri};
+use crate::header::{HeaderName, HeaderValue};
+use crate::method::Method;
+use crate::sealed::Sealed;
+use crate::status::StatusCode;
+use crate::uri::{Authority, PathAndQuery, Scheme, Uri};
+use crate::Error;
 
 /// Private trait for the `http` crate to have generic methods with fallible
 /// conversions.
@@ -33,8 +33,7 @@ where
     T: Sized,
 {
     fn http_try_into(self) -> Result<U, Error> {
-        HttpTryFrom::try_from(self)
-            .map_err(|e: U::Error| e.into())
+        HttpTryFrom::try_from(self).map_err(|e: U::Error| e.into())
     }
 }