refactor: use let-else in more places

Author: yvt

src/r3_core/src/utils/alloc.rs

@@ -402,12 +402,9 @@ where
 unsafe impl const Allocator for ConstAllocator {
     fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
         let ptr = unsafe { core::intrinsics::const_allocate(layout.size(), layout.align()) };
-        if let Some(ptr) = NonNull::new(ptr) {
-            unsafe { *self.ref_count += 1 };
-            Ok(NonNull::slice_from_raw_parts(ptr, layout.size()))
-        } else {
-            Err(AllocError)
-        }
+        let Some(ptr) = NonNull::new(ptr) else { return Err(AllocError) };
+        unsafe { *self.ref_count += 1 };
+        Ok(NonNull::slice_from_raw_parts(ptr, layout.size()))
     }
 
     unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {

src/r3_core/src/utils/binary_heap/mod.rs

@@ -67,30 +67,32 @@ where
             return None;
         }
 
-        if let Some(mut item) = self.pop() {
-            let slice = &mut **self;
-            if i < slice.len() {
-                // Swap the last item with the item at `i`
-                core::mem::swap(&mut slice[i], &mut item);
-                ctx.on_move(&mut slice[i], i);
-
-                let should_sift_up = i > 0 && ctx.lt(&slice[i], &slice[(i - 1) / 2]);
-
-                // Sift down or up the item at `i`, restoring the invariant
-                // Safety: `i` points to an element within `slice`.
-                unsafe {
-                    if should_sift_up {
-                        sift_up(slice, 0, i, ctx);
-                    } else {
-                        sift_down(slice, i, ctx);
-                    }
+        let Some(mut item) = self.pop()
+        else {
+            debug_assert!(false);
+            return None;
+        };
+
+        let slice = &mut **self;
+        if i < slice.len() {
+            // Swap the last item with the item at `i`
+            core::mem::swap(&mut slice[i], &mut item);
+            ctx.on_move(&mut slice[i], i);
+
+            let should_sift_up = i > 0 && ctx.lt(&slice[i], &slice[(i - 1) / 2]);
+
+            // Sift down or up the item at `i`, restoring the invariant
+            // Safety: `i` points to an element within `slice`.
+            unsafe {
+                if should_sift_up {
+                    sift_up(slice, 0, i, ctx);
+                } else {
+                    sift_down(slice, i, ctx);
                 }
             }
-            Some(item)
-        } else {
-            debug_assert!(false);
-            None
         }
+
+        Some(item)
     }
 
     fn heap_push<Ctx>(&mut self, item: Self::Element, ctx: Ctx) -> usize

src/r3_core/src/utils/vec.rs

@@ -79,14 +79,11 @@ impl<T: ~const Destruct> ComptimeVec<T> {
 
     pub const fn pop(&mut self) -> Option<T> {
         unsafe {
-            if let Some(i) = self.len.checked_sub(1) {
-                self.len = i;
-                // Safety: The `i`-th element was present, but since `len <= i`
-                // now, we can remove it
-                Some(self.ptr.as_ptr().wrapping_add(i).read())
-            } else {
-                None
-            }
+            let Some(i) = self.len.checked_sub(1) else { return None };
+            self.len = i;
+            // Safety: The `i`-th element was present, but since `len <= i`
+            // now, we can remove it
+            Some(self.ptr.as_ptr().wrapping_add(i).read())
         }
     }
 

src/r3_kernel/src/wait.rs

@@ -477,11 +477,7 @@ impl<Traits: KernelTraits> WaitQueue<Traits> {
         let mut accessor = wait_queue_accessor!(&self.waits, lock.borrow_mut());
         let wait_ref = unsafe { accessor.pop_front().unwrap_unchecked() };
 
-        let wait_ref = if let Some(wait_ref) = wait_ref {
-            wait_ref
-        } else {
-            return false;
-        };
+        let Some(wait_ref) = wait_ref else { return false; };
 
         // Safety: `wait_ref` points to a valid `Wait` because `wait_ref` was
         // in `self.waits` at the beginning of this function call.
@@ -587,15 +583,16 @@ impl<Traits: KernelTraits> fmt::Debug for WaitQueue<Traits> {
 
         impl<Traits: KernelTraits> fmt::Debug for WaitQueuePrinter<'_, Traits> {
             fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-                if let Ok(mut lock) = super::klock::lock_cpu() {
-                    let accessor = wait_queue_accessor!(&self.waits, lock.borrow_mut());
-
-                    f.debug_list()
-                        .entries(accessor.iter().map(|x| x.unwrap().1))
-                        .finish()
-                } else {
-                    f.write_str("< locked >")
-                }
+                let Ok(mut lock) = super::klock::lock_cpu()
+                else {
+                    return f.write_str("< locked >")
+                };
+
+                let accessor = wait_queue_accessor!(&self.waits, lock.borrow_mut());
+
+                f.debug_list()
+                    .entries(accessor.iter().map(|x| x.unwrap().1))
+                    .finish()
             }
         }
 
@@ -652,13 +649,13 @@ pub(super) fn reorder_wait_of_task<Traits: KernelTraits>(
     lock: CpuLockTokenRefMut<'_, Traits>,
     task_cb: &TaskCb<Traits>,
 ) {
-    if let Some(wait_ref) = task_cb.wait.current_wait.get(&*lock) {
-        // Safety: `wait_ref` must point to an existing `Wait`
-        let wait = unsafe { &*wait_ref.0.as_ptr() };
+    let Some(wait_ref) = task_cb.wait.current_wait.get(&*lock) else { return };
 
-        if let Some(wait_queue) = wait.wait_queue {
-            wait_queue.reorder_wait(lock, wait);
-        }
+    // Safety: `wait_ref` must point to an existing `Wait`
+    let wait = unsafe { &*wait_ref.0.as_ptr() };
+
+    if let Some(wait_queue) = wait.wait_queue {
+        wait_queue.reorder_wait(lock, wait);
     }
 }
 

src/r3_port_arm/src/threading/imp.rs

@@ -618,20 +618,20 @@ impl State {
 
     unsafe fn handle_irq<Traits: PortInstance>() {
         // Safety: We are the port, so it's okay to call this
-        if let Some(line) = unsafe { Traits::acknowledge_interrupt() } {
-            // Now that we have signaled the acknowledgement of the current
-            // exception, we can start accepting nested exceptions.
-            unsafe { asm!("cpsie i") };
-
-            if let Some(handler) = Traits::INTERRUPT_HANDLERS.get(line) {
-                // Safety: The first-level interrupt handler is the only code
-                //         allowed to call this
-                unsafe { handler() };
-            }
-
-            // Safety: We are the port, so it's okay to call this
-            unsafe { Traits::end_interrupt(line) };
+        let Some(line) = (unsafe { Traits::acknowledge_interrupt() }) else { return };
+
+        // Now that we have signaled the acknowledgement of the current
+        // exception, we can start accepting nested exceptions.
+        unsafe { asm!("cpsie i") };
+
+        if let Some(handler) = Traits::INTERRUPT_HANDLERS.get(line) {
+            // Safety: The first-level interrupt handler is the only code
+            //         allowed to call this
+            unsafe { handler() };
         }
+
+        // Safety: We are the port, so it's okay to call this
+        unsafe { Traits::end_interrupt(line) };
     }
 }
 

src/r3_port_arm_m_test_driver/src/logger_rtt.rs

@@ -14,16 +14,15 @@ impl log::Log for Logger {
     fn log(&self, record: &log::Record) {
         interrupt::free(move |cs| {
             let mut log_channel = LOG_CHANNEL.borrow(cs).borrow_mut();
-            if let Some(channel) = &mut *log_channel {
-                writeln!(
-                    channel,
-                    "[{level:5} {target}] {args}",
-                    level = record.level(),
-                    target = record.target(),
-                    args = record.args()
-                )
-                .unwrap();
-            }
+            let Some(channel) = &mut *log_channel else { return; };
+            writeln!(
+                channel,
+                "[{level:5} {target}] {args}",
+                level = record.level(),
+                target = record.target(),
+                args = record.args()
+            )
+            .unwrap();
         });
     }
 

src/r3_port_std/src/sched.rs

@@ -122,13 +122,14 @@ impl ums::Scheduler for SchedState {
     }
 
     fn thread_exited(&mut self, thread_id: ums::ThreadId) {
-        if let Some(i) = self.zombies.iter().position(|id| *id == thread_id) {
-            log::trace!("removing the zombie thread {:?}", thread_id);
-            self.zombies.swap_remove(i);
+        let Some(i) = self.zombies.iter().position(|id| *id == thread_id)
+        else {
+            log::warn!("thread_exited: unexpected thread {:?}", thread_id);
             return;
-        }
+        };
 
-        log::warn!("thread_exited: unexpected thread {:?}", thread_id);
+        log::trace!("removing the zombie thread {:?}", thread_id);
+        self.zombies.swap_remove(i);
     }
 }
 
@@ -153,9 +154,8 @@ pub fn check_preemption_by_interrupt(
         let sched_state = lock.scheduler();
 
         // Find the highest pended priority
-        let (pri, num) = if let Some(&x) = sched_state.pended_lines.iter().next() {
-            x
-        } else {
+        let Some(&(pri, num)) = sched_state.pended_lines.iter().next()
+        else {
             // No interrupt is pended
             break;
         };

src/r3_port_std/tests/kernel_tests/external_interrupt.rs

@@ -58,9 +58,8 @@ impl<Traits: SupportedSystemTraits> App<System<Traits>> {
 }
 
 fn task_body1<Traits: SupportedSystemTraits, D: Driver<App<System<Traits>>>>() {
-    let int = if let Some(int) = D::app().int {
-        int
-    } else {
+    let Some(int) = D::app().int
+    else {
         log::warn!("No interrupt lines defined, skipping the test");
         D::success();
         return;

src/r3_support_rp2040/src/stdout.rs

@@ -42,24 +42,22 @@ impl WrapSerialWrite {
 
             block!(interrupt::free(|cs| -> nb::Result<(), core::fmt::Error> {
                 let mut stdout = STDOUT.borrow(cs).borrow_mut();
-                if let Some(stdout) = &mut *stdout {
-                    loop {
-                        match s {
-                            [] => {
-                                break Ok(());
-                            }
-                            [head, tail @ ..] => {
-                                // Output the first byte. If this gets stuck,
-                                // break out of `interrupt::free`.
-                                stdout
-                                    .write(*head)
-                                    .map_err(|e| e.map(|_| core::fmt::Error))?;
-                                s = tail;
-                            }
+                let Some(stdout) = &mut *stdout else { return Ok(()) };
+
+                loop {
+                    match s {
+                        [] => {
+                            break Ok(());
+                        }
+                        [head, tail @ ..] => {
+                            // Output the first byte. If this gets stuck,
+                            // break out of `interrupt::free`.
+                            stdout
+                                .write(*head)
+                                .map_err(|e| e.map(|_| core::fmt::Error))?;
+                            s = tail;
                         }
                     }
-                } else {
-                    Ok(())
                 }
             }))?;
         }

src/r3_test_runner/src/subprocess.rs

@@ -259,41 +259,39 @@ impl fmt::Display for ShellEscape<'_> {
         // These characters need to be quoted or escaped in double-quotes
         let special_chars_in_dq = b"*?[#~=%";
 
-        if let Some(utf8) = self.0.to_str() {
-            // All bytes are printable. We might need quoting or escaping some
-            // bytes.
-            let bytes = utf8.as_bytes();
-            if bytes.contains(&b'\'') {
-                // Enclose in double quotes
-                write!(f, "\"")?;
-                let mut utf8 = utf8;
-                while !utf8.is_empty() {
-                    let i = utf8
-                        .as_bytes()
-                        .iter()
-                        .position(|b| special_chars_in_dq.contains(b));
-
-                    if let Some(i) = i {
-                        write!(f, "{}", &utf8[..i])?;
-
-                        // Escape the byte at `i`
-                        write!(f, "\\{}", utf8.as_bytes()[i] as char)?;
-
-                        utf8 = &utf8[i + 1..];
-                    } else {
-                        break;
-                    }
-                }
-                write!(f, "{utf8}\"")
-            } else if bytes.iter().any(|b| special_chars.contains(b)) {
-                // Enclose in single quotes
-                write!(f, "'{utf8}'")
-            } else {
-                write!(f, "{utf8}")
+        let Some(utf8) = self.0.to_str()
+        else {
+            // Some bytes are unprintable.
+            return write!(f, "<unprintable: {:?}>", self.0);
+        };
+
+        // All bytes are printable. We might need quoting or escaping some
+        // bytes.
+        let bytes = utf8.as_bytes();
+        if bytes.contains(&b'\'') {
+            // Enclose in double quotes
+            write!(f, "\"")?;
+            let mut utf8 = utf8;
+            while !utf8.is_empty() {
+                let Some(i) = utf8
+                    .as_bytes()
+                    .iter()
+                    .position(|b| special_chars_in_dq.contains(b))
+                else { break };
+
+                write!(f, "{}", &utf8[..i])?;
+
+                // Escape the byte at `i`
+                write!(f, "\\{}", utf8.as_bytes()[i] as char)?;
+
+                utf8 = &utf8[i + 1..];
             }
+            write!(f, "{utf8}\"")
+        } else if bytes.iter().any(|b| special_chars.contains(b)) {
+            // Enclose in single quotes
+            write!(f, "'{utf8}'")
         } else {
-            // Some bytes are unprintable.
-            write!(f, "<unprintable: {:?}>", self.0)
+            write!(f, "{utf8}")
         }
     }
 }