Update to rust master

Author: alexcrichton

Cargo.lock

@@ -3,9 +3,10 @@ extern crate "conduit-middleware" as conduit_middleware;
 extern crate civet;
 extern crate git2;
 
+use std::io::{self, fs, File};
 use std::os;
 use std::sync::Arc;
-use std::io::{mod, fs, File};
+use std::sync::mpsc::channel;
 use civet::Server;
 
 fn main() {
@@ -68,7 +69,7 @@ fn main() {
 
     // TODO: handle a graceful shutdown by just waiting for a SIG{INT,TERM}
     let (_tx, rx) = channel::<()>();
-    rx.recv();
+    rx.recv().unwrap();
 }
 
 fn env(s: &str) -> String {

src/bin/server.rs

@@ -1,4 +1,4 @@
-#[deriving(Clone)]
+#[derive(Clone)]
 pub struct Config {
     pub s3_bucket: String,
     pub s3_region: Option<String>,

src/config.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use pg;
 use pg::types::ToSql;
-use r2d2::{mod, LoggingErrorHandler};
+use r2d2::{self, LoggingErrorHandler};
 use r2d2_postgres::{PostgresPoolManager, Error};
 use conduit::{Request, Response};
 use conduit_middleware::Middleware;

src/db.rs

@@ -1,3 +1,5 @@
+use std::num::FromPrimitive;
+
 use semver;
 
 use pg;
@@ -18,7 +20,7 @@ pub struct Dependency {
     pub kind: Kind,
 }
 
-#[deriving(RustcEncodable, RustcDecodable)]
+#[derive(RustcEncodable, RustcDecodable)]
 pub struct EncodableDependency {
     pub id: i32,
     pub version_id: i32,
@@ -31,7 +33,7 @@ pub struct EncodableDependency {
     pub kind: Kind,
 }
 
-#[deriving(FromPrimitive, Copy)]
+#[derive(FromPrimitive, Copy)]
 pub enum Kind {
     Normal,
     Build,

src/dependency.rs

@@ -13,7 +13,7 @@ pub struct VersionDownload {
     pub date: Timespec,
 }
 
-#[deriving(RustcEncodable, RustcDecodable)]
+#[derive(RustcEncodable, RustcDecodable)]
 pub struct EncodableVersionDownload {
     pub id: i32,
     pub version: i32,

src/download.rs

@@ -17,7 +17,7 @@ use app::{App, RequestApp};
 use dependency::Kind;
 use util::{CargoResult, internal, ChainError};
 
-#[deriving(RustcEncodable, RustcDecodable)]
+#[derive(RustcEncodable, RustcDecodable)]
 pub struct Crate {
     pub name: String,
     pub vers: String,
@@ -27,7 +27,7 @@ pub struct Crate {
     pub yanked: Option<bool>,
 }
 
-#[deriving(RustcEncodable, RustcDecodable)]
+#[derive(RustcEncodable, RustcDecodable)]
 pub struct Dependency {
     pub name: String,
     pub req: String,

src/git.rs

@@ -29,7 +29,7 @@ impl<'a> fmt::Show for Escape<'a> {
         for (i, ch) in s.bytes().enumerate() {
             match ch as char {
                 '<' | '>' | '&' | '\'' | '"' => {
-                    try!(fmt.write(pile_o_bits.slice(last, i).as_bytes()));
+                    try!(fmt.write_str(pile_o_bits.slice(last, i)));
                     let s = match ch as char {
                         '>' => "&gt;",
                         '<' => "&lt;",
@@ -38,15 +38,15 @@ impl<'a> fmt::Show for Escape<'a> {
                         '"' => "&quot;",
                         _ => unreachable!()
                     };
-                    try!(fmt.write(s.as_bytes()));
+                    try!(fmt.write_str(s));
                     last = i + 1;
                 }
                 _ => {}
             }
         }
 
         if last < s.len() {
-            try!(fmt.write(pile_o_bits.slice_from(last).as_bytes()));
+            try!(fmt.write_str(pile_o_bits.slice_from(last)));
         }
         Ok(())
     }

src/html/escape.rs

@@ -12,15 +12,15 @@ use db::{Connection, RequestTransaction};
 use util::{RequestUtils, CargoResult, Require, internal};
 use util::errors::{NotFound, FromError};
 
-#[deriving(Clone)]
+#[derive(Clone)]
 pub struct Keyword {
     pub id: i32,
     pub keyword: String,
     pub created_at: Timespec,
     pub crates_cnt: i32,
 }
 
-#[deriving(RustcEncodable, RustcDecodable)]
+#[derive(RustcEncodable, RustcDecodable)]
 pub struct EncodableKeyword {
     pub id: String,
     pub keyword: String,
@@ -164,9 +164,9 @@ pub fn index(req: &mut Request) -> CargoResult<Response> {
     let row = try!(stmt.query(&[])).next().unwrap();
     let total = row.get(0u);
 
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R { keywords: Vec<EncodableKeyword>, meta: Meta }
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct Meta { total: i64 }
 
     Ok(req.json(&R {
@@ -183,7 +183,7 @@ pub fn show(req: &mut Request) -> CargoResult<Response> {
         None => return Err(FromError::from_error(NotFound)),
     };
 
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R { keyword: EncodableKeyword }
     Ok(req.json(&R { keyword: kw.encodable() }))
 }

src/keyword.rs

@@ -13,7 +13,7 @@ use curl::http;
 use pg;
 use pg::types::ToSql;
 use semver;
-use url::{mod, Url};
+use url::{self, Url};
 
 use {Model, User, Keyword, Version};
 use app::{App, RequestApp};
@@ -29,7 +29,7 @@ use util::{LimitErrorReader, HashingReader};
 use util::{RequestUtils, CargoResult, Require, internal, ChainError, human};
 use version::EncodableVersion;
 
-#[deriving(Clone)]
+#[derive(Clone)]
 pub struct Crate {
     pub id: i32,
     pub name: String,
@@ -47,7 +47,7 @@ pub struct Crate {
     pub repository: Option<String>,
 }
 
-#[deriving(RustcEncodable, RustcDecodable)]
+#[derive(RustcEncodable, RustcDecodable)]
 pub struct EncodableCrate {
     pub id: String,
     pub name: String,
@@ -65,7 +65,7 @@ pub struct EncodableCrate {
     pub links: CrateLinks,
 }
 
-#[deriving(RustcEncodable, RustcDecodable)]
+#[derive(RustcEncodable, RustcDecodable)]
 pub struct CrateLinks {
     pub version_downloads: String,
     pub versions: Option<String>,
@@ -513,9 +513,9 @@ pub fn index(req: &mut Request) -> CargoResult<Response> {
     let row = try!(stmt.query(args)).next().unwrap();
     let total = row.get(0u);
 
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R { crates: Vec<EncodableCrate>, meta: Meta }
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct Meta { total: i64 }
 
     Ok(req.json(&R {
@@ -553,7 +553,7 @@ pub fn summary(req: &mut Request) -> CargoResult<Response> {
     let most_downloaded = try!(tx.prepare("SELECT * FROM crates \
                                            ORDER BY downloads DESC LIMIT 10"));
 
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R {
         num_downloads: i64,
         num_crates: i64,
@@ -578,7 +578,7 @@ pub fn show(req: &mut Request) -> CargoResult<Response> {
     let ids = versions.iter().map(|v| v.id).collect();
     let kws = try!(krate.keywords(conn));
 
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R {
         krate: EncodableCrate,
         versions: Vec<EncodableVersion>,
@@ -698,7 +698,7 @@ pub fn new(req: &mut Request) -> CargoResult<Response> {
     // Now that we've come this far, we're committed!
     bomb.path = None;
 
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R { krate: EncodableCrate }
     Ok(req.json(&R { krate: krate.encodable(None) }))
 }
@@ -789,7 +789,7 @@ pub fn download(req: &mut Request) -> CargoResult<Response> {
                                crate_name, crate_name, version);
 
     if req.wants_json() {
-        #[deriving(RustcEncodable)]
+        #[derive(RustcEncodable)]
         struct R { url: String }
         Ok(req.json(&R{ url: redirect_url }))
     } else {
@@ -820,7 +820,7 @@ pub fn downloads(req: &mut Request) -> CargoResult<Response> {
         downloads.push(download.encodable());
     }
 
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R { version_downloads: Vec<EncodableVersionDownload> }
     Ok(req.json(&R{ version_downloads: downloads }))
 }
@@ -843,7 +843,7 @@ pub fn follow(req: &mut Request) -> CargoResult<Response> {
         try!(tx.execute("INSERT INTO follows (user_id, crate_id)
                          VALUES ($1, $2)", &[&user.id, &krate.id]));
     }
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R { ok: bool }
     Ok(req.json(&R { ok: true }))
 }
@@ -854,7 +854,7 @@ pub fn unfollow(req: &mut Request) -> CargoResult<Response> {
     try!(tx.execute("DELETE FROM follows
                      WHERE user_id = $1 AND crate_id = $2",
                     &[&user.id, &krate.id]));
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R { ok: bool }
     Ok(req.json(&R { ok: true }))
 }
@@ -865,7 +865,7 @@ pub fn following(req: &mut Request) -> CargoResult<Response> {
     let stmt = try!(tx.prepare("SELECT 1 FROM follows
                                 WHERE user_id = $1 AND crate_id = $2"));
     let mut rows = try!(stmt.query(&[&user.id, &krate.id]));
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R { following: bool }
     Ok(req.json(&R { following: rows.next().is_some() }))
 }
@@ -878,7 +878,7 @@ pub fn versions(req: &mut Request) -> CargoResult<Response> {
     let versions = versions.into_iter().map(|v| v.encodable(crate_name))
                            .collect();
 
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R { versions: Vec<EncodableVersion> }
     Ok(req.json(&R{ versions: versions }))
 }
@@ -890,7 +890,7 @@ pub fn owners(req: &mut Request) -> CargoResult<Response> {
     let owners = try!(krate.owners(tx));
     let owners = owners.into_iter().map(|u| u.encodable()).collect();
 
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R { users: Vec<EncodableUser> }
     Ok(req.json(&R{ users: owners }))
 }
@@ -912,7 +912,7 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult<Response> {
         return Err(human("must already be an owner to modify owners"))
     }
 
-    #[deriving(RustcDecodable)] struct Request { users: Vec<String> }
+    #[derive(RustcDecodable)] struct Request { users: Vec<String> }
     let request: Request = try!(json::decode(body.as_slice()).map_err(|_| {
         human("invalid json request")
     }));
@@ -928,7 +928,7 @@ fn modify_owners(req: &mut Request, add: bool) -> CargoResult<Response> {
         }
     }
 
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R { ok: bool }
     Ok(req.json(&R{ ok: true }))
 }
@@ -944,9 +944,9 @@ pub fn reverse_dependencies(req: &mut Request) -> CargoResult<Response> {
         dep.encodable(crate_name.as_slice())
     }).collect();
 
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct R { dependencies: Vec<EncodableDependency>, meta: Meta }
-    #[deriving(RustcEncodable)]
+    #[derive(RustcEncodable)]
     struct Meta { total: i64 }
     Ok(req.json(&R{ dependencies: rev_deps, meta: Meta { total: total } }))
 }

src/krate.rs

@@ -1,4 +1,5 @@
-#![feature(macro_rules, phase, slicing_syntax)]
+#![feature(macro_rules, phase, slicing_syntax, associated_types)]
+#![feature(old_orphan_check)]
 #![allow(missing_copy_implementations)]
 
 extern crate "rustc-serialize" as rustc_serialize;
@@ -62,7 +63,7 @@ pub mod util;
 pub mod version;
 mod licenses;
 
-#[deriving(PartialEq, Eq, Clone, Copy)]
+#[derive(PartialEq, Eq, Clone, Copy)]
 pub enum Env {
     Development,
     Test,

src/lib.rs

@@ -3,7 +3,7 @@ use db::Connection;
 use util::{CargoResult, Require};
 use util::errors::NotFound;
 
-pub trait Model {
+pub trait Model: Sized {
     fn from_row(row: &pg::Row) -> Self;
     fn table_name(_: Option<Self>) -> &'static str;
 

src/model.rs

@@ -13,4 +13,4 @@ path = "lib.rs"
 openssl = "0.2.0"
 time = "0.1.0"
 curl = "0.1.0"
-rustc-serialize = "0.1"
+rustc-serialize = "0.2"