Make use of deref coercions

Author: sfackler

src/lib.rs

@@ -172,7 +172,7 @@ impl IntoConnectParams for Url {
             ..
         } = self;
 
-        let maybe_path = try!(url::decode_component(&*host).map_err(ConnectError::InvalidUrl));
+        let maybe_path = try!(url::decode_component(&host).map_err(ConnectError::InvalidUrl));
         let target = if maybe_path.starts_with("/") {
             ConnectTarget::Unix(Path::new(maybe_path))
         } else {
@@ -444,7 +444,7 @@ impl InnerConnection {
 
         try!(conn.write_messages(&[StartupMessage {
             version: message::PROTOCOL_VERSION,
-            parameters: &*options
+            parameters: &options
         }]));
 
         try!(conn.handle_auth(user));
@@ -545,7 +545,7 @@ impl InnerConnection {
             AuthenticationCleartextPassword => {
                 let pass = try!(user.password.ok_or(ConnectError::MissingPassword));
                 try!(self.write_messages(&[PasswordMessage {
-                        password: &*pass,
+                        password: &pass,
                     }]));
             }
             AuthenticationMD5Password { salt } => {
@@ -559,7 +559,7 @@ impl InnerConnection {
                 hasher.update(&salt);
                 let output = format!("md5{}", hasher.finalize().to_hex());
                 try!(self.write_messages(&[PasswordMessage {
-                        password: &*output
+                        password: &output
                     }]));
             }
             AuthenticationKerberosV5
@@ -641,7 +641,7 @@ impl InnerConnection {
 
     fn prepare<'a>(&mut self, query: &str, conn: &'a Connection) -> Result<Statement<'a>> {
         let stmt_name = self.make_stmt_name();
-        let (param_types, result_desc) = try!(self.raw_prepare(&*stmt_name, query));
+        let (param_types, result_desc) = try!(self.raw_prepare(&stmt_name, query));
         Ok(Statement {
             conn: conn,
             name: stmt_name,
@@ -659,7 +659,7 @@ impl InnerConnection {
             Some(stmt) => stmt,
             None => {
                 let stmt_name = self.make_stmt_name();
-                let (param_types, result_desc) = try!(self.raw_prepare(&*stmt_name, query));
+                let (param_types, result_desc) = try!(self.raw_prepare(&stmt_name, query));
                 let stmt = CachedStatement {
                     name: stmt_name,
                     param_types: param_types,
@@ -687,7 +687,7 @@ impl InnerConnection {
         let _ = util::comma_join(&mut query, rows.iter().cloned());
         let _ = write!(&mut query, " FROM {}", table);
         let query = String::from_utf8(query).unwrap();
-        let (_, result_desc) = try!(self.raw_prepare("", &*query));
+        let (_, result_desc) = try!(self.raw_prepare("", &query));
         let column_types = result_desc.into_iter().map(|desc| desc.ty).collect();
 
         let mut query = vec![];
@@ -696,7 +696,7 @@ impl InnerConnection {
         let _ = write!(&mut query, ") FROM STDIN WITH (FORMAT binary)");
         let query = String::from_utf8(query).unwrap();
         let stmt_name = self.make_stmt_name();
-        try!(self.raw_prepare(&*stmt_name, &*query));
+        try!(self.raw_prepare(&stmt_name, &query));
 
         Ok(CopyInStatement {
             conn: conn,
@@ -819,7 +819,7 @@ impl InnerConnection {
                 ReadyForQuery { .. } => break,
                 DataRow { row } => {
                     result.push(row.into_iter().map(|opt| {
-                        opt.map(|b| String::from_utf8_lossy(&*b).into_owned())
+                        opt.map(|b| String::from_utf8_lossy(&b).into_owned())
                     }).collect());
                 }
                 CopyInResponse { .. } => {
@@ -1313,7 +1313,7 @@ impl<'conn> Statement<'conn> {
             self.finished = true;
             let mut conn = self.conn.conn.borrow_mut();
             check_desync!(conn);
-            conn.close_statement(&*self.name, b'S')
+            conn.close_statement(&self.name, b'S')
         } else {
             Ok(())
         }
@@ -1335,9 +1335,9 @@ impl<'conn> Statement<'conn> {
         try!(conn.write_messages(&[
             Bind {
                 portal: portal_name,
-                statement: &*self.name,
+                statement: &self.name,
                 formats: &[1],
-                values: &*values,
+                values: &values,
                 result_formats: &[1]
             },
             Execute {
@@ -1374,12 +1374,12 @@ impl<'conn> Statement<'conn> {
 
     /// Returns a slice containing the expected parameter types.
     pub fn param_types(&self) -> &[Type] {
-        &*self.param_types
+        &self.param_types
     }
 
     /// Returns a slice describing the columns of the result of the query.
     pub fn result_descriptions(&self) -> &[ResultDescription] {
-        &*self.result_desc
+        &self.result_desc
     }
 
     /// Executes the prepared statement, returning the number of rows modified.
@@ -1492,7 +1492,7 @@ impl<'conn> Statement<'conn> {
         self.next_portal_id.set(id + 1);
         let portal_name = format!("{}p{}", self.name, id);
 
-        self.inner_query(&*portal_name, row_limit, params).map(move |(result, more_rows)| {
+        self.inner_query(&portal_name, row_limit, params).map(move |(result, more_rows)| {
             LazyRows {
                 _trans: trans,
                 result: result,
@@ -1724,13 +1724,13 @@ impl<'trans, 'stmt> LazyRows<'trans, 'stmt> {
     fn finish_inner(&mut self) -> Result<()> {
         let mut conn = self.result.stmt.conn.conn.borrow_mut();
         check_desync!(conn);
-        conn.close_statement(&*self.name, b'P')
+        conn.close_statement(&self.name, b'P')
     }
 
     fn execute(&mut self) -> Result<()> {
         try!(self.result.stmt.conn.write_messages(&[
             Execute {
-                portal: &*self.name,
+                portal: &self.name,
                 max_rows: self.row_limit
             },
             Sync]));
@@ -1845,12 +1845,12 @@ impl<'a> CopyInStatement<'a> {
     fn finish_inner(&mut self) -> Result<()> {
         let mut conn = self.conn.conn.borrow_mut();
         check_desync!(conn);
-        conn.close_statement(&*self.name, b'S')
+        conn.close_statement(&self.name, b'S')
     }
 
     /// Returns a slice containing the expected column types.
     pub fn column_types(&self) -> &[Type] {
-        &*self.column_types
+        &self.column_types
     }
 
     /// Executes the prepared statement.
@@ -1868,7 +1868,7 @@ impl<'a> CopyInStatement<'a> {
         try!(conn.write_messages(&[
             Bind {
                 portal: "",
-                statement: &*self.name,
+                statement: &self.name,
                 formats: &[],
                 values: &[],
                 result_formats: &[]
@@ -1917,13 +1917,13 @@ impl<'a> CopyInStatement<'a> {
                             }
                             Ok(Some(val)) => {
                                 let _ = buf.write_be_i32(val.len() as i32);
-                                let _ = buf.write_all(&*val);
+                                let _ = buf.write_all(&val);
                             }
                             Err(err) => {
                                 // FIXME this is not the right way to handle this
                                 try_desync!(conn, conn.stream.write_message(
                                     &CopyFail {
-                                        message: &*err.to_string(),
+                                        message: &err.to_string(),
                                     }));
                                 break 'l;
                             }
@@ -1942,15 +1942,15 @@ impl<'a> CopyInStatement<'a> {
 
             try_desync!(conn, conn.stream.write_message(
                 &CopyData {
-                    data: &*buf
+                    data: &buf
                 }));
             buf.clear();
         }
 
         let _ = buf.write_be_i16(-1);
         try!(conn.write_messages(&[
             CopyData {
-                data: &*buf,
+                data: &buf,
             },
             CopyDone,
             Sync]));