Update to rust master

Author: alexcrichton

Cargo.lock

@@ -1 +1 @@
-2015-03-14
+2015-03-18

RUSTVERSION

@@ -43,7 +43,7 @@ fn update(tx: &postgres::Transaction) -> postgres::Result<()> {
         let mut rng = StdRng::new().unwrap();
         let mut dls = rng.gen_range(5000i32, 10000);
 
-        for day in range(0, 90) {
+        for day in 0..90 {
             let moment = now + Duration::days(-day);
             dls += rng.gen_range(-100, 100);
             try!(tx.execute("INSERT INTO version_downloads \

src/bin/populate.rs

@@ -111,7 +111,7 @@ fn commit_and_push<F>(repo: &git2::Repository, mut f: F) -> CargoResult<()>
     // rebase our repository, and after that it's possible that we're going to
     // race to commit the changes. For now we just cap out the maximum number of
     // retries at a fixed number.
-    for _ in range(0, 20) {
+    for _ in 0..20 {
         let (msg, dst) = try!(f());
 
         // git add $file
@@ -154,10 +154,10 @@ fn commit_and_push<F>(repo: &git2::Repository, mut f: F) -> CargoResult<()>
 
         // Ok, we need to update, so fetch and reset --hard
         try!(origin.add_fetch("refs/heads/*:refs/heads/*"));
-        try!(origin.fetch(&[], None, None));
+        try!(origin.fetch(&[], None));
         let head = try!(repo.head()).target().unwrap();
         let obj = try!(repo.find_object(head, None));
-        try!(repo.reset(&obj, git2::ResetType::Hard, None, None, None));
+        try!(repo.reset(&obj, git2::ResetType::Hard, None));
     }
 
     Err(internal("Too many rebase failures"))

src/git.rs

@@ -1,4 +1,4 @@
-#![feature(collections, core, std_misc, io, net)]
+#![feature(collections, core, std_misc, io)]
 
 #[macro_use] extern crate log;
 extern crate "postgres" as pg;

src/lib.rs

@@ -1,5 +1,5 @@
 #![deny(warnings)]
-#![feature(io, core, net, path_ext)]
+#![feature(io, core, path_ext)]
 
 extern crate "cargo-registry" as cargo_registry;
 extern crate "conduit-middleware" as conduit_middleware;

src/tests/all.rs

@@ -33,7 +33,7 @@ impl Write for Sink {
 impl Drop for Bomb {
     fn drop(&mut self) {
         t!(self.quit.send(()));
-        drop(TcpStream::connect(&t!(self.accept.socket_addr())));
+        drop(TcpStream::connect(&t!(self.accept.local_addr())));
         let res = self.rx.recv();
         let stderr = str::from_utf8(&self.iorx.0.lock().unwrap()).unwrap()
                          .to_string();
@@ -55,7 +55,7 @@ pub fn proxy() -> (String, Bomb) {
     let record = env::var("RECORD").is_ok();
 
     let a = t!(TcpListener::bind("127.0.0.1:0"));
-    let ret = format!("http://{}", t!(a.socket_addr()));
+    let ret = format!("http://{}", t!(a.local_addr()));
     let (tx, rx) = channel();
 
     let data = PathBuf::new(file!()).parent().unwrap().join("http-data")
@@ -188,7 +188,7 @@ fn replay_http(socket: TcpStream, data: &mut BufStream<File>,
 
     let mut expected = Vec::new();
     t!(data.take(request_size).read_to_end(&mut expected));
-    let mut expected_lines = SliceExt::split(&expected[..], |b| *b == b'\n')
+    let mut expected_lines = <[_]>::split(&expected[..], |b| *b == b'\n')
                                      .map(|s| str::from_utf8(s).unwrap())
                                      .map(|s| format!("{}", s));
     let mut actual_lines = socket.lines().map(|s| s.unwrap());
@@ -223,7 +223,7 @@ fn replay_http(socket: TcpStream, data: &mut BufStream<File>,
     let response_size = response.next().unwrap().trim().parse().unwrap();
     let mut response = Vec::new();
     data.take(response_size).read_to_end(&mut response).unwrap();
-    let lines = SliceExt::split(&response[..], |b| *b == b'\n')
+    let lines = <[_]>::split(&response[..], |b| *b == b'\n')
                         .map(|s| str::from_utf8(s).unwrap());
     for line in lines {
         if line.starts_with("Date:") { continue }

src/tests/record.rs

@@ -1,5 +1,5 @@
 use std::io::Read;
-use std::net::IpAddr;
+use std::net::SocketAddr;
 
 use conduit;
 use conduit::Request;
@@ -32,7 +32,7 @@ impl<'a> Request for RequestProxy<'a> {
     fn query_string(&self) -> Option<&str> {
         self.other.query_string()
     }
-    fn remote_ip(&self) -> IpAddr { self.other.remote_ip() }
+    fn remote_addr(&self) -> SocketAddr { self.other.remote_addr() }
     fn content_length(&self) -> Option<u64> {
         self.other.content_length()
     }