Allow calling interrupt::free with zero-arity closures.

Author: reitermarkus

CHANGELOG.md

@@ -7,9 +7,13 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 
+### Changed
+- `interrupt::free` can be called with closures of type `FnOnce() -> T`.
+
 ### Deprecated
 - the `ptr()` function on all peripherals register blocks in favor of
   the associated constant `PTR` (#386).
+- Calling `interrupt::free` with closures of type `FnOnce(&CriticalSection) -> T` is deprecated. Users should switch to using `critical_section::with`.
 
 ## [v0.7.4] - 2021-12-31
 

src/interrupt.rs

@@ -48,20 +48,54 @@ pub unsafe fn enable() {
     call_asm!(__cpsie());
 }
 
+/// Hacky compatibility layer to allow calling `interrupt::free` using
+/// closures with arity 0 as well as 1. This trait is not considered
+/// part of the public API.
+///
+/// The generic `Args` type is not actually used, see:
+/// https://geo-ant.github.io/blog/2021/rust-traits-and-variadic-functions/
+///
+/// TODO: Remove before releasing 0.8.
+pub trait InterruptFreeFn<Args, R> {
+    /// Call the closure.
+    unsafe fn call(self) -> R;
+}
+
+impl<F, R> InterruptFreeFn<(), R> for F
+where
+    F: FnOnce() -> R,
+{
+    #[inline]
+    unsafe fn call(self) -> R {
+        self()
+    }
+}
+
+impl<'cs, F, R> InterruptFreeFn<&'cs CriticalSection, R> for F
+where
+    F: FnOnce(&'cs CriticalSection) -> R,
+{
+    #[inline]
+    unsafe fn call(self) -> R {
+        let cs: &'cs CriticalSection = core::mem::transmute(&CriticalSection::new());
+        self(cs)
+    }
+}
+
 /// Execute closure `f` in an interrupt-free context.
 ///
 /// This as also known as a "critical section".
 #[inline]
-pub fn free<F, R>(f: F) -> R
+pub fn free<Args, F, R>(f: F) -> R
 where
-    F: FnOnce(&CriticalSection) -> R,
+    F: InterruptFreeFn<Args, R>,
 {
     let primask = crate::register::primask::read();
 
     // disable interrupts
     disable();
 
-    let r = f(unsafe { &CriticalSection::new() });
+    let r = unsafe { f.call() };
 
     // If the interrupts were active before our `disable` call, then re-enable
     // them. Otherwise, keep them disabled

src/lib.rs

@@ -79,9 +79,6 @@
 // Don't warn about feature(asm) being stable on Rust >= 1.59.0
 #![allow(stable_features)]
 
-extern crate bare_metal;
-extern crate volatile_register;
-
 #[macro_use]
 mod call_asm;
 #[macro_use]

src/macros.rs

@@ -54,7 +54,7 @@ macro_rules! iprintln {
 #[macro_export]
 macro_rules! singleton {
     (: $ty:ty = $expr:expr) => {
-        $crate::interrupt::free(|_| {
+        $crate::interrupt::free(|| {
             static mut VAR: Option<$ty> = None;
 
             #[allow(unsafe_code)]

src/peripheral/mod.rs

@@ -165,7 +165,7 @@ impl Peripherals {
     /// Returns all the core peripherals *once*
     #[inline]
     pub fn take() -> Option<Self> {
-        interrupt::free(|_| {
+        interrupt::free(|| {
             if unsafe { TAKEN } {
                 None
             } else {

src/peripheral/sau.rs

@@ -162,7 +162,7 @@ impl SAU {
     /// This function is executed under a critical section to prevent having inconsistent results.
     #[inline]
     pub fn set_region(&mut self, region_number: u8, region: SauRegion) -> Result<(), SauError> {
-        interrupt::free(|_| {
+        interrupt::free(|| {
             let base_address = region.base_address;
             let limit_address = region.limit_address;
             let attribute = region.attribute;
@@ -215,7 +215,7 @@ impl SAU {
     /// This function is executed under a critical section to prevent having inconsistent results.
     #[inline]
     pub fn get_region(&mut self, region_number: u8) -> Result<SauRegion, SauError> {
-        interrupt::free(|_| {
+        interrupt::free(|| {
             if region_number >= self.region_numbers() {
                 Err(SauError::RegionNumberTooBig)
             } else {