Merge pull request #358 from danieleades/clippy/let-else

use 'let/else' syntax

Author: dwrensha

benchmark/benchmark.rs

@@ -468,14 +468,11 @@ fn try_main() -> ::capnp::Result<()> {
         args[0]
     );
 
-    let iters = match args[5].parse::<u64>() {
-        Ok(n) => n,
-        Err(_) => {
-            return Err(::capnp::Error::failed(format!(
-                "Could not parse a u64 from: {}",
-                args[5]
-            )))
-        }
+    let Ok(iters) = args[5].parse::<u64>() else {
+        return Err(::capnp::Error::failed(format!(
+            "Could not parse a u64 from: {}",
+            args[5]
+        )))
     };
 
     let mode = Mode::parse(&args[2])?;

capnp-futures/src/serialize.rs

@@ -53,9 +53,8 @@ pub async fn try_read_message<R>(
 where
     R: AsyncRead + Unpin,
 {
-    let segment_lengths_builder = match read_segment_table(&mut reader, options).await? {
-        Some(s) => s,
-        None => return Ok(None),
+    let Some(segment_lengths_builder) = read_segment_table(&mut reader, options).await? else {
+        return Ok(None)
     };
     Ok(Some(
         read_segments(

capnp-rpc/src/lib.rs

@@ -227,11 +227,8 @@ impl<VatId> RpcSystem<VatId> {
     where
         T: ::capnp::capability::FromClientHook,
     {
-        let connection = match self.network.connect(vat_id) {
-            Some(connection) => connection,
-            None => {
-                return T::new(self.bootstrap_cap.clone());
-            }
+        let Some(connection) = self.network.connect(vat_id) else {
+            return T::new(self.bootstrap_cap.clone());
         };
         let connection_state = Self::get_connection_state(
             &self.connection_state,

capnp-rpc/src/rpc.rs

@@ -644,13 +644,10 @@ impl<VatId> ConnectionState<VatId> {
     }
 
     fn message_loop(weak_state: Weak<Self>) -> Promise<(), capnp::Error> {
-        let state = match weak_state.upgrade() {
-            None => {
-                return Promise::err(Error::disconnected(
-                    "message loop cannot continue without a connection".into(),
-                ))
-            }
-            Some(c) => c,
+        let Some(state) = weak_state.upgrade() else {
+            return Promise::err(Error::disconnected(
+                "message loop cannot continue without a connection".into(),
+            ))
         };
 
         let promise = match *state.connection.borrow_mut() {
@@ -896,13 +893,10 @@ impl<VatId> ConnectionState<VatId> {
         weak_state: &Weak<Self>,
         message: Box<dyn crate::IncomingMessage>,
     ) -> ::capnp::Result<()> {
-        let connection_state = match weak_state.upgrade() {
-            None => {
-                return Err(Error::disconnected(
-                    "handle_message() cannot continue without a connection".into(),
-                ))
-            }
-            Some(c) => c,
+        let Some(connection_state) = weak_state.upgrade() else {
+            return Err(Error::disconnected(
+                "handle_message() cannot continue without a connection".into(),
+            ))
         };
 
         let reader = message.get_body()?.get_as::<message::Reader>()?;
@@ -2048,11 +2042,8 @@ impl<VatId> Pipeline<VatId> {
             let this = Rc::downgrade(&state);
             let resolve_self_promise =
                 connection_state.eagerly_evaluate(fork.clone().then(move |response| {
-                    let state = match this.upgrade() {
-                        Some(s) => s,
-                        None => {
-                            return Promise::err(Error::failed("dangling reference to this".into()))
-                        }
+                    let Some(state) = this.upgrade() else {
+                        return Promise::err(Error::failed("dangling reference to this".into()))
                     };
                     PipelineState::resolve(&state, response);
                     Promise::ok(())

capnp/src/serialize.rs

@@ -75,9 +75,8 @@ pub fn read_message_from_flat_slice<'a>(
     let all_bytes = *slice;
     let mut bytes = *slice;
     let orig_bytes_len = bytes.len();
-    let segment_lengths_builder = match read_segment_table(&mut bytes, options)? {
-        Some(b) => b,
-        None => return Err(Error::failed("empty slice".to_string())),
+    let Some(segment_lengths_builder) = read_segment_table(&mut bytes, options)? else {
+        return Err(Error::failed("empty slice".to_string()))
     };
     let segment_table_bytes_len = orig_bytes_len - bytes.len();
     assert_eq!(segment_table_bytes_len % BYTES_PER_WORD, 0);
@@ -138,9 +137,8 @@ impl<T: Deref<Target = [u8]>> BufferSegments<T> {
     pub fn new(buffer: T, options: message::ReaderOptions) -> Result<Self> {
         let mut segment_bytes = &*buffer;
 
-        let segment_table = match read_segment_table(&mut segment_bytes, options)? {
-            Some(b) => b,
-            None => return Err(Error::failed("empty buffer".to_string())),
+        let Some(segment_table) = read_segment_table(&mut segment_bytes, options)? else {
+            return Err(Error::failed("empty buffer".to_string()))
         };
         let segment_table_bytes_len = buffer.len() - segment_bytes.len();
 
@@ -280,9 +278,8 @@ pub fn read_message<R>(
 where
     R: Read,
 {
-    let owned_segments_builder = match read_segment_table(&mut read, options)? {
-        Some(b) => b,
-        None => return Err(Error::failed("Premature end of file".to_string())),
+    let Some(owned_segments_builder) = read_segment_table(&mut read, options)? else {
+        return Err(Error::failed("Premature end of file".to_string()))
     };
     read_segments(
         &mut read,
@@ -301,10 +298,7 @@ pub fn try_read_message<R>(
 where
     R: Read,
 {
-    let owned_segments_builder = match read_segment_table(&mut read, options)? {
-        Some(b) => b,
-        None => return Ok(None),
-    };
+    let Some(owned_segments_builder) = read_segment_table(&mut read, options)? else { return Ok(None) };
     Ok(Some(read_segments(
         &mut read,
         owned_segments_builder.into_owned_segments(),

capnpc/src/codegen.rs

@@ -443,10 +443,7 @@ fn populate_scope_map(
     node_id: u64,
 ) -> ::capnp::Result<()> {
     // unused nodes in imported files might be omitted from the node map
-    let node_reader = match node_map.get(&node_id) {
-        Some(node) => node,
-        None => return Ok(()),
-    };
+    let Some(node_reader) = node_map.get(&node_id) else { return Ok(()) };
 
     for annotation in node_reader.get_annotations()?.iter() {
         if annotation.get_id() == NAME_ANNOTATION_ID {
@@ -1164,10 +1161,7 @@ fn used_params_of_brand(
     let brand_scopes = brand_scopes; // freeze
     let mut current_node_id = node_id;
     loop {
-        let current_node = match gen.node_map.get(&current_node_id) {
-            None => break,
-            Some(node) => node,
-        };
+        let Some(current_node) = gen.node_map.get(&current_node_id) else { break };
         let params = current_node.get_parameters()?;
         match brand_scopes.get(&current_node_id) {
             None => (),

capnpc/src/codegen_types.rs

@@ -373,10 +373,7 @@ pub fn do_branding(
     let mut current_node_id = node_id;
     let mut accumulator: Vec<Vec<String>> = Vec::new();
     loop {
-        let current_node = match gen.node_map.get(&current_node_id) {
-            None => break,
-            Some(node) => node,
-        };
+        let Some(current_node) = gen.node_map.get(&current_node_id) else { break };
         let params = current_node.get_parameters()?;
         let mut arguments: Vec<String> = Vec::new();
         match brand_scopes.get(&current_node_id) {
@@ -448,9 +445,8 @@ pub fn get_type_parameters(
     let mut current_node_id = node_id;
     let mut accumulator: Vec<Vec<String>> = Vec::new();
     loop {
-        let current_node = match gen.node_map.get(&current_node_id) {
-            None => break,
-            Some(node) => node,
+        let Some(current_node) = gen.node_map.get(&current_node_id) else {
+            break
         };
         let mut params = Vec::new();
         for param in current_node.get_parameters().unwrap().iter() {