Merge pull request #343 from danieleades/clippy/general

Clippy/general

Author: dwrensha

benchmark/benchmark.rs

@@ -106,7 +106,7 @@ impl Serialize for NoCompression {
         W: io::Write,
         A: message::Allocator,
     {
-        serialize::write_message(write, message).map_err(|e| e.into())
+        serialize::write_message(write, message)
     }
 }
 
@@ -133,7 +133,7 @@ impl Serialize for Packed {
         W: io::Write,
         A: message::Allocator,
     {
-        serialize_packed::write_message(write, message).map_err(|e| e.into())
+        serialize_packed::write_message(write, message)
     }
 }
 
@@ -161,15 +161,21 @@ pub struct UseScratch {
     buffer2: Vec<capnp::Word>,
 }
 
-impl UseScratch {
-    pub fn new() -> Self {
+impl Default for UseScratch {
+    fn default() -> Self {
         Self {
             buffer1: capnp::Word::allocate_zeroed_vec(SCRATCH_SIZE),
             buffer2: capnp::Word::allocate_zeroed_vec(SCRATCH_SIZE),
         }
     }
 }
 
+impl UseScratch {
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
 impl<'a> Scratch<'a> for UseScratch {
     type Allocator = message::ScratchSpaceHeapAllocator<'a>;
 
@@ -231,7 +237,7 @@ where
 
             {
                 let mut writer: &mut [u8] = &mut request_bytes;
-                compression.write_message(&mut writer, &mut message_req)?;
+                compression.write_message(&mut writer, &message_req)?;
             }
 
             let mut request_bytes1: &[u8] = &request_bytes;
@@ -244,7 +250,7 @@ where
 
         {
             let mut writer: &mut [u8] = &mut response_bytes;
-            compression.write_message(&mut writer, &mut message_res)?;
+            compression.write_message(&mut writer, &message_res)?;
         }
 
         let mut response_bytes1: &[u8] = &response_bytes;
@@ -286,7 +292,7 @@ where
             testcase.handle_request(request_reader, response)?;
         }
 
-        compression.write_message(&mut out_buffered, &mut message_res)?;
+        compression.write_message(&mut out_buffered, &message_res)?;
         out_buffered.flush()?;
     }
     Ok(())
@@ -317,7 +323,7 @@ where
             let request = message_req.init_root();
             testcase.setup_request(&mut rng, request)
         };
-        compression.write_message(&mut out_buffered, &mut message_req)?;
+        compression.write_message(&mut out_buffered, &message_req)?;
         out_buffered.flush()?;
 
         let message_reader = compression.read_message(&mut in_buffered, Default::default())?;
@@ -472,11 +478,11 @@ fn try_main() -> ::capnp::Result<()> {
         }
     };
 
-    let mode = Mode::parse(&*args[2])?;
+    let mode = Mode::parse(&args[2])?;
 
     match &*args[4] {
-        "none" => do_testcase2(&*args[1], mode, &*args[3], NoCompression, iters),
-        "packed" => do_testcase2(&*args[1], mode, &*args[3], Packed, iters),
+        "none" => do_testcase2(&args[1], mode, &args[3], NoCompression, iters),
+        "packed" => do_testcase2(&args[1], mode, &args[3], Packed, iters),
         s => Err(::capnp::Error::failed(format!(
             "unrecognized compression: {}",
             s

benchmark/carsales.rs

@@ -78,8 +78,8 @@ macro_rules! car_value_impl(
 car_value_impl!(Reader);
 car_value_impl!(Builder);
 
-const MAKES: [&'static str; 5] = ["Toyota", "GM", "Ford", "Honda", "Tesla"];
-const MODELS: [&'static str; 6] = ["Camry", "Prius", "Volt", "Accord", "Leaf", "Model S"];
+const MAKES: [&str; 5] = ["Toyota", "GM", "Ford", "Honda", "Tesla"];
+const MODELS: [&str; 6] = ["Camry", "Prius", "Volt", "Accord", "Leaf", "Model S"];
 
 pub fn random_car(rng: &mut FastRand, mut car: car::Builder) {
     car.set_make(MAKES[rng.next_less_than(MAKES.len() as u32) as usize]);

benchmark/catrank.rs

@@ -28,7 +28,7 @@ pub struct ScoredResult<'a> {
     result: search_result::Reader<'a>,
 }
 
-const URL_PREFIX: &'static str = "http://example.com";
+const URL_PREFIX: &str = "http://example.com";
 
 pub struct CatRank;
 
@@ -108,10 +108,7 @@ impl crate::TestCase for CatRank {
             if snippet.contains(" dog ") {
                 score /= 10000.0;
             }
-            scored_results.push(ScoredResult {
-                score: score,
-                result: result,
-            });
+            scored_results.push(ScoredResult { score, result });
         }
 
         // sort in decreasing order

benchmark/common.rs

@@ -29,15 +29,21 @@ pub struct FastRand {
     w: u32,
 }
 
-impl FastRand {
-    pub fn new() -> Self {
+impl Default for FastRand {
+    fn default() -> Self {
         Self {
             x: 0x1d2acd47,
             y: 0x58ca3e14,
             z: 0xf563f232,
             w: 0x0bc76199,
         }
     }
+}
+
+impl FastRand {
+    pub fn new() -> FastRand {
+        Self::default()
+    }
 
     #[inline]
     pub fn next_u32(&mut self) -> u32 {
@@ -46,7 +52,7 @@ impl FastRand {
         self.y = self.z;
         self.z = self.w;
         self.w = self.w ^ (self.w >> 19) ^ tmp ^ (tmp >> 8);
-        return self.w;
+        self.w
     }
 
     #[inline]
@@ -74,7 +80,7 @@ pub fn div(a: i32, b: i32) -> i32 {
     if a == i32::MIN && b == -1 {
         return i32::MAX;
     }
-    return a / b;
+    a / b
 }
 
 #[inline]
@@ -85,10 +91,10 @@ pub fn modulus(a: i32, b: i32) -> i32 {
     if a == i32::MIN && b == -1 {
         return i32::MAX;
     }
-    return a % b;
+    a % b
 }
 
-pub const WORDS: [&'static str; 13] = [
+pub const WORDS: [&str; 13] = [
     "foo ", "bar ", "baz ", "qux ", "quux ", "corge ", "grault ", "garply ", "waldo ", "fred ",
     "plugh ", "xyzzy ", "thud ",
 ];

benchmark/eval.rs

@@ -42,11 +42,11 @@ fn make_expression(rng: &mut FastRand, mut exp: expression::Builder, depth: u32)
     };
 
     match exp.get_op().unwrap() {
-        Operation::Add => return left + right,
-        Operation::Subtract => return left - right,
-        Operation::Multiply => return left * right,
-        Operation::Divide => return div(left, right),
-        Operation::Modulus => return modulus(left, right),
+        Operation::Add => left + right,
+        Operation::Subtract => left - right,
+        Operation::Multiply => left * right,
+        Operation::Divide => div(left, right),
+        Operation::Modulus => modulus(left, right),
     }
 }
 

capnp-futures/src/serialize.rs

@@ -231,8 +231,8 @@ where
                     .copy_from_slice(&((segments[idx].len() / 8) as u32).to_le_bytes());
             }
             if segment_count == 2 {
-                for idx in 4..8 {
-                    buf[idx] = 0
+                for value in &mut buf[4..8] {
+                    *value = 0;
                 }
             }
             write.write_all(&buf).await?;
@@ -258,8 +258,8 @@ async fn write_segments<W>(mut write: W, segments: &[&[u8]]) -> Result<()>
 where
     W: AsyncWrite + Unpin,
 {
-    for i in 0..segments.len() {
-        write.write_all(segments[i]).await?;
+    for segment in segments {
+        write.write_all(segment).await?;
     }
     Ok(())
 }

capnp-futures/src/serialize_packed.rs

@@ -122,8 +122,8 @@ where
                 PackedReadStage::WritingZeroes => {
                     let num_zeroes = std::cmp::min(outbuf.len(), *num_run_bytes_remaining);
 
-                    for ii in 0..num_zeroes {
-                        outbuf[ii] = 0;
+                    for value in outbuf.iter_mut().take(num_zeroes) {
+                        *value = 0;
                     }
                     if num_zeroes >= *num_run_bytes_remaining {
                         *buf_pos = 0;

capnp-futures/src/write_queue.rs

@@ -101,6 +101,10 @@ where
         unimplemented!()
     }
 
+    pub fn is_empty(&mut self) -> bool {
+        self.len() == 0
+    }
+
     /// Commands the queue to stop writing messages once it is empty. After this method has been called,
     /// any new calls to `send()` will return a future that immediately resolves to an error.
     /// If the passed-in `result` is an error, then the `WriteQueue` will resolve to that error.

capnp-rpc/examples/calculator/server.rs

@@ -36,7 +36,7 @@ struct ValueImpl {
 
 impl ValueImpl {
     fn new(value: f64) -> Self {
-        Self { value: value }
+        Self { value }
     }
 }
 
@@ -80,8 +80,8 @@ fn evaluate_impl(
                 let mut request = func.call_request();
                 {
                     let mut params = request.get().init_params(param_values.len() as u32);
-                    for ii in 0..param_values.len() {
-                        params.set(ii as u32, param_values[ii]);
+                    for (ii, value) in param_values.iter().enumerate() {
+                        params.set(ii as u32, *value);
                     }
                 }
                 Ok(request.send().promise.await?.get()?.get_value())
@@ -98,7 +98,7 @@ struct FunctionImpl {
 impl FunctionImpl {
     fn new(param_count: u32, body: calculator::expression::Reader) -> ::capnp::Result<Self> {
         let mut result = Self {
-            param_count: param_count,
+            param_count,
             body: ::capnp_rpc::ImbuedMessageBuilder::new(::capnp::message::HeapAllocator::new()),
         };
         result.body.set_root(body)?;
@@ -196,7 +196,7 @@ impl calculator::Server for CalculatorImpl {
         let op = pry!(pry!(params.get()).get_op());
         results
             .get()
-            .set_func(capnp_rpc::new_client(OperatorImpl { op: op }));
+            .set_func(capnp_rpc::new_client(OperatorImpl { op }));
         Promise::ok(())
     }
 }

capnp-rpc/examples/pubsub/server.rs

@@ -54,10 +54,7 @@ struct SubscriptionImpl {
 
 impl SubscriptionImpl {
     fn new(id: u64, subscribers: Rc<RefCell<SubscriberMap>>) -> Self {
-        Self {
-            id: id,
-            subscribers: subscribers,
-        }
+        Self { id, subscribers }
     }
 }
 
@@ -83,7 +80,7 @@ impl PublisherImpl {
                 next_id: 0,
                 subscribers: subscribers.clone(),
             },
-            subscribers.clone(),
+            subscribers,
         )
     }
 }
@@ -175,11 +172,11 @@ pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
                             tokio::task::spawn_local(request.send().promise.map(
                                 move |r| match r {
                                     Ok(_) => {
-                                        subscribers2.borrow_mut().subscribers.get_mut(&idx).map(
-                                            |ref mut s| {
-                                                s.requests_in_flight -= 1;
-                                            },
-                                        );
+                                        if let Some(ref mut s) =
+                                            subscribers2.borrow_mut().subscribers.get_mut(&idx)
+                                        {
+                                            s.requests_in_flight -= 1;
+                                        }
                                     }
                                     Err(e) => {
                                         println!("Got error: {:?}. Dropping subscriber.", e);