Clippy/general (#361)

* use inline format args

* remove redundant clones

* remove needless borrowed reference

* remove needless 'to_string'

* nest 'or' patterns

* use 'Self' keyword to refer to own type

Author: danieleades

benchmark/benchmark.rs

@@ -365,7 +365,7 @@ where
             Ok(())
         }
         Err(e) => {
-            println!("could not start process: {}", e);
+            println!("could not start process: {e}");
             Ok(())
         }
     }
@@ -387,7 +387,7 @@ impl Mode {
             "client" => Ok(Self::Client),
             "server" => Ok(Self::Server),
             "pipe" => Ok(Self::Pipe),
-            s => Err(::capnp::Error::failed(format!("unrecognized mode: {}", s))),
+            s => Err(::capnp::Error::failed(format!("unrecognized mode: {s}"))),
         }
     }
 }
@@ -433,8 +433,7 @@ where
         "catrank" => do_testcase(catrank::CatRank, mode, scratch, compression, iters),
         "eval" => do_testcase(eval::Eval, mode, scratch, compression, iters),
         s => Err(::capnp::Error::failed(format!(
-            "unrecognized test case: {}",
-            s
+            "unrecognized test case: {s}"
         ))),
     }
 }
@@ -453,8 +452,7 @@ where
         "no-reuse" => do_testcase1(case, mode, NoScratch, compression, iters),
         "reuse" => do_testcase1(case, mode, UseScratch::new(), compression, iters),
         s => Err(::capnp::Error::failed(format!(
-            "unrecognized reuse option: {}",
-            s
+            "unrecognized reuse option: {s}"
         ))),
     }
 }
@@ -481,8 +479,7 @@ fn try_main() -> ::capnp::Result<()> {
         "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
+            "unrecognized compression: {s}"
         ))),
     }
 }

benchmark/catrank.rs

@@ -151,8 +151,7 @@ impl crate::TestCase for CatRank {
             Ok(())
         } else {
             Err(::capnp::Error::failed(format!(
-                "check_response() expected {} but got {}",
-                expected_good_count, good_count
+                "check_response() expected {expected_good_count} but got {good_count}"
             )))
         }
     }

benchmark/common.rs

@@ -41,7 +41,7 @@ impl Default for FastRand {
 }
 
 impl FastRand {
-    pub fn new() -> FastRand {
+    pub fn new() -> Self {
         Self::default()
     }
 

benchmark/run_all.rs

@@ -35,9 +35,9 @@ fn run_one(
         .arg(mode)
         .arg(scratch)
         .arg(compression)
-        .arg(format!("{}", iteration_count));
+        .arg(format!("{iteration_count}"));
 
-    println!("{} {} {}", mode, compression, scratch);
+    println!("{mode} {compression} {scratch}");
     let start_time = time::Instant::now();
     let result_status = command.spawn().unwrap().wait().unwrap();
     let elapsed = start_time.elapsed();
@@ -91,18 +91,18 @@ fn try_main() -> ::capnp::Result<()> {
 
     let executable = &*args[1];
 
-    println!("running carsales with {} iterations", carsales_iters);
+    println!("running carsales with {carsales_iters} iterations");
     run_case(
         executable,
         "carsales",
         &["reuse", "no-reuse"],
         carsales_iters,
     );
 
-    println!("running catrank with {} iterations", catrank_iters);
+    println!("running catrank with {catrank_iters} iterations");
     run_case(executable, "catrank", &["no-reuse"], catrank_iters);
 
-    println!("running eval with {} iterations", eval_iters);
+    println!("running eval with {eval_iters} iterations");
     run_case(executable, "eval", &["no-reuse"], eval_iters);
 
     Ok(())

capnp-rpc/examples/calculator/server.rs

@@ -66,7 +66,7 @@ fn evaluate_impl(
         ),
         calculator::expression::Parameter(p) => match params {
             Some(params) if p < params.len() => Promise::ok(params.get(p)),
-            _ => Promise::err(Error::failed(format!("bad parameter: {}", p))),
+            _ => Promise::err(Error::failed(format!("bad parameter: {p}"))),
         },
         calculator::expression::Call(call) => {
             let func = pry!(call.get_function());
@@ -232,7 +232,7 @@ pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
                 );
 
                 let rpc_system = RpcSystem::new(Box::new(network), Some(calc.clone().client));
-                tokio::task::spawn_local(rpc_system.map_err(|e| println!("error: {:?}", e)));
+                tokio::task::spawn_local(rpc_system.map_err(|e| println!("error: {e:?}")));
             }
         })
         .await

capnp-rpc/examples/hello-world/server.rs

@@ -37,7 +37,7 @@ impl hello_world::Server for HelloWorldImpl {
     ) -> Promise<(), ::capnp::Error> {
         let request = pry!(pry!(params.get()).get_request());
         let name = pry!(request.get_name());
-        let message = format!("Hello, {}!", name);
+        let message = format!("Hello, {name}!");
 
         results.get().init_reply().set_message(&message);
 

capnp-rpc/examples/pubsub/server.rs

@@ -179,7 +179,7 @@ pub async fn main() -> Result<(), Box<dyn std::error::Error>> {
                                         }
                                     }
                                     Err(e) => {
-                                        println!("Got error: {:?}. Dropping subscriber.", e);
+                                        println!("Got error: {e:?}. Dropping subscriber.");
                                         subscribers2.borrow_mut().subscribers.remove(&idx);
                                     }
                                 },

capnp-rpc/src/lib.rs

@@ -275,7 +275,7 @@ impl<VatId> RpcSystem<VatId> {
                     *connection_state_ref1.borrow_mut() = None;
                     match shutdown_promise {
                         Ok(s) => s,
-                        Err(e) => Promise::err(Error::failed(format!("{}", e))),
+                        Err(e) => Promise::err(Error::failed(format!("{e}"))),
                     }
                 }));
                 rpc::ConnectionState::new(bootstrap_cap, connection, on_disconnect_fulfiller)
@@ -405,7 +405,7 @@ where
 struct SystemTaskReaper;
 impl crate::task_set::TaskReaper<Error> for SystemTaskReaper {
     fn task_failed(&mut self, error: Error) {
-        println!("ERROR: {}", error);
+        println!("ERROR: {error}");
     }
 }
 

capnp-rpc/src/rpc.rs

@@ -378,7 +378,7 @@ fn remote_exception_to_error(exception: exception::Reader) -> Error {
         _ => (::capnp::ErrorKind::Failed, "(malformed error)"),
     };
     Error {
-        description: format!("remote exception: {}", reason),
+        description: format!("remote exception: {reason}"),
         kind,
     }
 }
@@ -783,15 +783,13 @@ impl<VatId> ConnectionState<VatId> {
         match answers_slots.get_mut(&answer_id) {
             None => {
                 return Err(Error::failed(format!(
-                    "Invalid question ID {} in Finish message.",
-                    answer_id
+                    "Invalid question ID {answer_id} in Finish message."
                 )));
             }
             Some(answer) => {
                 if !answer.active {
                     return Err(Error::failed(format!(
-                        "'Finish' for invalid question ID {}.",
-                        answer_id
+                        "'Finish' for invalid question ID {answer_id}."
                     )));
                 }
                 answer.received_finish.set(true);
@@ -939,8 +937,7 @@ impl<VatId> ConnectionState<VatId> {
                     .contains_key(&question_id)
                 {
                     return Err(Error::failed(format!(
-                        "Received a new call on in-use question id {}",
-                        question_id
+                        "Received a new call on in-use question id {question_id}"
                     )));
                 }
 
@@ -994,7 +991,7 @@ impl<VatId> ConnectionState<VatId> {
                         if let Some(f) = redirected_results_done_fulfiller {
                             match v {
                                 Ok(r) => drop(f.send(Ok(Response::redirected(r.clone())))),
-                                Err(e) => drop(f.send(Err(e.clone()))),
+                                Err(e) => drop(f.send(Err(e))),
                             }
                         }
                         Promise::ok(())
@@ -1095,8 +1092,7 @@ impl<VatId> ConnectionState<VatId> {
                     }
                     None => {
                         return Err(Error::failed(format!(
-                            "Invalid question ID in Return message: {}",
-                            question_id
+                            "Invalid question ID in Return message: {question_id}"
                         )));
                     }
                 }
@@ -1146,11 +1142,13 @@ impl<VatId> ConnectionState<VatId> {
             Ok(message::Disembargo(disembargo)) => {
                 Self::handle_disembargo(&connection_state, disembargo?)?
             }
-            Ok(message::Provide(_))
-            | Ok(message::Accept(_))
-            | Ok(message::Join(_))
-            | Ok(message::ObsoleteSave(_))
-            | Ok(message::ObsoleteDelete(_))
+            Ok(
+                message::Provide(_)
+                | message::Accept(_)
+                | message::Join(_)
+                | message::ObsoleteSave(_)
+                | message::ObsoleteDelete(_),
+            )
             | Err(::capnp::NotInSchema(_)) => {
                 Self::send_unimplemented(&connection_state, &message)?;
             }
@@ -1225,7 +1223,7 @@ impl<VatId> ConnectionState<VatId> {
         match target.which()? {
             message_target::ImportedCap(export_id) => {
                 match self.exports.borrow().slots.get(export_id as usize) {
-                    Some(&Some(ref exp)) => Ok(exp.client_hook.clone()),
+                    Some(Some(exp)) => Ok(exp.client_hook.clone()),
                     _ => Err(Error::failed(
                         "Message target is not a current export ID.".to_string(),
                     )),

capnp-rpc/test/test.rs

@@ -340,8 +340,7 @@ fn pipelining_return_null() {
                     Ok(())
                 } else {
                     Err(Error::failed(format!(
-                        "Should have gotten null capability error. Instead got {:?}",
-                        e
+                        "Should have gotten null capability error. Instead got {e:?}"
                     )))
                 }
             }