Use let chains where possible

Author: mkeeter

build/i2c/src/lib.rs

@@ -538,13 +538,12 @@ impl ConfigGenerator {
             // their bus.
             //
             for (index, (p, port)) in c.ports.iter().enumerate() {
-                if let Some(name) = &port.name {
-                    if buses
+                if let Some(name) = &port.name
+                    && buses
                         .insert(name.clone(), (c.controller, index))
                         .is_some()
-                    {
-                        panic!("i2c bus {name} appears twice");
-                    }
+                {
+                    panic!("i2c bus {name} appears twice");
                 }
 
                 if c.ports.len() == 1 {
@@ -1011,10 +1010,10 @@ impl ConfigGenerator {
                 by_bus.insert((&d.device, bus), d);
             }
 
-            if let Some(name) = &d.name {
-                if by_name.insert((&d.device, name), d).is_some() {
-                    panic!("duplicate name {} for device {}", name, d.device)
-                }
+            if let Some(name) = &d.name
+                && by_name.insert((&d.device, name), d).is_some()
+            {
+                panic!("duplicate name {} for device {}", name, d.device)
             }
             if let Some(refdes) = &d.refdes {
                 if by_refdes.insert((&d.device, refdes), d).is_some() {
@@ -1241,10 +1240,10 @@ impl ConfigGenerator {
         println!("cargo::rerun-if-changed={}", dir.join("src").display());
 
         for entry in std::fs::read_dir(dir.join("src"))? {
-            if let Some(f) = entry?.path().file_name() {
-                if let Some(name) = f.to_str().unwrap().strip_suffix(".rs") {
-                    drivers.insert(name.to_string());
-                }
+            if let Some(f) = entry?.path().file_name()
+                && let Some(name) = f.to_str().unwrap().strip_suffix(".rs")
+            {
+                drivers.insert(name.to_string());
             }
         }
 

drv/psc-psu-update/src/main.rs

@@ -233,15 +233,14 @@ impl Psu {
 
         if let (Some(started), Some(backoff)) =
             (self.update_started, self.update_backoff)
+            && started + backoff > now
         {
-            if started + backoff > now {
-                //
-                // Indicate we are backing off, but in a way that won't flood
-                // the ring buffer with the backing off of a single PSU.
-                //
-                ringbuf_entry!(Trace::BackingOff(ndx));
-                return false;
-            }
+            //
+            // Indicate we are backing off, but in a way that won't flood
+            // the ring buffer with the backing off of a single PSU.
+            //
+            ringbuf_entry!(Trace::BackingOff(ndx));
+            return false;
         }
 
         true

drv/sidecar-seq-server/src/main.rs

@@ -276,50 +276,48 @@ impl ServerImpl {
     }
 
     fn actually_reset_front_io_phy(&mut self) -> Result<(), SeqError> {
-        if let Some(front_io_board) = self.front_io_board.as_mut() {
-            if front_io_board.initialized() {
-                // The board was initialized prior and this function is called
-                // by the monorail task because it is initializing the front IO
-                // PHY. Unfortunately some front IO boards have PHY oscillators
-                // which do not start reliably when their enable pin is used and
-                // the only way to resolve this is by power cycling the front IO
-                // board. But power cycling the board also bounces any QSFP
-                // transceivers which may be running, so this function attempts
-                // to determine what the monorail task wants to do.
-                //
-                // Whether or not the PHY oscillator was found to be operating
-                // nominally is recorded in the front IO board controller. Look
-                // up what this value is to determine if a power reset of the
-                // front IO board is needed.
-                match front_io_board.phy().osc_state()? {
-                    PhyOscState::Bad => {
-                        // The PHY was attempted to be initialized but its
-                        // oscillator was deemed not functional. Unfortunately
-                        // the only course of action is to power cycle the
-                        // entire front IO board, so do so now.
-                        self.front_io_hsc.set_enable(false)?;
-                        ringbuf_entry!(Trace::FrontIOBoardPowerEnable(false));
-
-                        // Wait some cool down period to allow caps to bleed off
-                        // etc.
-                        userlib::hl::sleep_for(1000);
-                    }
-                    PhyOscState::Good => {
-                        // The PHY was initialized properly before and its
-                        // oscillator declared operating nominally. Assume this
-                        // has not changed and only a reset the PHY itself is
-                        // desired.
-                        front_io_board.phy().set_phy_power_enabled(false)?;
-                        ringbuf_entry!(Trace::FrontIOBoardPhyPowerEnable(
-                            false
-                        ));
-
-                        userlib::hl::sleep_for(10);
-                    }
-                    PhyOscState::Unknown => {
-                        // Do nothing (yet) since the oscillator state is
-                        // unknown.
-                    }
+        if let Some(front_io_board) = self.front_io_board.as_mut()
+            && front_io_board.initialized()
+        {
+            // The board was initialized prior and this function is called
+            // by the monorail task because it is initializing the front IO
+            // PHY. Unfortunately some front IO boards have PHY oscillators
+            // which do not start reliably when their enable pin is used and
+            // the only way to resolve this is by power cycling the front IO
+            // board. But power cycling the board also bounces any QSFP
+            // transceivers which may be running, so this function attempts
+            // to determine what the monorail task wants to do.
+            //
+            // Whether or not the PHY oscillator was found to be operating
+            // nominally is recorded in the front IO board controller. Look
+            // up what this value is to determine if a power reset of the
+            // front IO board is needed.
+            match front_io_board.phy().osc_state()? {
+                PhyOscState::Bad => {
+                    // The PHY was attempted to be initialized but its
+                    // oscillator was deemed not functional. Unfortunately
+                    // the only course of action is to power cycle the
+                    // entire front IO board, so do so now.
+                    self.front_io_hsc.set_enable(false)?;
+                    ringbuf_entry!(Trace::FrontIOBoardPowerEnable(false));
+
+                    // Wait some cool down period to allow caps to bleed off
+                    // etc.
+                    userlib::hl::sleep_for(1000);
+                }
+                PhyOscState::Good => {
+                    // The PHY was initialized properly before and its
+                    // oscillator declared operating nominally. Assume this
+                    // has not changed and only a reset the PHY itself is
+                    // desired.
+                    front_io_board.phy().set_phy_power_enabled(false)?;
+                    ringbuf_entry!(Trace::FrontIOBoardPhyPowerEnable(false));
+
+                    userlib::hl::sleep_for(10);
+                }
+                PhyOscState::Unknown => {
+                    // Do nothing (yet) since the oscillator state is
+                    // unknown.
                 }
             }
         }
@@ -853,10 +851,10 @@ impl NotificationHandler for ServerImpl {
         // Currently, we will only resequence a single time to resolve the problem.
         match self.tofino.sequencer.state().unwrap_or(TofinoSeqState::A2) {
             TofinoSeqState::A0 => {
-                if !self.resequenced {
-                    if let Err(e) = self.monitor_tofino_pcie_link() {
-                        ringbuf_entry!(Trace::TofinoSequencerError(e));
-                    }
+                if !self.resequenced
+                    && let Err(e) = self.monitor_tofino_pcie_link()
+                {
+                    ringbuf_entry!(Trace::TofinoSequencerError(e));
                 }
             }
             // If we're not in A0, make sure next time we go into A0 we will attempt to

drv/stm32h7-spi-server-core/src/lib.rs

@@ -312,10 +312,10 @@ impl SpiServerCore {
 
         // If we are locked, check that the caller isn't mistakenly
         // addressing the wrong device.
-        if let Some(lockstate) = &self.lock_holder.get() {
-            if lockstate.device_index != device_index {
-                return Err(TransferError::BadDevice);
-            }
+        if let Some(lockstate) = &self.lock_holder.get()
+            && lockstate.device_index != device_index
+        {
+            return Err(TransferError::BadDevice);
         }
 
         // Reject out-of-range devices.
@@ -508,11 +508,11 @@ impl SpiServerCore {
 
                 // Deposit the byte if we're still within the bounds of the
                 // caller's incoming lease.
-                if let Some(rx_reader) = &mut rx {
-                    if rx_reader.write(b).is_err() {
-                        // We're off the end. Stop checking.
-                        rx = None;
-                    }
+                if let Some(rx_reader) = &mut rx
+                    && rx_reader.write(b).is_err()
+                {
+                    // We're off the end. Stop checking.
+                    rx = None;
                 }
 
                 // By releasing a TX permit, we might have unblocked the TX

drv/stm32xx-i2c/src/lib.rs

@@ -716,10 +716,10 @@ impl I2cController<'_> {
             let mut pos = 0;
 
             loop {
-                if let ReadLength::Fixed(rlen) = rlen {
-                    if pos >= rlen {
-                        break;
-                    }
+                if let ReadLength::Fixed(rlen) = rlen
+                    && pos >= rlen
+                {
+                    break;
                 }
 
                 loop {

lib/counters/derive/src/lib.rs

@@ -285,12 +285,11 @@ impl<'input> CountGenerator<'input> {
             #variant_name: <#variant_type as counters::Count>::NEW_COUNTERS
         });
         where_clause_types.insert(variant_type.clone());
-        if let syn::Type::Path(ty_path) = variant_type {
-            if let Some(ident) = ty_path.path.get_ident() {
-                if all_generics.contains(ident) {
-                    needed_generics.insert(ident.clone());
-                }
-            }
+        if let syn::Type::Path(ty_path) = variant_type
+            && let Some(ident) = ty_path.path.get_ident()
+            && all_generics.contains(ident)
+        {
+            needed_generics.insert(ident.clone());
         }
     }
 }

sys/kern/src/task.rs

@@ -238,14 +238,14 @@ impl Task {
 
         // We only need to check the mask, and make updates, if the task is
         // ready to hear about notifications.
-        if self.state.can_accept_notification() {
-            if let Some(firing) = self.take_notifications() {
-                // A bit the task is interested in has newly become set!
-                // Interrupt it.
-                self.save.set_recv_result(TaskId::KERNEL, firing, 0, 0, 0);
-                self.state = TaskState::Healthy(SchedState::Runnable);
-                return true;
-            }
+        if self.state.can_accept_notification()
+            && let Some(firing) = self.take_notifications()
+        {
+            // A bit the task is interested in has newly become set!
+            // Interrupt it.
+            self.save.set_recv_result(TaskId::KERNEL, firing, 0, 0, 0);
+            self.state = TaskState::Healthy(SchedState::Runnable);
+            return true;
         }
         false
     }
@@ -776,16 +776,16 @@ impl NextTask {
 pub fn process_timers(tasks: &mut [Task], current_time: Timestamp) -> NextTask {
     let mut sched_hint = NextTask::Same;
     for (index, task) in tasks.iter_mut().enumerate() {
-        if let Some(deadline) = task.timer.deadline {
-            if deadline <= current_time {
-                task.timer.deadline = None;
-                let task_hint = if task.post(task.timer.to_post) {
-                    NextTask::Specific(index)
-                } else {
-                    NextTask::Same
-                };
-                sched_hint = sched_hint.combine(task_hint)
-            }
+        if let Some(deadline) = task.timer.deadline
+            && deadline <= current_time
+        {
+            task.timer.deadline = None;
+            let task_hint = if task.post(task.timer.to_post) {
+                NextTask::Specific(index)
+            } else {
+                NextTask::Same
+            };
+            sched_hint = sched_hint.combine(task_hint)
         }
     }
     sched_hint
@@ -859,10 +859,10 @@ pub fn priority_scan(
             continue;
         }
 
-        if let Some((_, best_task)) = choice {
-            if !t.priority.is_more_important_than(best_task.priority) {
-                continue;
-            }
+        if let Some((_, best_task)) = choice
+            && !t.priority.is_more_important_than(best_task.priority)
+        {
+            continue;
         }
 
         choice = Some((pos, t));

task/control-plane-agent/src/mgs_sidecar.rs

@@ -190,12 +190,12 @@ impl MgsHandler {
 
         let now = sys_get_timer().now;
         for (vid, k) in self.locked.clone().iter() {
-            if let LockState::UnlockedUntil(lock_at) = k {
-                if now >= *lock_at {
-                    ringbuf_entry!(Trace::TimedRelock { vid });
-                    if let Err(e) = self.lock(vid) {
-                        ringbuf_entry!(Trace::TimedLockFailed(e));
-                    }
+            if let LockState::UnlockedUntil(lock_at) = k
+                && now >= *lock_at
+            {
+                ringbuf_entry!(Trace::TimedRelock { vid });
+                if let Err(e) = self.lock(vid) {
+                    ringbuf_entry!(Trace::TimedLockFailed(e));
                 }
             }
         }

task/control-plane-agent/src/update/host_flash.rs

@@ -400,16 +400,16 @@ impl ComponentUpdater for HostFlashUpdate {
                     return Err(SpError::UpdateFailed(err as u32));
                 }
 
-                if skip_bytes < buffer.len() {
-                    if let Err(err) = self.task.page_program_dev(
+                if skip_bytes < buffer.len()
+                    && let Err(err) = self.task.page_program_dev(
                         *dev,
                         *next_write_offset + skip_bytes as u32,
                         HfProtectMode::ProtectSector0,
                         &buffer[skip_bytes..],
-                    ) {
-                        *current.state_mut() = State::Failed(err);
-                        return Err(SpError::UpdateFailed(err as u32));
-                    }
+                    )
+                {
+                    *current.state_mut() = State::Failed(err);
+                    return Err(SpError::UpdateFailed(err as u32));
                 }
 
                 *next_write_offset += buffer.len() as u32;

task/monorail-server/src/server.rs

@@ -58,15 +58,15 @@ impl<'a, R: Vsc7448Rw> ServerImpl<'a, R> {
 
     pub fn wake(&mut self) -> Result<(), VscError> {
         let now = sys_get_timer().now;
-        if let Some(wake_interval) = bsp::WAKE_INTERVAL {
-            if now >= self.wake_target_time {
-                let out = self.bsp.wake();
-                self.wake_target_time = userlib::set_timer_relative(
-                    wake_interval,
-                    notifications::WAKE_TIMER_MASK,
-                );
-                return out;
-            }
+        if let Some(wake_interval) = bsp::WAKE_INTERVAL
+            && now >= self.wake_target_time
+        {
+            let out = self.bsp.wake();
+            self.wake_target_time = userlib::set_timer_relative(
+                wake_interval,
+                notifications::WAKE_TIMER_MASK,
+            );
+            return out;
         }
         Ok(())
     }