chore: Use let-else in embedders and execution_environment

rs/embedders/src/wasm_executor.rs

@@ -272,15 +272,14 @@ impl WasmExecutor for WasmExecutorImpl {
     ) -> HypervisorResult<(ExecutionState, NumInstructions, Option<CompilationResult>)> {
         // Compile Wasm binary and cache it.
         let wasm_binary = WasmBinary::new(canister_module);
-        let (embedder_cache, serialized_module, compilation_result) =
-            match self.get_embedder_cache(&wasm_binary, compilation_cache)? {
-                CacheLookup {
-                    cache,
-                    serialized_module: Some(serialized_module),
-                    compilation_result,
-                } => (cache, serialized_module, compilation_result),
-                _ => panic!("Newly created WasmBinary must be compiled or deserialized."),
-            };
+        let CacheLookup {
+            cache: embedder_cache,
+            serialized_module: Some(serialized_module),
+            compilation_result,
+        } = self.get_embedder_cache(&wasm_binary, compilation_cache)?
+        else {
+            panic!("Newly created WasmBinary must be compiled or deserialized.")
+        };
         self.observe_metrics(&serialized_module.imports_details);
         let exported_functions = serialized_module.exported_functions.clone();
         let wasm_metadata = serialized_module.wasm_metadata.clone();

rs/embedders/src/wasmtime_embedder.rs

@@ -1064,13 +1064,13 @@ impl WasmtimeInstance {
 
     /// Returns the current instruction counter.
     pub fn instruction_counter(&mut self) -> i64 {
-        match self.store.data().num_instructions_global {
-            Some(num_instructions) => match num_instructions.get(&mut self.store) {
-                Val::I64(instruction_counter) => instruction_counter,
-                _ => panic!("invalid instruction counter type"),
-            },
-            None => panic!("couldn't find the instruction counter in the canister globals"),
-        }
+        let Some(num_instructions) = self.store.data().num_instructions_global else {
+            panic!("couldn't find the instruction counter in the canister globals");
+        };
+        let Val::I64(instruction_counter) = num_instructions.get(&mut self.store) else {
+            panic!("invalid instruction counter type");
+        };
+        instruction_counter
     }
 
     /// Returns the heap size.

rs/embedders/tests/wasmtime_embedder.rs

@@ -244,19 +244,17 @@ mod test {
                 ic_types::methods::WasmMethod::Update("test_performance_counter".to_string()),
             ))
             .unwrap();
-        let performance_counter1 = match res.exported_globals[0] {
-            Global::I64(c) => c as u64,
-            _ => panic!("Error getting performance_counter1"),
+        let Global::I64(performance_counter1) = res.exported_globals[0] else {
+            panic!("Error getting performance_counter1");
         };
-        let performance_counter2 = match res.exported_globals[1] {
-            Global::I64(c) => c as u64,
-            _ => panic!("Error getting performance_counter2"),
+        let Global::I64(performance_counter2) = res.exported_globals[1] else {
+            panic!("Error getting performance_counter2");
         };
         let instruction_counter = instance.instruction_counter();
         let system_api = &instance.store_data().system_api().unwrap();
         let instructions_used = system_api.slice_instructions_executed(instruction_counter);
-        assert_eq!(performance_counter1, expected_instructions_counter1);
-        assert_eq!(performance_counter2, expected_instructions_counter2);
+        assert_eq!(performance_counter1 as u64, expected_instructions_counter1);
+        assert_eq!(performance_counter2 as u64, expected_instructions_counter2);
 
         assert_eq!(instructions_used.get(), expected_instructions);
     }

rs/execution_environment/benches/system_api/execute_update.rs

@@ -358,16 +358,14 @@ pub fn execute_update_bench(c: &mut Criterion) {
                 ExecuteMessageResult::Finished { response, .. } => response,
                 ExecuteMessageResult::Paused { .. } => panic!("Unexpected paused execution"),
             };
-            match response {
-                ExecutionResponse::Ingress((_, status)) => match status {
-                    IngressStatus::Known { state, .. } => {
-                        if let IngressState::Failed(err) = state {
-                            assert_eq!(err.code(), ErrorCode::CanisterDidNotReply)
-                        }
-                    }
-                    _ => panic!("Unexpected ingress status"),
-                },
-                _ => panic!("Expected ingress result"),
+            let ExecutionResponse::Ingress((_, status)) = response else {
+                panic!("Expected ingress result");
+            };
+            let IngressStatus::Known { state, .. } = status else {
+                panic!("Unexpected ingress status");
+            };
+            if let IngressState::Failed(err) = state {
+                assert_eq!(err.code(), ErrorCode::CanisterDidNotReply)
             }
             assert_eq!(
                 expected_instructions,

rs/execution_environment/benches/wasm_instructions/main.rs

@@ -438,16 +438,14 @@ pub fn wasm_instructions_bench(c: &mut Criterion) {
                 ExecuteMessageResult::Finished { response, .. } => response,
                 ExecuteMessageResult::Paused { .. } => panic!("Unexpected paused execution"),
             };
-            match response {
-                ExecutionResponse::Ingress((_, status)) => match status {
-                    IngressStatus::Known { state, .. } => {
-                        if let IngressState::Failed(err) = state {
-                            assert_eq!(err.code(), ErrorCode::CanisterDidNotReply)
-                        }
-                    }
-                    _ => panic!("Unexpected ingress status"),
-                },
-                _ => panic!("Expected ingress result"),
+            let ExecutionResponse::Ingress((_, status)) = response else {
+                panic!("Expected ingress result");
+            };
+            let IngressStatus::Known { state, .. } = status else {
+                panic!("Unexpected ingress status");
+            };
+            if let IngressState::Failed(err) = state {
+                assert_eq!(err.code(), ErrorCode::CanisterDidNotReply)
             }
         },
     );

rs/execution_environment/src/execution/response/tests.rs

@@ -1156,23 +1156,11 @@ fn dts_and_nondts_cycles_match_after_response() {
     let status_a = test_a.ingress_status(&amsg_id);
     let status_b = test_b.ingress_status(&bmsg_id);
     assert_eq!(status_a, status_b);
-    let time_a = match status_a {
-        IngressStatus::Known {
-            receiver: _,
-            user_id: _,
-            time,
-            state: _,
-        } => time,
-        _ => unreachable!(),
+    let IngressStatus::Known { time: time_a, .. } = status_a else {
+        unreachable!();
     };
-    let time_b = match status_b {
-        IngressStatus::Known {
-            receiver: _,
-            user_id: _,
-            time,
-            state: _,
-        } => time,
-        _ => unreachable!(),
+    let IngressStatus::Known { time: time_b, .. } = status_b else {
+        unreachable!();
     };
     assert_eq!(time_a, time_b);
     assert_eq!(start_time, time_a);

rs/execution_environment/src/execution_environment/tests.rs

@@ -1405,18 +1405,15 @@ fn create_canister_xnet_called_from_nns() {
     );
     test.execute_all();
     let response = test.xnet_messages()[0].clone();
-    match response {
-        RequestOrResponse::Response(response) => {
-            assert_eq!(response.originator, nns_canister);
-            assert_eq!(response.respondent, CanisterId::from(own_subnet));
-            assert_eq!(response.refund, Cycles::new(0));
-            match response.response_payload {
-                Payload::Data(_) => (),
-                _ => panic!("Failed creating the canister."),
-            }
-        }
-        _ => panic!("Type should be RequestOrResponse::Response"),
-    }
+    let RequestOrResponse::Response(response) = response else {
+        panic!("Type should be RequestOrResponse::Response");
+    };
+    assert_eq!(response.originator, nns_canister);
+    assert_eq!(response.respondent, CanisterId::from(own_subnet));
+    assert_eq!(response.refund, Cycles::new(0));
+    let Payload::Data(_) = response.response_payload else {
+        panic!("Failed creating the canister.");
+    };
 }
 
 #[test]

rs/execution_environment/src/query_handler/tests.rs

@@ -1398,7 +1398,7 @@ fn query_stats_are_collected() {
 fn test_incorrect_query_name() {
     let test = ExecutionTestBuilder::new().build();
     let method = "unknown method".to_string();
-    match test.query(
+    let Err(err) = test.query(
         UserQuery {
             source: user_test_id(2),
             receiver: CanisterId::ic_00(),
@@ -1409,16 +1409,14 @@ fn test_incorrect_query_name() {
         },
         Arc::new(test.state().clone()),
         vec![],
-    ) {
-        Err(e) => {
-            assert_eq!(e.code(), ErrorCode::CanisterMethodNotFound);
-            assert_eq!(
-                e.description(),
-                format!("Query method {} not found.", method)
-            );
-        }
-        _ => panic!("Unexpected result."),
-    }
+    ) else {
+        panic!("Unexpected result.");
+    };
+    assert_eq!(err.code(), ErrorCode::CanisterMethodNotFound);
+    assert_eq!(
+        err.description(),
+        format!("Query method {} not found.", method)
+    );
 }
 
 #[test]