Merge pull request #403 from hyperium/stabilize

Remove box_syntax and collections feature gates

src/client/request.rs

@@ -57,7 +57,7 @@ impl Request<Fresh> {
 
         let stream = try!(connector.connect(&*host, port, &*url.scheme));
         // FIXME: Use Type ascription
-        let stream: Box<NetworkStream + Send> = box stream;
+        let stream: Box<NetworkStream + Send> = Box::new(stream);
         let stream = ThroughWriter(BufWriter::new(stream));
 
         let mut headers = Headers::new();

src/client/response.rs

@@ -130,13 +130,13 @@ mod tests {
             status: status::StatusCode::Ok,
             headers: Headers::new(),
             version: version::HttpVersion::Http11,
-            body: EofReader(BufReader::new(box MockStream::new())),
+            body: EofReader(BufReader::new(Box::new(MockStream::new()))),
             status_raw: RawStatus(200, Borrowed("OK")),
             _marker: PhantomData,
         };
 
         let b = res.into_inner().downcast::<MockStream>().ok().unwrap();
-        assert_eq!(b, box MockStream::new());
+        assert_eq!(b, Box::new(MockStream::new()));
 
     }
 
@@ -156,7 +156,7 @@ mod tests {
             \r\n"
         );
 
-        let res = Response::new(box stream).unwrap();
+        let res = Response::new(Box::new(stream)).unwrap();
 
         // The status line is correct?
         assert_eq!(res.status, status::StatusCode::Ok);
@@ -187,7 +187,7 @@ mod tests {
             \r\n"
         );
 
-        let res = Response::new(box stream).unwrap();
+        let res = Response::new(Box::new(stream)).unwrap();
 
         assert!(read_to_string(res).is_err());
     }
@@ -206,7 +206,7 @@ mod tests {
             \r\n"
         );
 
-        let res = Response::new(box stream).unwrap();
+        let res = Response::new(Box::new(stream)).unwrap();
 
         assert!(read_to_string(res).is_err());
     }
@@ -225,7 +225,7 @@ mod tests {
             \r\n"
         );
 
-        let res = Response::new(box stream).unwrap();
+        let res = Response::new(Box::new(stream)).unwrap();
 
         assert_eq!(read_to_string(res), Ok("1".to_string()));
     }

src/header/internals/item.rs

@@ -85,7 +85,7 @@ impl Item {
 fn parse<H: Header + HeaderFormat>(raw: &Vec<Vec<u8>>) -> Option<Box<HeaderFormat + Send + Sync>> {
     Header::parse_header(&raw[..]).map(|h: H| {
         // FIXME: Use Type ascription
-        let h: Box<HeaderFormat + Send + Sync> = box h;
+        let h: Box<HeaderFormat + Send + Sync> = Box::new(h);
         h
     })
 }

src/header/mod.rs

@@ -356,11 +356,21 @@ mod tests {
 
     use test::Bencher;
 
+    // Slice.position_elem is unstable
+    fn index_of(slice: &[u8], byte: u8) -> Option<usize> {
+        for (index, &b) in slice.iter().enumerate() {
+            if b == byte {
+                return Some(index);
+            }
+        }
+        None
+    }
+
     macro_rules! raw {
         ($($line:expr),*) => ({
             [$({
                 let line = $line;
-                let pos = line.position_elem(&b':').expect("raw splits on :, not found");
+                let pos = index_of(line, b':').expect("raw splits on ':', not found");
                 httparse::Header {
                     name: ::std::str::from_utf8(&line[..pos]).unwrap(),
                     value: &line[pos + 2..]

src/header/shared/entity.rs

@@ -47,29 +47,29 @@ impl FromStr for EntityTag {
         // Early exits:
         // 1. The string is empty, or,
         // 2. it doesn't terminate in a DQUOTE.
-        if slice.is_empty() || !slice.ends_with("\"") {
+        if slice.is_empty() || !slice.ends_with('"') {
             return Err(());
         }
 
         // The etag is weak if its first char is not a DQUOTE.
-        if slice.chars().next().unwrap() == '"' /* '"' */ {
+        if slice.starts_with('"') /* '"' */ {
             // No need to check if the last char is a DQUOTE,
             // we already did that above.
-            if check_slice_validity(slice.slice_chars(1, length-1)) {
+            if check_slice_validity(&slice[1..length-1]) {
                 return Ok(EntityTag {
                     weak: false,
-                    tag: slice.slice_chars(1, length-1).to_string()
+                    tag: slice[1..length-1].to_string()
                 });
             } else {
                 return Err(());
             }
         }
 
-        if slice.slice_chars(0, 3) == "W/\"" {
-            if check_slice_validity(slice.slice_chars(3, length-1)) {
+        if slice.starts_with("W/\"") {
+            if check_slice_validity(&slice[3..length-1]) {
                 return Ok(EntityTag {
                     weak: true,
-                    tag: slice.slice_chars(3, length-1).to_string()
+                    tag: slice[3..length-1].to_string()
                 });
             } else {
                 return Err(());

src/lib.rs

@@ -1,6 +1,5 @@
 #![doc(html_root_url = "https://hyperium.github.io/hyper/hyper/index.html")]
-#![feature(core, collections, io,
-           box_syntax, unsafe_destructor, into_cow, convert)]
+#![feature(core, io, unsafe_destructor, into_cow, convert)]
 #![deny(missing_docs)]
 #![cfg_attr(test, deny(warnings))]
 #![cfg_attr(test, feature(alloc, test))]

src/net.rs

@@ -355,20 +355,20 @@ mod tests {
     #[test]
     fn test_downcast_box_stream() {
         // FIXME: Use Type ascription
-        let stream: Box<NetworkStream + Send> = box MockStream::new();
+        let stream: Box<NetworkStream + Send> = Box::new(MockStream::new());
 
         let mock = stream.downcast::<MockStream>().ok().unwrap();
-        assert_eq!(mock, box MockStream::new());
+        assert_eq!(mock, Box::new(MockStream::new()));
 
     }
 
     #[test]
     fn test_downcast_unchecked_box_stream() {
         // FIXME: Use Type ascription
-        let stream: Box<NetworkStream + Send> = box MockStream::new();
+        let stream: Box<NetworkStream + Send> = Box::new(MockStream::new());
 
         let mock = unsafe { stream.downcast_unchecked::<MockStream>() };
-        assert_eq!(mock, box MockStream::new());
+        assert_eq!(mock, Box::new(MockStream::new()));
 
     }
 

src/server/listener.rs

@@ -1,6 +1,5 @@
 use std::thread::{self, JoinGuard};
 use std::sync::mpsc;
-use std::collections::VecMap;
 use net::NetworkListener;
 
 pub struct ListenerPool<A: NetworkListener> {
@@ -24,22 +23,16 @@ impl<'a, A: NetworkListener + Send + 'a> ListenerPool<A> {
 
         let (super_tx, supervisor_rx) = mpsc::channel();
 
-        let counter = &mut 0;
         let work = &work;
-        let mut spawn = move || {
-            let id = *counter;
-            let guard = spawn_with(super_tx.clone(), work, self.acceptor.clone(), id);
-            *counter += 1;
-            (id, guard)
+        let spawn = move |id| {
+            spawn_with(super_tx.clone(), work, self.acceptor.clone(), id)
         };
 
         // Go
-        let mut guards: VecMap<_> = (0..threads).map(|_| spawn()).collect();
+        let mut guards: Vec<_> = (0..threads).map(|id| spawn(id)).collect();
 
         for id in supervisor_rx.iter() {
-            guards.remove(&id);
-            let (id, guard) = spawn();
-            guards.insert(id, guard);
+            guards[id] = spawn(id);
         }
     }
 }