Merge pull request #166 from austinvazquez/fix-needless-borrow

ttrpc: fix lint errors in build

Author: Tim-Zhang

build.rs

@@ -14,7 +14,7 @@ fn main() {
     protobuf_codegen::Codegen::new()
         .pure()
         .out_dir(out_dir)
-        .inputs(&["src/ttrpc.proto"])
+        .inputs(["src/ttrpc.proto"])
         .include("src")
         .customize(customize)
         .run()

src/asynchronous/client.rs

@@ -97,7 +97,7 @@ impl Client {
         };
 
         let msg = result?;
-        let res = Response::decode(&msg.payload)
+        let res = Response::decode(msg.payload)
             .map_err(err_to_others_err!(e, "Unpack response error "))?;
 
         let status = res.status();

src/asynchronous/stream.rs

@@ -103,7 +103,7 @@ where
 {
     pub async fn recv(&mut self) -> Result<P> {
         let msg_buf = self.rx.recv().await?;
-        P::decode(&msg_buf).map_err(err_to_others_err!(e, "Decode message failed."))
+        P::decode(msg_buf).map_err(err_to_others_err!(e, "Decode message failed."))
     }
 }
 
@@ -184,7 +184,7 @@ where
             return Ok(None);
         }
         let msg_buf = res?;
-        Q::decode(&msg_buf)
+        Q::decode(msg_buf)
             .map_err(err_to_others_err!(e, "Decode message failed."))
             .map(Some)
     }
@@ -221,7 +221,7 @@ where
     pub async fn close_and_recv(&mut self) -> Result<P> {
         self.inner.close_send().await?;
         let msg_buf = self.inner.recv().await?;
-        P::decode(&msg_buf).map_err(err_to_others_err!(e, "Decode message failed."))
+        P::decode(msg_buf).map_err(err_to_others_err!(e, "Decode message failed."))
     }
 }
 
@@ -273,7 +273,7 @@ where
             return Ok(None);
         }
         let msg_buf = res?;
-        P::decode(&msg_buf)
+        P::decode(msg_buf)
             .map_err(err_to_others_err!(e, "Decode message failed."))
             .map(Some)
     }
@@ -302,7 +302,7 @@ where
             return Ok(None);
         }
         let msg_buf = res?;
-        Q::decode(&msg_buf)
+        Q::decode(msg_buf)
             .map_err(err_to_others_err!(e, "Decode message failed."))
             .map(Some)
     }

src/proto.rs

@@ -398,7 +398,7 @@ mod tests {
         assert_eq!(&buf, &PROTOBUF_REQUEST);
         let dreq = Request::decode(&buf).unwrap();
         assert_eq!(creq, dreq);
-        let dreq2 = Request::decode(&PROTOBUF_REQUEST).unwrap();
+        let dreq2 = Request::decode(PROTOBUF_REQUEST).unwrap();
         assert_eq!(creq, dreq2);
     }
 
@@ -470,7 +470,7 @@ mod tests {
         buf.extend_from_slice(&[0x0, 0x0]);
         let msg = Message::<Request>::read_from(&*buf).await.unwrap();
         assert_eq!(msg.header.length, 67);
-        assert_eq!(msg.header.length, msg.payload.size() as u32);
+        assert_eq!(msg.header.length, msg.payload.size());
         assert_eq!(msg.header.stream_id, 0x123456);
         assert_eq!(msg.header.type_, MESSAGE_TYPE_REQUEST);
         assert_eq!(msg.header.flags, 0xef);

src/sync/client.rs

@@ -229,7 +229,7 @@ impl Client {
 
         let buf = result?;
         let res =
-            Response::decode(&buf).map_err(err_to_others_err!(e, "Unpack response error "))?;
+            Response::decode(buf).map_err(err_to_others_err!(e, "Unpack response error "))?;
 
         let status = res.status();
         if status.code() != Code::OK {

ttrpc-codegen/src/convert.rs

@@ -495,7 +495,7 @@ impl<'a> Resolver<'a> {
             for (oneof_index, oneof) in input.oneofs.iter().enumerate() {
                 let oneof_index = oneof_index as i32;
                 for f in &oneof.fields {
-                    fields.push(self.field(f, Some(oneof_index as i32), &nested_path_in_file)?);
+                    fields.push(self.field(f, Some(oneof_index), &nested_path_in_file)?);
                 }
             }
 
@@ -908,7 +908,7 @@ impl<'a> Resolver<'a> {
                 if field_type != &model::FieldType::Bool {
                     Err(())
                 } else {
-                    Ok(protobuf::UnknownValue::Varint(if b { 1 } else { 0 }))
+                    Ok(protobuf::UnknownValue::Varint(u64::from(b)))
                 }
             }
             // TODO: check overflow
@@ -938,7 +938,7 @@ impl<'a> Resolver<'a> {
                 | model::FieldType::Int32
                 | model::FieldType::Uint64
                 | model::FieldType::Uint32 => Ok(protobuf::UnknownValue::Varint(v as u64)),
-                model::FieldType::Sint64 => Ok(protobuf::UnknownValue::sint64(v as i64)),
+                model::FieldType::Sint64 => Ok(protobuf::UnknownValue::sint64(v)),
                 model::FieldType::Sint32 => Ok(protobuf::UnknownValue::sint32(v as i32)),
                 _ => Err(()),
             },

ttrpc-codegen/src/lib.rs

@@ -258,7 +258,7 @@ impl<'a> Run<'a> {
         let mut this_file_deps = HashMap::new();
         self.get_all_deps_already_parsed(&parsed, &mut this_file_deps);
 
-        let this_file_deps: Vec<_> = this_file_deps.into_iter().map(|(_, v)| v.parsed).collect();
+        let this_file_deps: Vec<_> = this_file_deps.into_values().map(|v| v.parsed).collect();
 
         let descriptor =
             convert::file_descriptor(protobuf_path.to_owned(), &parsed, &this_file_deps).map_err(
@@ -346,8 +346,8 @@ pub fn parse_and_typecheck(
 
     let file_descriptors: Vec<_> = run
         .parsed_files
-        .into_iter()
-        .map(|(_, v)| v.descriptor)
+        .into_values()
+        .map(|v| v.descriptor)
         .collect();
 
     Ok(ParsedAndTypechecked {

ttrpc-codegen/src/parser.rs

@@ -347,16 +347,11 @@ impl<'a> Lexer<'a> {
     }
 
     fn next_char_if_eq(&mut self, expect: char) -> bool {
-        self.next_char_if(|c| c == expect) != None
+        self.next_char_if(|c| c == expect).is_some()
     }
 
     fn next_char_if_in(&mut self, alphabet: &str) -> Option<char> {
-        for c in alphabet.chars() {
-            if self.next_char_if_eq(c) {
-                return Some(c);
-            }
-        }
-        None
+        alphabet.chars().find(|&c| self.next_char_if_eq(c))
     }
 
     fn next_char_expect_eq(&mut self, expect: char) -> ParserResult<()> {
@@ -430,7 +425,7 @@ impl<'a> Lexer<'a> {
         Ok(
             if self.skip_if_lookahead_is_str("0x") || self.skip_if_lookahead_is_str("0X") {
                 let s = self.take_while(Lexer::is_ascii_hexdigit);
-                Some(u64::from_str_radix(s, 16)? as u64)
+                Some(u64::from_str_radix(s, 16)?)
             } else {
                 None
             },
@@ -449,7 +444,7 @@ impl<'a> Lexer<'a> {
 
         let pos = clone.pos;
 
-        Ok(if clone.next_char_if(Lexer::is_ascii_digit) != None {
+        Ok(if clone.next_char_if(Lexer::is_ascii_digit).is_some() {
             clone.take_while(Lexer::is_ascii_digit);
             let value = clone.input[pos..clone.pos].parse()?;
             *self = clone;
@@ -517,7 +512,7 @@ impl<'a> Lexer<'a> {
 
     // exponent  = ( "e" | "E" ) [ "+" | "-" ] decimals
     fn next_exponent_opt(&mut self) -> ParserResult<Option<()>> {
-        if self.next_char_if_in("eE") != None {
+        if self.next_char_if_in("eE").is_some() {
             self.next_char_if_in("+-");
             self.next_decimal_digits()?;
             Ok(Some(()))
@@ -537,7 +532,7 @@ impl<'a> Lexer<'a> {
             if self.next_char_if_eq('.') {
                 self.next_decimal_digits()?;
                 self.next_exponent_opt()?;
-            } else if self.next_exponent_opt()? == None {
+            } else if (self.next_exponent_opt()?).is_none() {
                 return Err(ParserError::IncorrectFloatLit);
             }
         }
@@ -931,7 +926,7 @@ impl<'a> Parser<'a> {
     }
 
     fn next_ident_if_eq(&mut self, word: &str) -> ParserResult<bool> {
-        Ok(self.next_ident_if_in(&[word])? != None)
+        Ok((self.next_ident_if_in(&[word])?).is_some())
     }
 
     pub fn next_ident_expect_eq(&mut self, word: &str) -> ParserResult<()> {
@@ -950,7 +945,10 @@ impl<'a> Parser<'a> {
     }
 
     fn next_symbol_if_eq(&mut self, symbol: char) -> ParserResult<bool> {
-        Ok(self.next_token_if(|token| matches!(*token, Token::Symbol(c) if c == symbol))? != None)
+        Ok(
+            (self.next_token_if(|token| matches!(*token, Token::Symbol(c) if c == symbol))?)
+                .is_some(),
+        )
     }
 
     fn next_symbol_expect_eq(&mut self, symbol: char) -> ParserResult<()> {