fix clippy warnings

arch/rv32i/src/pmp.rs

@@ -183,7 +183,7 @@ impl TORRegionSpec {
             || (end as usize) % 4 != 0
             || (end as usize)
                 .checked_sub(start as usize)
-                .map_or(true, |size| size < 4)
+                .is_none_or(|size| size < 4)
         {
             None
         } else {

boards/nordic/nrf52840dk/src/io.rs

@@ -56,7 +56,7 @@ impl IoWrite for Writer {
             Writer::WriterRtt(rtt_memory) => {
                 rtt_memory.write_sync(buf);
             }
-        };
+        }
         buf.len()
     }
 }

capsules/core/src/low_level_debug/fmt.rs

@@ -82,7 +82,7 @@ impl core::fmt::Write for WriteAdapter<'_> {
         if let Some(slice) = self.buffer.get_mut(self.used..(self.used + msg.len())) {
             slice.copy_from_slice(msg.as_bytes());
             self.used += msg.len();
-        };
+        }
         Ok(())
     }
 }

capsules/core/src/process_console.rs

@@ -1244,7 +1244,7 @@ impl<
                                             self.command_index.set(next_command_len);
                                             self.cursor.set(next_command_len);
                                             command[next_command_len] = EOL;
-                                        };
+                                        }
                                     });
                                 }
                                 EscKey::Left if cursor > 0 => {
@@ -1310,7 +1310,7 @@ impl<
                                     }
                                 }
                                 _ => {}
-                            };
+                            }
                         } else if read_buf[0] == NLINE || read_buf[0] == CR {
                             if (previous_byte == NLINE || previous_byte == CR)
                                 && previous_byte != read_buf[0]
@@ -1429,7 +1429,7 @@ impl<
                     "ProcessConsole issues reads of 1 byte, but receive_complete was length {}",
                     rx_len
                 ),
-            };
+            }
         }
         let _ = self.uart.receive_buffer(read_buf, 1);
     }

capsules/core/src/virtualizers/virtual_alarm.rs

@@ -166,7 +166,7 @@ impl<'a, A: Alarm<'a>> Alarm<'a> for VirtualMuxAlarm<'a, A> {
             let expiration = reference.wrapping_add(dt);
             if !cur_alarm.within_range(reference, expiration) {
                 let next = self.mux.next_tick_vals.get();
-                if next.map_or(true, |(next_reference, next_dt)| {
+                if next.is_none_or(|(next_reference, next_dt)| {
                     now.within_range(next_reference, next_reference.wrapping_add(next_dt))
                 }) {
                     self.mux.set_alarm(reference, dt);

capsules/core/src/virtualizers/virtual_flash.rs

@@ -106,7 +106,7 @@ impl<'a, F: hil::flash::Flash> MuxFlash<'a, F> {
                                 let _ = self.flash.erase_page(page_number);
                             }
                             _ => {}
-                        };
+                        }
                     },
                     |buf| {
                         match node.operation.get() {

capsules/core/src/virtualizers/virtual_i2c.rs

@@ -134,7 +134,7 @@ impl<'a, I: i2c::I2CMaster<'a>, S: i2c::SMBusMaster<'a>> MuxI2C<'a, I, S> {
                                     node.operation.set(Op::CommandComplete(Err(e.0)));
                                     node.mux.do_next_op_async();
                                 }
-                            };
+                            }
                         }
                         Op::Read(len) => {
                             match self.smbus.unwrap().smbus_read(node.addr, buf, len) {
@@ -144,7 +144,7 @@ impl<'a, I: i2c::I2CMaster<'a>, S: i2c::SMBusMaster<'a>> MuxI2C<'a, I, S> {
                                     node.operation.set(Op::CommandComplete(Err(e.0)));
                                     node.mux.do_next_op_async();
                                 }
-                            };
+                            }
                         }
                         Op::WriteRead(wlen, rlen) => {
                             match self
@@ -158,7 +158,7 @@ impl<'a, I: i2c::I2CMaster<'a>, S: i2c::SMBusMaster<'a>> MuxI2C<'a, I, S> {
                                     node.operation.set(Op::CommandComplete(Err(e.0)));
                                     node.mux.do_next_op_async();
                                 }
-                            };
+                            }
                         }
                         Op::CommandComplete(err) => {
                             self.command_complete(buf, err);

capsules/extra/src/can.rs

@@ -493,7 +493,7 @@ impl<Can: can::Can> can::ReceiveClient<{ can::STANDARD_CAN_PACKET_SIZE }> for Ca
                     (error_upcalls::ERROR_RX, kernel_err.into(), 0),
                 )
             }
-        };
+        }
     }
 
     fn stopped(&self, buffer: &'static mut [u8; can::STANDARD_CAN_PACKET_SIZE]) {

capsules/extra/src/gpio_async.rs

@@ -190,7 +190,7 @@ impl<Port: hil::gpio_async::Port> SyscallDriver for GPIOAsync<'_, Port> {
         // On any command other than 0, we check if another command is in flight
         if self.configuring_process.is_some() {
             return CommandReturn::failure(ErrorCode::BUSY);
-        };
+        }
 
         let res = match command_number {
             // enable output

capsules/extra/src/ieee802154/framer.rs

@@ -1009,7 +1009,7 @@ impl<'a, M: Mac<'a>, A: AES128CCM<'a>> CCMClient for Framer<'a, M, A> {
                         };
                         self.rx_state.replace(other_state);
                     }
-                };
+                }
             });
         }
 

capsules/extra/src/lpm013m126.rs

@@ -743,7 +743,7 @@ where
             _ => {
                 self.extcomin.toggle();
             }
-        };
+        }
     }
 }
 

capsules/extra/src/lsm6dsoxtr.rs

@@ -445,7 +445,7 @@ impl<I: i2c::I2CDevice> i2c::I2CClient for Lsm6dsoxtrI2C<'_, I> {
                     self.nine_dof_client.map(|client| {
                         client.callback(0, 0, 0);
                     });
-                };
+                }
                 self.buffer.replace(buffer);
                 self.i2c.disable();
                 self.state.set(State::Idle);
@@ -474,7 +474,7 @@ impl<I: i2c::I2CDevice> i2c::I2CClient for Lsm6dsoxtrI2C<'_, I> {
                     self.nine_dof_client.map(|client| {
                         client.callback(0, 0, 0);
                     });
-                };
+                }
                 self.buffer.replace(buffer);
                 self.i2c.disable();
                 self.state.set(State::Idle);

capsules/extra/src/net/sixlowpan/sixlowpan_compression.rs

@@ -975,7 +975,7 @@ fn decompress_multicast(
             iphc::DAM_INLINE => {
                 // DAC = 1, DAM = 00: 48 bits
                 // ffXX:XXLL:PPPP:PPPP:PPPP:PPPP:XXXX:XXXX
-                let prefix_bytes = ((ctx.prefix_len + 7) / 8) as usize;
+                let prefix_bytes = ctx.prefix_len.div_ceil(8) as usize;
                 if prefix_bytes > 8 {
                     // The maximum prefix length for this mode is 64 bits.
                     // If the specified prefix exceeds this length, the

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

@@ -231,7 +231,7 @@ impl<'a, A: time::Alarm<'a>> ThreadNetworkDriver<'a, A> {
                 self.state.replace(curr_state);
                 self.terminate_child_join(Err(ErrorCode::BUSY));
             }
-        };
+        }
     }
 
     fn thread_mle_send(
@@ -738,6 +738,6 @@ impl<'a, A: time::Alarm<'a>> CCMClient for ThreadNetworkDriver<'a, A> {
                     .map(|code| self.terminate_child_join(Err(code)));
             }
             _ => (),
-        };
+        }
     }
 }

capsules/extra/src/net/udp/udp_port_table.rs

@@ -217,7 +217,7 @@ impl UdpPortManager {
             .map_or(true, |port_query| port_query.is_bound(port));
         if user_bound {
             return Ok(true);
-        };
+        }
         let ret = self
             .port_array
             .map(|table| {

capsules/extra/src/public_key_crypto/rsa_keys.rs

@@ -304,7 +304,7 @@ impl<const L: usize> RsaPrivKey for RSAKeys<L> {
                 MutImutBuffer::Immutable(buf) => {
                     closure(buf);
                 }
-            };
+            }
             self.private_key.replace(private_key);
             Some(())
         } else {
@@ -332,7 +332,7 @@ impl<const L: usize> RsaPrivKeyMut for RSAKeys<L> {
                     closure(buf);
                 }
                 MutImutBuffer::Immutable(_buf) => unreachable!(),
-            };
+            }
             self.private_key.replace(private_key);
             Some(())
         } else {

capsules/extra/src/screen.rs

@@ -388,7 +388,7 @@ impl<'a> Screen<'a> {
                                 let mut write_len = buffer_size / bytes_per_pixel;
                                 if write_len > len {
                                     write_len = len
-                                };
+                                }
                                 app.write_position += write_len * bytes_per_pixel;
                                 kernel_data
                                     .get_readonly_processbuffer(ro_allow::SHARED)

capsules/extra/src/sdcard.rs

@@ -1258,7 +1258,7 @@ impl<'a, A: hil::time::Alarm<'a>> SDCard<'a, A> {
 
     pub fn is_installed(&self) -> bool {
         // if there is no detect pin, assume an sd card is installed
-        self.detect_pin.get().map_or(true, |pin| {
+        self.detect_pin.get().is_none_or(|pin| {
             // sd card detection pin is active low
             !pin.read()
         })

capsules/extra/src/st77xx.rs

@@ -395,7 +395,7 @@ impl<'a, A: Alarm<'a>, B: Bus<'a, BusAddr8>, P: Pin> ST77XX<'a, A, B, P> {
                     self.width.set(self.screen.default_height);
                     self.height.set(self.screen.default_width);
                 }
-            };
+            }
             self.buffer.map_or_else(
                 || panic!("st77xx: set rotation has no buffer"),
                 |buffer| {
@@ -505,7 +505,7 @@ impl<'a, A: Alarm<'a>, B: Bus<'a, BusAddr8>, P: Pin> ST77XX<'a, A, B, P> {
                                 SendCommand::Slice(cmd, len) => {
                                     self.send_command_slice(cmd, len);
                                 }
-                            };
+                            }
                         },
                     );
                 } else {
@@ -614,7 +614,7 @@ impl<'a, A: Alarm<'a>, B: Bus<'a, BusAddr8>, P: Pin> ST77XX<'a, A, B, P> {
             _ => {
                 panic!("ST77XX status Idle");
             }
-        };
+        }
     }
 
     fn set_memory_frame(

capsules/extra/src/tickv_kv_store.rs

@@ -365,7 +365,7 @@ impl<'a, K: KVSystem<'a, K = T>, T: KeyType> KVSystemClient<T> for TicKVKVStore<
                                     cb.delete_complete(Err(ErrorCode::FAIL), unhashed_key);
                                 });
                             }
-                        };
+                        }
                     }
                     Operation::GarbageCollect => {}
                 }

capsules/extra/src/tutorials/encryption_oracle_chkpt4.rs

@@ -175,9 +175,7 @@ impl<'a, A: AES128<'a> + AES128Ctr> EncryptionOracleDriver<'a, A> {
                                 iv[..copy_len].copy_to_slice(&mut static_buf[..copy_len]);
 
                                 AES128::set_iv(self.aes, &static_buf[..copy_len])
-                            })
-                            .map_err(Into::into)
-                        })??;
+                            })})??;
                 }
 
                 // Our AES engine works with kernel-provided `&'static mut`

capsules/extra/src/tutorials/encryption_oracle_chkpt5.rs

@@ -175,9 +175,7 @@ impl<'a, A: AES128<'a> + AES128Ctr> EncryptionOracleDriver<'a, A> {
                                 iv[..copy_len].copy_to_slice(&mut static_buf[..copy_len]);
 
                                 AES128::set_iv(self.aes, &static_buf[..copy_len])
-                            })
-                            .map_err(Into::into)
-                        })??;
+                            })})??;
                 }
 
                 // Our AES engine works with kernel-provided `&'static mut`

capsules/extra/src/usb/usbc_client_ctrl.rs

@@ -422,7 +422,7 @@ impl<'a, 'b, U: hil::usb::UsbController<'a>> ClientCtrl<'a, 'b, U> {
                 self.controller.enable_address();
             }
             _ => {}
-        };
+        }
         self.state[endpoint].set(State::Init);
     }
 }

capsules/extra/src/usb_hid_driver.rs

@@ -254,7 +254,7 @@ impl<'a, U: usb_hid::UsbHid<'a, [u8; 64]>> SyscallDriver for UsbHidDriver<'a, U>
                         }
                     } else {
                         return CommandReturn::failure(ErrorCode::ALREADY);
-                    };
+                    }
 
                     // If we were able to setup a read then next we do the
                     // transmit.

chips/apollo3/src/clkgen.rs

@@ -77,7 +77,7 @@ impl ClkGen {
                 regs.cctrl.set(0);
                 regs.clkkey.set(0);
             }
-        };
+        }
     }
 
     pub fn enable_ble(&self) {

chips/esp32-c3/src/rng.rs

@@ -48,7 +48,7 @@ impl DeferredCallClient for Rng<'_> {
         self.client.map(|client| {
             if let Continue::More = client.entropy_available(&mut RngIter(self), Ok(())) {
                 self.deferred_call.set();
-            };
+            }
         });
     }
 }

chips/lowrisc/src/rsa.rs

@@ -65,7 +65,7 @@ impl<'a> OtbnRsa<'a> {
                             );
                         }
                         MutImutBuffer::Immutable(_) => unreachable!(),
-                    };
+                    }
                 });
             }
             MutImutBuffer::Immutable(exponent) => {
@@ -82,7 +82,7 @@ impl<'a> OtbnRsa<'a> {
                         });
                     }
                     MutImutBuffer::Mutable(_) => unreachable!(),
-                };
+                }
             }
         }
     }
@@ -112,7 +112,7 @@ impl<'a> crate::otbn::Client<'a> for OtbnRsa<'a> {
                             );
                         }
                         MutImutBuffer::Immutable(_) => unreachable!(),
-                    };
+                    }
                 });
             }
             MutImutBuffer::Immutable(exponent) => {
@@ -129,7 +129,7 @@ impl<'a> crate::otbn::Client<'a> for OtbnRsa<'a> {
                         });
                     }
                     MutImutBuffer::Mutable(_) => unreachable!(),
-                };
+                }
             }
         }
     }

chips/lowrisc/src/spi_host.rs

@@ -694,7 +694,7 @@ impl<'a> hil::spi::SpiMaster<'a> for SpiHost<'a> {
         match polarity {
             ClockPolarity::IdleLow => regs.config_opts.modify(conf_opts::CPOL_0::CLEAR),
             ClockPolarity::IdleHigh => regs.config_opts.modify(conf_opts::CPOL_0::SET),
-        };
+        }
         Ok(())
     }
 
@@ -713,7 +713,7 @@ impl<'a> hil::spi::SpiMaster<'a> for SpiHost<'a> {
         match phase {
             ClockPhase::SampleLeading => regs.config_opts.modify(conf_opts::CPHA_0::CLEAR),
             ClockPhase::SampleTrailing => regs.config_opts.modify(conf_opts::CPHA_0::SET),
-        };
+        }
         Ok(())
     }