try! -> ?

Author: sfackler

README.md

@@ -63,8 +63,8 @@ fn main() {
 ### Connecting
 Connect to a Postgres server using the standard URI format:
 ```rust
-let conn = try!(Connection::connect("postgres://user:pass@host:port/database?arg1=val1&arg2=val2",
-                                    TlsMode::None));
+let conn = Connection::connect("postgres://user:pass@host:port/database?arg1=val1&arg2=val2",
+                               TlsMode::None)?;
 ```
 `pass` may be omitted if not needed. `port` defaults to `5432` and `database`
 defaults to the value of `user` if not specified. The driver supports `trust`,
@@ -75,7 +75,7 @@ be set to the absolute path to the directory containing the socket file. Since
 `/` is a reserved character in URLs, the path should be URL encoded. If Postgres
 stored its socket files in `/run/postgres`, the connection would then look like:
 ```rust
-let conn = try!(Connection::connect("postgres://postgres@%2Frun%2Fpostgres", TlsMode::None));
+let conn = Connection::connect("postgres://postgres@%2Frun%2Fpostgres", TlsMode::None)?;
 ```
 Paths which contain non-UTF8 characters can be handled in a different manner;
 see the documentation for details.
@@ -89,7 +89,7 @@ that query parameters are 1-indexed rather than the more common 0-indexing.
 `execute` returns the number of rows affected by the query (or 0 if not
 applicable):
 ```rust
-let updates = try!(conn.execute("UPDATE foo SET bar = $1 WHERE baz = $2", &[&1i32, &"biz"]));
+let updates = conn.execute("UPDATE foo SET bar = $1 WHERE baz = $2", &[&1i32, &"biz"])?;
 println!("{} rows were updated", updates);
 ```
 
@@ -98,7 +98,7 @@ The fields in a row can be accessed either by their indices or their column
 names, though access by index is more efficient. Unlike statement parameters,
 result columns are zero-indexed.
 ```rust
-for row in &try!(conn.query("SELECT bar, baz FROM foo WHERE buz = $1", &[&1i32])) {
+for row in &conn.query("SELECT bar, baz FROM foo WHERE buz = $1", &[&1i32])? {
     let bar: i32 = row.get(0);
     let baz: String = row.get("baz");
     println!("bar: {}, baz: {}", bar, baz);
@@ -110,9 +110,9 @@ If the same statement will be executed repeatedly (possibly with different
 parameters), explicitly preparing it can improve performance:
 
 ```rust
-let stmt = try!(conn.prepare("UPDATE foo SET bar = $1 WHERE baz = $2"));
+let stmt = conn.prepare("UPDATE foo SET bar = $1 WHERE baz = $2")?;
 for (bar, baz) in updates {
-    try!(stmt.execute(&[bar, baz]));
+    stmt.execute(&[bar, baz])?;
 }
 ```
 
@@ -122,13 +122,13 @@ The `transaction` method will start a new transaction. It returns a
 `Connection` as well as methods to control the result of the
 transaction:
 ```rust
-let trans = try!(conn.transaction());
+let trans = conn.transaction()?;
 
-try!(trans.execute(...));
-let stmt = try!(trans.prepare(...));
+trans.execute(...)?;
+let stmt = trans.prepare(...)?;
 // ...
 
-try!(trans.commit());
+trans.commit()?;
 ```
 The transaction will be active until the `Transaction` object falls out of
 scope. A transaction will roll back by default. Nested transactions are

codegen/src/type_gen.rs

@@ -159,7 +159,7 @@ r#"impl fmt::Display for Type {{
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {{
         match self.schema() {{
             "public" | "pg_catalog" => {{}}
-            schema => try!(write!(fmt, "{{}}.", schema)),
+            schema => write!(fmt, "{{}}.", schema)?,
         }}
         fmt.write_str(self.name())
     }}

postgres-shared/src/error/mod.rs

@@ -159,24 +159,24 @@ impl DbError {
         let mut line = None;
         let mut routine = None;
 
-        while let Some(field) = try!(fields.next()) {
+        while let Some(field) = fields.next()? {
             match field.type_() {
                 b'S' => severity = Some(field.value().to_owned()),
                 b'C' => code = Some(SqlState::from_code(field.value())),
                 b'M' => message = Some(field.value().to_owned()),
                 b'D' => detail = Some(field.value().to_owned()),
                 b'H' => hint = Some(field.value().to_owned()),
                 b'P' => {
-                    normal_position = Some(try!(field.value().parse::<u32>().map_err(|_| {
+                    normal_position = Some(field.value().parse::<u32>().map_err(|_| {
                         io::Error::new(io::ErrorKind::InvalidInput,
                                        "`P` field did not contain an integer")
-                    })));
+                    })?);
                 }
                 b'p' => {
-                    internal_position = Some(try!(field.value().parse::<u32>().map_err(|_| {
+                    internal_position = Some(field.value().parse::<u32>().map_err(|_| {
                         io::Error::new(io::ErrorKind::InvalidInput,
                                        "`p` field did not contain an integer")
-                    })));
+                    })?);
                 }
                 b'q' => internal_query = Some(field.value().to_owned()),
                 b'W' => where_ = Some(field.value().to_owned()),
@@ -187,31 +187,31 @@ impl DbError {
                 b'n' => constraint = Some(field.value().to_owned()),
                 b'F' => file = Some(field.value().to_owned()),
                 b'L' => {
-                    line = Some(try!(field.value().parse::<u32>().map_err(|_| {
+                    line = Some(field.value().parse::<u32>().map_err(|_| {
                         io::Error::new(io::ErrorKind::InvalidInput,
                                        "`L` field did not contain an integer")
-                    })));
+                    })?);
                 }
                 b'R' => routine = Some(field.value().to_owned()),
                 b'V' => {
-                    parsed_severity = Some(try!(Severity::from_str(field.value()).ok_or_else(|| {
+                    parsed_severity = Some(Severity::from_str(field.value()).ok_or_else(|| {
                         io::Error::new(io::ErrorKind::InvalidInput,
                                        "`V` field contained an invalid value")
-                    })));
+                    })?);
                 }
                 _ => {},
             }
         }
 
         Ok(DbError {
-            severity: try!(severity.ok_or_else(|| {
+            severity: severity.ok_or_else(|| {
                 io::Error::new(io::ErrorKind::InvalidInput, "`S` field missing")
-            })),
+            })?,
             parsed_severity: parsed_severity,
-            code: try!(code.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput,
-                                                         "`C` field missing"))),
-            message: try!(message.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput,
-                                                               "`M` field missing"))),
+            code: code.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput,
+                                                         "`C` field missing"))?,
+            message: message.ok_or_else(|| io::Error::new(io::ErrorKind::InvalidInput,
+                                                               "`M` field missing"))?,
             detail: detail,
             hint: hint,
             position: match normal_position {
@@ -221,10 +221,10 @@ impl DbError {
                         Some(position) => {
                             Some(ErrorPosition::Internal {
                                 position: position,
-                                query: try!(internal_query.ok_or_else(|| {
+                                query: internal_query.ok_or_else(|| {
                                     io::Error::new(io::ErrorKind::InvalidInput,
                                                    "`q` field missing but `p` field present")
-                                })),
+                                })?,
                             })
                         }
                         None => None,
@@ -310,7 +310,7 @@ pub enum ConnectError {
 
 impl fmt::Display for ConnectError {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        try!(fmt.write_str(error::Error::description(self)));
+        fmt.write_str(error::Error::description(self))?;
         match *self {
             ConnectError::ConnectParams(ref msg) => write!(fmt, ": {}", msg),
             ConnectError::Db(ref err) => write!(fmt, ": {}", err),

postgres-shared/src/params/mod.rs

@@ -78,7 +78,7 @@ impl IntoConnectParams for Url {
     fn into_connect_params(self) -> Result<ConnectParams, Box<Error + Sync + Send>> {
         let Url { host, port, user, path: url::Path { mut path, query: options, .. }, .. } = self;
 
-        let maybe_path = try!(url::decode_component(&host));
+        let maybe_path = url::decode_component(&host)?;
         let target = if maybe_path.starts_with('/') {
             ConnectTarget::Unix(PathBuf::from(maybe_path))
         } else {

postgres-shared/src/params/url.rs

@@ -51,17 +51,17 @@ impl Url {
 
     pub fn parse(rawurl: &str) -> DecodeResult<Url> {
         // scheme
-        let (scheme, rest) = try!(get_scheme(rawurl));
+        let (scheme, rest) = get_scheme(rawurl)?;
 
         // authority
-        let (userinfo, host, port, rest) = try!(get_authority(rest));
+        let (userinfo, host, port, rest) = get_authority(rest)?;
 
         // path
         let has_authority = !host.is_empty();
-        let (path, rest) = try!(get_path(rest, has_authority));
+        let (path, rest) = get_path(rest, has_authority)?;
 
         // query and fragment
-        let (query, fragment) = try!(get_query_fragment(rest));
+        let (query, fragment) = get_query_fragment(rest)?;
 
         let url = Url::new(scheme.to_owned(),
                            userinfo,
@@ -84,10 +84,10 @@ impl Path {
     }
 
     pub fn parse(rawpath: &str) -> DecodeResult<Path> {
-        let (path, rest) = try!(get_path(rawpath, false));
+        let (path, rest) = get_path(rawpath, false)?;
 
         // query and fragment
-        let (query, fragment) = try!(get_query_fragment(&rest));
+        let (query, fragment) = get_query_fragment(&rest)?;
 
         Ok(Path {
             path: path,
@@ -177,7 +177,7 @@ fn query_from_str(rawquery: &str) -> DecodeResult<Query> {
     if !rawquery.is_empty() {
         for p in rawquery.split('&') {
             let (k, v) = split_char_first(p, '=');
-            query.push((try!(decode_component(k)), try!(decode_component(v))));
+            query.push((decode_component(k)?, decode_component(v)?));
         }
     }
 
@@ -316,13 +316,13 @@ fn get_authority(rawurl: &str) -> DecodeResult<(Option<UserInfo>, &str, Option<u
                 colon_count = 0; // reset count
                 match st {
                     State::Start => {
-                        let user = try!(decode_component(&rawurl[begin..i]));
+                        let user = decode_component(&rawurl[begin..i])?;
                         userinfo = Some(UserInfo::new(user, None));
                         st = State::InHost;
                     }
                     State::PassHostPort => {
-                        let user = try!(decode_component(&rawurl[begin..pos]));
-                        let pass = try!(decode_component(&rawurl[pos + 1..i]));
+                        let user = decode_component(&rawurl[begin..pos])?;
+                        let pass = decode_component(&rawurl[pos + 1..i])?;
                         userinfo = Some(UserInfo::new(user, Some(pass)));
                         st = State::InHost;
                     }
@@ -392,7 +392,7 @@ fn get_path(rawurl: &str, is_authority: bool) -> DecodeResult<(String, &str)> {
     if is_authority && end != 0 && !rawurl.starts_with('/') {
         Err("Non-empty path must begin with '/' in presence of authority.".to_owned())
     } else {
-        Ok((try!(decode_component(&rawurl[0..end])), &rawurl[end..len]))
+        Ok((decode_component(&rawurl[0..end])?, &rawurl[end..len]))
     }
 }
 
@@ -403,11 +403,11 @@ fn get_query_fragment(rawurl: &str) -> DecodeResult<(Query, Option<String>)> {
     // Parse the fragment if available
     let fragment = match raw_fragment {
         "" => None,
-        raw => Some(try!(decode_component(raw))),
+        raw => Some(decode_component(raw)?),
     };
 
     match before_fragment.chars().next() {
-        Some('?') => Ok((try!(query_from_str(&before_fragment[1..])), fragment)),
+        Some('?') => Ok((query_from_str(&before_fragment[1..])?, fragment)),
         None => Ok((vec![], fragment)),
         _ => Err(format!("Query didn't start with '?': '{}..'", before_fragment)),
     }

postgres-shared/src/rows.rs

@@ -60,7 +60,7 @@ impl<'a> FromFallibleIterator<Option<&'a [u8]>> for RowData {
             indices: Vec::with_capacity(it.size_hint().0),
         };
 
-        while let Some(cell) = try!(it.next()) {
+        while let Some(cell) = it.next()? {
             let index = match cell {
                 Some(cell) =>  {
                     let base = row.buf.len();

postgres-shared/src/types/bit_vec.rs

@@ -8,7 +8,7 @@ use types::{FromSql, ToSql, IsNull, Type};
 
 impl FromSql for BitVec {
     fn from_sql(_: &Type, raw: &[u8]) -> Result<BitVec, Box<Error + Sync + Send>> {
-        let varbit = try!(types::varbit_from_sql(raw));
+        let varbit = types::varbit_from_sql(raw)?;
         let mut bitvec = BitVec::from_bytes(varbit.bytes());
         while bitvec.len() > varbit.len() {
             bitvec.pop();
@@ -25,7 +25,7 @@ impl ToSql for BitVec {
               _: &Type,
               mut out: &mut Vec<u8>)
               -> Result<IsNull, Box<Error + Sync + Send>> {
-        try!(types::varbit_to_sql(self.len(), self.to_bytes().into_iter(), out));
+        types::varbit_to_sql(self.len(), self.to_bytes().into_iter(), out)?;
         Ok(IsNull::No)
     }
 

postgres-shared/src/types/chrono.rs

@@ -15,7 +15,7 @@ impl FromSql for NaiveDateTime {
     fn from_sql(_: &Type,
                 raw: &[u8])
                 -> Result<NaiveDateTime, Box<Error + Sync + Send>> {
-        let t = try!(types::timestamp_from_sql(raw));
+        let t = types::timestamp_from_sql(raw)?;
         Ok(base() + Duration::microseconds(t))
     }
 
@@ -43,7 +43,7 @@ impl FromSql for DateTime<UTC> {
     fn from_sql(type_: &Type,
                 raw: &[u8])
                 -> Result<DateTime<UTC>, Box<Error + Sync + Send>> {
-        let naive = try!(NaiveDateTime::from_sql(type_, raw));
+        let naive = NaiveDateTime::from_sql(type_, raw)?;
         Ok(DateTime::from_utc(naive, UTC))
     }
 
@@ -66,7 +66,7 @@ impl FromSql for DateTime<Local> {
     fn from_sql(type_: &Type,
                 raw: &[u8])
                 -> Result<DateTime<Local>, Box<Error + Sync + Send>> {
-        let utc = try!(DateTime::<UTC>::from_sql(type_, raw));
+        let utc = DateTime::<UTC>::from_sql(type_, raw)?;
         Ok(utc.with_timezone(&Local))
     }
 
@@ -89,7 +89,7 @@ impl FromSql for DateTime<FixedOffset> {
     fn from_sql(type_: &Type,
                 raw: &[u8])
                 -> Result<DateTime<FixedOffset>, Box<Error + Sync + Send>> {
-        let utc = try!(DateTime::<UTC>::from_sql(type_, raw));
+        let utc = DateTime::<UTC>::from_sql(type_, raw)?;
         Ok(utc.with_timezone(&FixedOffset::east(0)))
     }
 
@@ -112,7 +112,7 @@ impl FromSql for NaiveDate {
     fn from_sql(_: &Type,
                 raw: &[u8])
                 -> Result<NaiveDate, Box<Error + Sync + Send>> {
-        let jd = try!(types::date_from_sql(raw));
+        let jd = types::date_from_sql(raw)?;
         Ok(base().date() + Duration::days(jd as i64))
     }
 
@@ -141,7 +141,7 @@ impl FromSql for NaiveTime {
     fn from_sql(_: &Type,
                 raw: &[u8])
                 -> Result<NaiveTime, Box<Error + Sync + Send>> {
-        let usec = try!(types::time_from_sql(raw));
+        let usec = types::time_from_sql(raw)?;
         Ok(NaiveTime::from_hms(0, 0, 0) + Duration::microseconds(usec))
     }
 

postgres-shared/src/types/eui48.rs

@@ -10,7 +10,7 @@ impl FromSql for MacAddress {
     fn from_sql(_: &Type,
                 raw: &[u8])
                 -> Result<MacAddress, Box<Error + Sync + Send>> {
-        let bytes = try!(types::macaddr_from_sql(raw));
+        let bytes = types::macaddr_from_sql(raw)?;
         Ok(MacAddress::new(bytes))
     }