Replace try with ?

Author: Eh2406

src/bin/fill-in-user-id.rs

@@ -67,16 +67,16 @@ fn update(app: &App, tx: &postgres::transaction::Transaction) {
         println!("attempt: {}/{}", id, login);
         let res = (|| -> CargoResult<()> {
             let url = format!("/users/{}", login);
-            let (handle, resp) = try!(http::github(app, &url, &token));
-            let ghuser: GithubUser = try!(http::parse_github_response(handle, resp));
+            let (handle, resp) = http::github(app, &url, &token)?;
+            let ghuser: GithubUser = http::parse_github_response(handle, resp)?;
             if let Some(ref avatar) = avatar {
                 if !avatar.contains(&ghuser.id.to_string()) {
                     return Err(human(format!("avatar: {}", avatar)))
                 }
             }
             if ghuser.login == login {
-                try!(tx.execute("UPDATE users SET gh_id = $1 WHERE id = $2",
-                                &[&ghuser.id, &id]));
+                tx.execute("UPDATE users SET gh_id = $1 WHERE id = $2",
+                           &[&ghuser.id, &id])?;
                 Ok(())
             } else {
                 Err(human(format!("different login: {}", ghuser.login)))

src/bin/migrate.rs

@@ -38,10 +38,10 @@ fn update(tx: &postgres::transaction::Transaction) -> postgres::Result<()> {
         for day in 0..90 {
             let moment = now + Duration::days(-day);
             dls += rng.gen_range(-100, 100);
-            try!(tx.execute("INSERT INTO version_downloads \
+            tx.execute("INSERT INTO version_downloads \
                               (version_id, downloads, date) \
                               VALUES ($1, $2, $3)",
-                            &[&id, &dls, &moment]));
+                       &[&id, &dls, &moment])?;
         }
     }
     Ok(())

src/bin/populate.rs

@@ -36,20 +36,20 @@ fn update(conn: &postgres::GenericConnection) -> postgres::Result<()> {
     loop {
         // FIXME(rust-lang/rust#27401): weird declaration to make sure this
         // variable gets dropped.
-        let tx; tx = try!(conn.transaction());
+        let tx; tx = conn.transaction()?;
         {
-            let stmt = try!(tx.prepare("SELECT * FROM version_downloads \
+            let stmt = tx.prepare("SELECT * FROM version_downloads \
                                         WHERE processed = FALSE AND id > $1
                                         ORDER BY id ASC
-                                        LIMIT $2"));
-            let mut rows = try!(stmt.query(&[&max, &LIMIT]));
-            match try!(collect(&tx, &mut rows)) {
+                                        LIMIT $2")?;
+            let mut rows = stmt.query(&[&max, &LIMIT])?;
+            match collect(&tx, &mut rows)? {
                 None => break,
                 Some(m) => max = m,
             }
         }
         tx.set_commit();
-        try!(tx.finish());
+        tx.finish()?;
     }
     Ok(())
 }
@@ -87,10 +87,10 @@ fn collect(tx: &postgres::transaction::Transaction,
 
         // Flag this row as having been processed if we're passed the cutoff,
         // and unconditionally increment the number of counted downloads.
-        try!(tx.execute("UPDATE version_downloads
+        tx.execute("UPDATE version_downloads
                          SET processed = $2, counted = counted + $3
                          WHERE id = $1",
-                        &[id, &(download.date < cutoff), &amt]));
+                   &[id, &(download.date < cutoff), &amt])?;
         println!("{}\n{}", time::at(download.date).rfc822(),
                  time::at(cutoff).rfc822());
         total += amt as i64;
@@ -102,31 +102,31 @@ fn collect(tx: &postgres::transaction::Transaction,
         let crate_id = Version::find(tx, download.version_id).unwrap().crate_id;
 
         // Update the total number of version downloads
-        try!(tx.execute("UPDATE versions
+        tx.execute("UPDATE versions
                          SET downloads = downloads + $1
                          WHERE id = $2",
-                        &[&amt, &download.version_id]));
+                   &[&amt, &download.version_id])?;
         // Update the total number of crate downloads
-        try!(tx.execute("UPDATE crates SET downloads = downloads + $1
-                         WHERE id = $2", &[&amt, &crate_id]));
+        tx.execute("UPDATE crates SET downloads = downloads + $1
+                         WHERE id = $2", &[&amt, &crate_id])?;
 
         // Update the total number of crate downloads for today
-        let cnt = try!(tx.execute("UPDATE crate_downloads
+        let cnt = tx.execute("UPDATE crate_downloads
                                    SET downloads = downloads + $2
                                    WHERE crate_id = $1 AND date = date($3)",
-                                  &[&crate_id, &amt, &download.date]));
+                             &[&crate_id, &amt, &download.date])?;
         if cnt == 0 {
-            try!(tx.execute("INSERT INTO crate_downloads
+            tx.execute("INSERT INTO crate_downloads
                              (crate_id, downloads, date)
                              VALUES ($1, $2, $3)",
-                            &[&crate_id, &amt, &download.date]));
+                       &[&crate_id, &amt, &download.date])?;
         }
     }
 
     // After everything else is done, update the global counter of total
     // downloads.
-    try!(tx.execute("UPDATE metadata SET total_downloads = total_downloads + $1",
-                    &[&total]));
+    tx.execute("UPDATE metadata SET total_downloads = total_downloads + $1",
+               &[&total])?;
 
     Ok(Some(max))
 }

src/bin/update-downloads.rs

@@ -58,7 +58,7 @@ pub fn tls_handshake() -> Box<TlsHandshake + Sync + Send> {
                          _domain: &str,
                          stream: Stream)
                          -> Result<Box<TlsStream>, Box<Error + Send + Sync>> {
-            let stream = try!(self.0.danger_connect_without_providing_domain_for_certificate_verification_and_server_name_indication(stream));
+            let stream = self.0.danger_connect_without_providing_domain_for_certificate_verification_and_server_name_indication(stream)?;
             Ok(Box::new(stream))
         }
     }
@@ -131,9 +131,9 @@ impl Transaction {
 
     pub fn conn(&self) -> CargoResult<&r2d2::PooledConnection<r2d2_postgres::PostgresConnectionManager>> {
         if !self.slot.filled() {
-            let conn = try!(self.app.database.get().map_err(|e| {
+            let conn = self.app.database.get().map_err(|e| {
                 internal(format!("failed to get a database connection: {}", e))
-            }));
+            })?;
             self.slot.fill(Box::new(conn));
         }
         Ok(&**self.slot.borrow().unwrap())
@@ -146,8 +146,8 @@ impl Transaction {
         // desired effect.
         unsafe {
             if !self.tx.filled() {
-                let conn = try!(self.conn());
-                let t = try!(conn.transaction());
+                let conn = self.conn()?;
+                let t = conn.transaction()?;
                 let t = mem::transmute::<_, pg::transaction::Transaction<'static>>(t);
                 self.tx.fill(t);
             }
@@ -183,9 +183,9 @@ impl Middleware for TransactionMiddleware {
             if res.is_ok() && tx.commit.get() == Some(true) {
                 transaction.set_commit();
             }
-            try!(transaction.finish().map_err(|e| {
-                Box::new(e) as Box<Error+Send>
-            }));
+            transaction.finish().map_err(|e| {
+                Box::new(e) as Box<Error + Send>
+            })?;
         }
         return res
     }

src/db.rs

@@ -53,16 +53,16 @@ pub fn add_crate(app: &App, krate: &Crate) -> CargoResult<()> {
 
     commit_and_push(repo, || {
         // Add the crate to its relevant file
-        try!(fs::create_dir_all(dst.parent().unwrap()));
+        fs::create_dir_all(dst.parent().unwrap())?;
         let mut prev = String::new();
         if fs::metadata(&dst).is_ok() {
-            try!(File::open(&dst).and_then(|mut f| f.read_to_string(&mut prev)));
+            File::open(&dst).and_then(|mut f| f.read_to_string(&mut prev))?;
         }
         let s = json::encode(krate).unwrap();
         let new = prev + &s;
-        let mut f = try!(File::create(&dst));
-        try!(f.write_all(new.as_bytes()));
-        try!(f.write_all(b"\n"));
+        let mut f = File::create(&dst)?;
+        f.write_all(new.as_bytes())?;
+        f.write_all(b"\n")?;
 
         Ok((format!("Updating crate `{}#{}`", krate.name, krate.vers),
             dst.clone()))
@@ -78,22 +78,22 @@ pub fn yank(app: &App, krate: &str, version: &semver::Version,
 
     commit_and_push(repo, || {
         let mut prev = String::new();
-        try!(File::open(&dst).and_then(|mut f| f.read_to_string(&mut prev)));
+        File::open(&dst).and_then(|mut f| f.read_to_string(&mut prev))?;
         let new = prev.lines().map(|line| {
-            let mut git_crate = try!(json::decode::<Crate>(line).map_err(|_| {
+            let mut git_crate = json::decode::<Crate>(line).map_err(|_| {
                 internal(format!("couldn't decode: `{}`", line))
-            }));
+            })?;
             if git_crate.name != krate ||
                git_crate.vers.to_string() != version.to_string() {
                 return Ok(line.to_string())
             }
             git_crate.yanked = Some(yanked);
             Ok(json::encode(&git_crate).unwrap())
         }).collect::<CargoResult<Vec<String>>>();
-        let new = try!(new).join("\n");
-        let mut f = try!(File::create(&dst));
-        try!(f.write_all(new.as_bytes()));
-        try!(f.write_all(b"\n"));
+        let new = new?.join("\n");
+        let mut f = File::create(&dst)?;
+        f.write_all(new.as_bytes())?;
+        f.write_all(b"\n")?;
 
         Ok((format!("{} crate `{}#{}`",
                     if yanked {"Yanking"} else {"Unyanking"},
@@ -112,27 +112,27 @@ fn commit_and_push<F>(repo: &git2::Repository, mut f: F) -> CargoResult<()>
     // race to commit the changes. For now we just cap out the maximum number of
     // retries at a fixed number.
     for _ in 0..20 {
-        let (msg, dst) = try!(f());
+        let (msg, dst) = f()?;
 
         // git add $file
-        let mut index = try!(repo.index());
+        let mut index = repo.index()?;
         let mut repo_path = repo_path.iter();
         let dst = dst.iter().skip_while(|s| Some(*s) == repo_path.next())
                      .collect::<PathBuf>();
-        try!(index.add_path(&dst));
-        try!(index.write());
-        let tree_id = try!(index.write_tree());
-        let tree = try!(repo.find_tree(tree_id));
+        index.add_path(&dst)?;
+        index.write()?;
+        let tree_id = index.write_tree()?;
+        let tree = repo.find_tree(tree_id)?;
 
         // git commit -m "..."
-        let head = try!(repo.head());
-        let parent = try!(repo.find_commit(head.target().unwrap()));
-        let sig = try!(repo.signature());
-        try!(repo.commit(Some("HEAD"), &sig, &sig, &msg, &tree, &[&parent]));
+        let head = repo.head()?;
+        let parent = repo.find_commit(head.target().unwrap())?;
+        let sig = repo.signature()?;
+        repo.commit(Some("HEAD"), &sig, &sig, &msg, &tree, &[&parent])?;
 
         // git push
         let mut ref_status = None;
-        let mut origin = try!(repo.find_remote("origin"));
+        let mut origin = repo.find_remote("origin")?;
         let res = {
             let mut callbacks = git2::RemoteCallbacks::new();
             callbacks.credentials(credentials);
@@ -153,15 +153,15 @@ fn commit_and_push<F>(repo: &git2::Repository, mut f: F) -> CargoResult<()>
 
         let mut callbacks = git2::RemoteCallbacks::new();
         callbacks.credentials(credentials);
-        try!(origin.update_tips(Some(&mut callbacks), true,
-                                git2::AutotagOption::Unspecified,
-                                None));
+        origin.update_tips(Some(&mut callbacks), true,
+                           git2::AutotagOption::Unspecified,
+                           None)?;
 
         // Ok, we need to update, so fetch and reset --hard
-        try!(origin.fetch(&["refs/heads/*:refs/heads/*"], None, None));
-        let head = try!(repo.head()).target().unwrap();
-        let obj = try!(repo.find_object(head, None));
-        try!(repo.reset(&obj, git2::ResetType::Hard, None));
+        origin.fetch(&["refs/heads/*:refs/heads/*"], None, None)?;
+        let head = repo.head()?.target().unwrap();
+        let obj = repo.find_object(head, None)?;
+        repo.reset(&obj, git2::ResetType::Hard, None)?;
     }
 
     Err(internal("Too many rebase failures"))

src/git.rs

@@ -32,7 +32,7 @@ pub fn github(app: &App, url: &str, auth: &Token)
             data.extend_from_slice(buf);
             Ok(buf.len())
         }).unwrap();
-        try!(transfer.perform());
+        transfer.perform()?;
     }
     Ok((handle, data))
 }
@@ -58,9 +58,9 @@ pub fn parse_github_response<T: Decodable>(mut resp: Easy, data: Vec<u8>)
         }
     }
 
-    let json = try!(str::from_utf8(&data).ok().chain_error(||{
+    let json = str::from_utf8(&data).ok().chain_error(|| {
         internal("github didn't send a utf8-response")
-    }));
+    })?;
 
     json::decode(json).chain_error(|| {
         internal("github didn't send a valid json response")

src/http.rs

@@ -74,19 +74,19 @@ fn run(sql: String) -> Step {
 impl<'a> Manager<'a> {
     pub fn new(tx: Transaction) -> PgResult<Manager> {
         let mut mgr = Manager { tx: tx, versions: HashSet::new() };
-        try!(mgr.load());
+        mgr.load()?;
         Ok(mgr)
     }
 
     fn load(&mut self) -> PgResult<()> {
-        try!(self.tx.execute("CREATE TABLE IF NOT EXISTS schema_migrations (
+        self.tx.execute("CREATE TABLE IF NOT EXISTS schema_migrations (
             id              SERIAL PRIMARY KEY,
             version         INT8 NOT NULL UNIQUE
-        )", &[]));
+        )", &[])?;
 
-        let stmt = try!(self.tx.prepare("SELECT version FROM \
-                                         schema_migrations"));
-        for row in try!(stmt.query(&[])).iter() {
+        let stmt = self.tx.prepare("SELECT version FROM \
+                                         schema_migrations")?;
+        for row in stmt.query(&[])?.iter() {
             assert!(self.versions.insert(row.get("version")));
         }
         Ok(())
@@ -99,20 +99,20 @@ impl<'a> Manager<'a> {
     pub fn apply(&mut self, mut migration: Migration) -> PgResult<()> {
         if !self.versions.insert(migration.version) { return Ok(()) }
         println!("applying {}", migration.version);
-        try!((migration.up)(A { t: &self.tx }));
-        let stmt = try!(self.tx.prepare("INSERT into schema_migrations
-                                         (version) VALUES ($1)"));
-        try!(stmt.execute(&[&migration.version]));
+        (migration.up)(A { t: &self.tx })?;
+        let stmt = self.tx.prepare("INSERT into schema_migrations
+                                         (version) VALUES ($1)")?;
+        stmt.execute(&[&migration.version])?;
         Ok(())
     }
 
     pub fn rollback(&mut self, mut migration: Migration) -> PgResult<()> {
         if !self.versions.remove(&migration.version) { return Ok(()) }
         println!("rollback {}", migration.version);
-        try!((migration.down)(A { t: &self.tx }));
-        let stmt = try!(self.tx.prepare("DELETE FROM schema_migrations
-                                         WHERE version = $1"));
-        try!(stmt.execute(&[&migration.version]));
+        (migration.down)(A { t: &self.tx })?;
+        let stmt = self.tx.prepare("DELETE FROM schema_migrations
+                                         WHERE version = $1")?;
+        stmt.execute(&[&migration.version])?;
         Ok(())
     }
 

src/migrate/lib.rs

@@ -22,7 +22,7 @@ impl conduit_middleware::Middleware for Middleware {
             Some(id) => {
 
                 // Look for a user in the database with the given `user_id`
-                match User::find(try!(req.tx().map_err(std_error)), id) {
+                match User::find(req.tx().map_err(std_error)?, id) {
                     Ok(user) => user,
                     Err(..) => return Ok(()),
                 }
@@ -36,7 +36,7 @@ impl conduit_middleware::Middleware for Middleware {
                     Some(headers) => {
 
                         // Look for a user in the database with a matching API token
-                        let tx = try!(req.tx().map_err(std_error));
+                        let tx = req.tx().map_err(std_error)?;
                         match User::find_by_api_token(tx, &headers[0]) {
                             Ok(user) => user,
                             Err(..) => return Ok(())