nightly bump: cleanups made obvious by clippy

boards/configurations/nrf52840dk/nrf52840dk-test-kernel/src/io.rs

@@ -55,15 +55,11 @@ impl IoWrite for Writer {
                     });
                 }
                 for &c in buf {
-                    unsafe {
-                        uart.send_byte(c);
-                    }
+                    unsafe { uart.send_byte(c) }
                     while !uart.tx_ready() {}
                 }
             }
-            Writer::WriterRtt(rtt_memory) => {
-                rtt_memory.write_sync(buf);
-            }
+            Writer::WriterRtt(rtt_memory) => rtt_memory.write_sync(buf),
         }
         buf.len()
     }

boards/nordic/nrf52840dk/src/io.rs

@@ -47,15 +47,11 @@ impl IoWrite for Writer {
                     });
                 }
                 for &c in buf {
-                    unsafe {
-                        uart.send_byte(c);
-                    }
+                    unsafe { uart.send_byte(c) }
                     while !uart.tx_ready() {}
                 }
             }
-            Writer::WriterRtt(rtt_memory) => {
-                rtt_memory.write_sync(buf);
-            }
+            Writer::WriterRtt(rtt_memory) => rtt_memory.write_sync(buf),
         }
         buf.len()
     }

boards/particle_boron/src/io.rs

@@ -49,9 +49,7 @@ impl IoWrite for Writer {
                     });
                 }
                 for &c in buf {
-                    unsafe {
-                        uart.send_byte(c);
-                    }
+                    unsafe { uart.send_byte(c) }
                     while !uart.tx_ready() {}
                 }
             }

boards/raspberry_pi_pico/src/main.rs

@@ -453,7 +453,7 @@ pub unsafe fn start() -> (
     match peripherals.rtc.rtc_init() {
         Ok(()) => {}
         Err(e) => {
-            debug!("error starting rtc {:?}", e);
+            debug!("error starting rtc {:?}", e)
         }
     }
 

boards/sma_q3/src/io.rs

@@ -36,9 +36,7 @@ impl IoWrite for Writer {
     fn write(&mut self, buf: &[u8]) -> usize {
         match self {
             Writer::Uninitialized => {}
-            Writer::WriterRtt(rtt_memory) => {
-                rtt_memory.write_sync(buf);
-            }
+            Writer::WriterRtt(rtt_memory) => rtt_memory.write_sync(buf),
         }
         buf.len()
     }

capsules/extra/src/ieee802154/framer.rs

@@ -926,7 +926,7 @@ impl<'a, M: Mac<'a>, A: AES128CCM<'a>> radio::RxClient for Framer<'a, M, A> {
                 }
             };
             self.rx_state.replace(next_state);
-            self.step_receive_state();
+            self.step_receive_state()
         });
     }
 }
@@ -1000,7 +1000,7 @@ impl<'a, M: Mac<'a>, A: AES128CCM<'a>> CCMClient for Framer<'a, M, A> {
                             RxState::Idle
                         };
                         self.rx_state.replace(next_state);
-                        self.step_receive_state();
+                        self.step_receive_state()
                     }
                     other_state => {
                         rx_waiting = match other_state {
@@ -1022,7 +1022,7 @@ impl<'a, M: Mac<'a>, A: AES128CCM<'a>> CCMClient for Framer<'a, M, A> {
                 });
             });
         } else if rx_waiting {
-            self.step_receive_state();
+            self.step_receive_state()
         }
     }
 }

capsules/extra/src/lsm6dsoxtr.rs

@@ -426,8 +426,8 @@ impl<I: i2c::I2CDevice> i2c::I2CClient for Lsm6dsoxtrI2C<'_, I> {
                 let mut y: usize = 0;
                 let mut z: usize = 0;
 
-                if status == Ok(()) {
-                    self.nine_dof_client.map(|nine_dof_client| {
+                self.nine_dof_client.map(|nine_dof_client| {
+                    if status == Ok(()) {
                         let scale_factor = self.accel_scale.get() as usize;
                         x = ((((buffer[0] as u16 + ((buffer[1] as u16) << 8)) as i16) as isize)
                             * (SCALE_FACTOR_ACCEL[scale_factor] as isize)
@@ -440,12 +440,10 @@ impl<I: i2c::I2CDevice> i2c::I2CClient for Lsm6dsoxtrI2C<'_, I> {
                             * (SCALE_FACTOR_ACCEL[scale_factor] as isize)
                             / 1000) as usize;
                         nine_dof_client.callback(x, y, z)
-                    });
-                } else {
-                    self.nine_dof_client.map(|client| {
-                        client.callback(0, 0, 0);
-                    });
-                }
+                    } else {
+                        nine_dof_client.callback(0, 0, 0)
+                    }
+                });
                 self.buffer.replace(buffer);
                 self.i2c.disable();
                 self.state.set(State::Idle);
@@ -455,8 +453,8 @@ impl<I: i2c::I2CDevice> i2c::I2CClient for Lsm6dsoxtrI2C<'_, I> {
                 let mut x: usize = 0;
                 let mut y: usize = 0;
                 let mut z: usize = 0;
-                if status == Ok(()) {
-                    self.nine_dof_client.map(|nine_dof_client| {
+                self.nine_dof_client.map(|nine_dof_client| {
+                    if status == Ok(()) {
                         let scale_factor = self.gyro_range.get() as usize;
                         x = (((buffer[0] as u16 + ((buffer[1] as u16) << 8)) as i16) as isize
                             * (SCALE_FACTOR_GYRO[scale_factor] as isize)
@@ -469,12 +467,10 @@ impl<I: i2c::I2CDevice> i2c::I2CClient for Lsm6dsoxtrI2C<'_, I> {
                             * (SCALE_FACTOR_GYRO[scale_factor] as isize)
                             / 100) as usize;
                         nine_dof_client.callback(x, y, z)
-                    });
-                } else {
-                    self.nine_dof_client.map(|client| {
-                        client.callback(0, 0, 0);
-                    });
-                }
+                    } else {
+                        nine_dof_client.callback(0, 0, 0)
+                    }
+                });
                 self.buffer.replace(buffer);
                 self.i2c.disable();
                 self.state.set(State::Idle);
@@ -489,9 +485,8 @@ impl<I: i2c::I2CDevice> i2c::I2CClient for Lsm6dsoxtrI2C<'_, I> {
                         * 100) as i32),
                     Err(i2c_error) => Err(i2c_error.into()),
                 };
-                self.temperature_client.map(|client| {
-                    client.callback(temperature);
-                });
+                self.temperature_client
+                    .map(|client| client.callback(temperature));
                 self.buffer.replace(buffer);
                 self.i2c.disable();
                 self.state.set(State::Idle);

capsules/extra/src/net/thread/driver.rs

@@ -733,9 +733,9 @@ impl<'a, A: time::Alarm<'a>> CCMClient for ThreadNetworkDriver<'a, A> {
                 // Move the decrypted MLE message into the recv_buf and execute the receiving logic. Upon
                 // an error in `recv_logic`, joining the network fails and schedule termination upcall
                 self.recv_buffer.replace(assembled_subslice);
-                self.recv_logic(IPAddr(src_ipv6))
-                    .err()
-                    .map(|code| self.terminate_child_join(Err(code)));
+                if let Err(code) = self.recv_logic(IPAddr(src_ipv6)) {
+                    self.terminate_child_join(Err(code))
+                }
             }
             _ => (),
         }

capsules/extra/src/public_key_crypto/rsa_keys.rs

@@ -301,9 +301,7 @@ impl<const L: usize> RsaPrivKey for RSAKeys<L> {
         if let Some(private_key) = self.private_key.take() {
             match private_key {
                 MutImutBuffer::Mutable(ref _buf) => unreachable!(),
-                MutImutBuffer::Immutable(buf) => {
-                    closure(buf);
-                }
+                MutImutBuffer::Immutable(buf) => closure(buf),
             }
             self.private_key.replace(private_key);
             Some(())
@@ -328,9 +326,7 @@ impl<const L: usize> RsaPrivKeyMut for RSAKeys<L> {
     fn map_exponent(&self, closure: &dyn Fn(&mut [u8])) -> Option<()> {
         if let Some(mut private_key) = self.private_key.take() {
             match private_key {
-                MutImutBuffer::Mutable(ref mut buf) => {
-                    closure(buf);
-                }
+                MutImutBuffer::Mutable(ref mut buf) => closure(buf),
                 MutImutBuffer::Immutable(_buf) => unreachable!(),
             }
             self.private_key.replace(private_key);

capsules/extra/src/st77xx.rs

@@ -489,21 +489,17 @@ impl<'a, A: Alarm<'a>, B: Bus<'a, BusAddr8>, P: Pin> ST77XX<'a, A, B, P> {
                     self.sequence_buffer.map_or_else(
                         || panic!("st77xx: do next op has no sequence buffer"),
                         |sequence| match sequence[position] {
-                            SendCommand::Nop => {
-                                self.do_next_op();
-                            }
+                            SendCommand::Nop => self.do_next_op(),
                             SendCommand::Default(cmd) => {
-                                self.send_command_with_default_parameters(cmd);
+                                self.send_command_with_default_parameters(cmd)
                             }
                             SendCommand::Position(cmd, position, len) => {
-                                self.send_command(cmd, position, len, 1);
+                                self.send_command(cmd, position, len, 1)
                             }
                             SendCommand::Repeat(cmd, position, len, repeat) => {
-                                self.send_command(cmd, position, len, repeat);
-                            }
-                            SendCommand::Slice(cmd, len) => {
-                                self.send_command_slice(cmd, len);
+                                self.send_command(cmd, position, len, repeat)
                             }
+                            SendCommand::Slice(cmd, len) => self.send_command_slice(cmd, len),
                         },
                     );
                 } else {
@@ -512,23 +508,22 @@ impl<'a, A: Alarm<'a>, B: Bus<'a, BusAddr8>, P: Pin> ST77XX<'a, A, B, P> {
                         self.client.map(|client| {
                             self.power_on.set(true);
 
-                            client.screen_is_ready();
+                            client.screen_is_ready()
                         });
                     } else {
                         if self.setup_command.get() {
                             self.setup_command.set(false);
-                            self.setup_client.map(|setup_client| {
-                                setup_client.command_complete(Ok(()));
-                            });
+                            self.setup_client
+                                .map(|setup_client| setup_client.command_complete(Ok(())));
                         } else {
                             self.client.map(|client| {
                                 if self.write_buffer.is_some() {
                                     self.write_buffer.take().map(|buffer| {
                                         let data = SubSliceMut::new(buffer);
-                                        client.write_complete(data, Ok(()));
+                                        client.write_complete(data, Ok(()))
                                     });
                                 } else {
-                                    client.command_complete(Ok(()));
+                                    client.command_complete(Ok(()))
                                 }
                             });
                         }

capsules/extra/src/usb_hid_driver.rs

@@ -245,12 +245,9 @@ impl<'a, U: usb_hid::UsbHid<'a, [u8; 64]>> SyscallDriver for UsbHidDriver<'a, U>
                     // a receive we return `ErrorCode::ALREADY`. If the
                     // receive fails we return an error.
                     if let Some(buf) = self.recv_buffer.take() {
-                        match self.usb.receive_buffer(buf) {
-                            Ok(()) => {}
-                            Err((err, buffer)) => {
-                                self.recv_buffer.replace(buffer);
-                                return CommandReturn::failure(err);
-                            }
+                        if let Err((err, buffer)) = self.usb.receive_buffer(buf) {
+                            self.recv_buffer.replace(buffer);
+                            return CommandReturn::failure(err);
                         }
                     } else {
                         return CommandReturn::failure(ErrorCode::ALREADY);

chips/earlgrey/src/plic.rs

@@ -93,7 +93,7 @@ impl Plic {
     /// Disable specific interrupt.
     pub fn disable(&self, index: u32) {
         if index >= PLIC_IRQ_NUM as u32 {
-            panic!("Invalid IRQ: {}", index);
+            panic!("Invalid IRQ: {}", index)
         }
         let offset = (index / 32) as usize;
         let mask = !(1 << (index % 32));
@@ -127,7 +127,7 @@ impl Plic {
     /// Saved interrupts are cleared when `'complete()` is called.
     pub unsafe fn save_interrupt(&self, index: u32) {
         if index >= PLIC_IRQ_NUM as u32 {
-            panic!("Invalid IRQ: {}", index);
+            panic!("Invalid IRQ: {}", index)
         }
         let offset = (index / 32) as usize;
         let mask = 1 << (index % 32);
@@ -158,7 +158,7 @@ impl Plic {
     pub unsafe fn complete(&self, index: u32) {
         self.registers.claim.set(index);
         if index >= PLIC_IRQ_NUM as u32 {
-            panic!("Invalid IRQ: {}", index);
+            panic!("Invalid IRQ: {}", index)
         }
         let offset = (index / 32) as usize;
         let mask = !(1 << (index % 32));

chips/sam4l/src/usart.rs

@@ -742,7 +742,7 @@ impl<'a> USART<'a> {
                 let cd = system_frequency / baud_rate;
                 usart.registers.brgr.write(BaudRate::CD.val(cd));
             }
-            _ => {}
+            UsartMode::Unused => {}
         }
     }
 

kernel/src/hil/hasher.rs

@@ -54,7 +54,7 @@ pub trait Hasher<'a, const L: usize> {
     /// callback is fired.
     /// On error the return value will contain a return code and the original data
     /// The possible ErrorCodes are:
-    ///    - BUSY: The system is busy performing an operation The caller should
+    ///    - BUSY: The system is busy performing an operation. The caller should
     ///      expect a callback
     ///    - SIZE: The size of the `data` buffer is invalid
     fn add_data(
@@ -69,7 +69,7 @@ pub trait Hasher<'a, const L: usize> {
     /// callback is fired.
     /// On error the return value will contain a return code and the original data
     /// The possible ErrorCodes are:
-    ///    - BUSY: The system is busy performing an operation The caller should
+    ///    - BUSY: The system is busy performing an operation. The caller should
     ///      expect a callback
     ///    - SIZE: The size of the `data` buffer is invalid
     fn add_mut_data(
@@ -85,7 +85,7 @@ pub trait Hasher<'a, const L: usize> {
     /// If there is data from the `add_data()` command asynchronously waiting to
     /// be written it will be written before the operation starts.
     /// The possible ErrorCodes are:
-    ///    - BUSY: The system is busy performing an operation The caller should
+    ///    - BUSY: The system is busy performing an operation. The caller should
     ///      expect a callback
     ///    - SIZE: The size of the `data` buffer is invalid
     fn run(&'a self, hash: &'static mut [u8; L]) -> Result<(), (ErrorCode, &'static mut [u8; L])>;

kernel/src/scheduler/mlfq.rs

@@ -96,9 +96,8 @@ impl<'a, A: 'static + time::Alarm<'static>> MLFQSched<'a, A> {
 
     fn redeem_all_procs(&self) {
         for queue in self.processes.iter().skip(1) {
-            match queue.pop_head() {
-                Some(proc) => self.processes[0].push_tail(proc),
-                None => {}
+            if let Some(proc) = queue.pop_head() {
+                self.processes[0].push_tail(proc)
             }
         }
     }