zephyr: fmt update

Run `cargo fmt` to canonicalize the code.  This is a lot of whitespace
cleanups, so is likely to produce numerous conflicts with any pending
PRs.  But, the code should be better going forward.

Signed-off-by: David Brown <[email protected]>

Author: d3zd3z

zephyr/src/align.rs

@@ -34,11 +34,12 @@ impl_alignas!(1, 2, 4, 8, 16, 32, 64, 128, 256);
 /// member of the struct.
 #[repr(transparent)]
 pub struct AlignAs<const N: usize>([<AlignAsStruct as AlignAsTrait<N>>::Aligned; 0])
-    where
+where
     AlignAsStruct: AlignAsTrait<N>;
 
 impl<const N: usize> AlignAs<N>
-    where AlignAsStruct: AlignAsTrait<N>
+where
+    AlignAsStruct: AlignAsTrait<N>,
 {
     /// Construct a new AlignAs.
     ///

zephyr/src/lib.rs

@@ -53,7 +53,7 @@ use core::panic::PanicInfo;
 
 /// Override rust's panic.  This simplistic initial version just hangs in a loop.
 #[panic_handler]
-fn panic(info :&PanicInfo) -> ! {
+fn panic(info: &PanicInfo) -> ! {
     #[cfg(CONFIG_PRINTK)]
     {
         printkln!("panic: {}", info);

zephyr/src/logging/impl_printk.rs

@@ -24,15 +24,11 @@ impl Log for PrintkLogger {
     // printing will be racy.  Otherwise, the message will be broken into small chunks that are each
     // printed atomically.
     fn log(&self, record: &Record<'_>) {
-        printkln!("{}:{}: {}",
-                  record.level(),
-                  record.target(),
-                  record.args());
+        printkln!("{}:{}: {}", record.level(), record.target(), record.args());
     }
 
     // Flush is not needed.
-    fn flush(&self) {
-    }
+    fn flush(&self) {}
 }
 
 static PRINTK_LOGGER: PrintkLogger = PrintkLogger;

zephyr/src/logging/impl_zlog.rs

@@ -35,9 +35,7 @@ impl Log for ZlogLogger {
             // Zephyr doesn't have a separate trace, so fold that into debug.
             Level::Trace => raw::LOG_LEVEL_DBG,
         };
-        let mut msg = format!("{}: {}",
-                              record.target(),
-                              record.args());
+        let mut msg = format!("{}: {}", record.target(), record.args());
         // Append a null so this is a valid C string.  This lets us avoid an additional allocation
         // and copying.
         msg.push('\x00');
@@ -47,8 +45,7 @@ impl Log for ZlogLogger {
     }
 
     // Flush not needed.
-    fn flush(&self) {
-    }
+    fn flush(&self) {}
 }
 
 extern "C" {

zephyr/src/object.rs

@@ -188,8 +188,8 @@ where
             KOBJ_UNINITIALIZED,
             KOBJ_INITING,
             Ordering::AcqRel,
-            Ordering::Acquire)
-        {
+            Ordering::Acquire,
+        ) {
             return None;
         }
         let result = self.get_wrapped(args);
@@ -401,7 +401,7 @@ macro_rules! _kobj_stack {
                 [$crate::sys::thread::RealStaticThreadStack<{$crate::sys::thread::stack_len($size)}>; $asize] =
                 unsafe { ::core::mem::zeroed() };
 
-            $v static $name: 
+            $v static $name:
                 [$crate::_export::KStaticThreadStack; $asize] =
                 $crate::_export::KStaticThreadStack::new_from_array(&[< $name _REAL >]);
         }

zephyr/src/printk.rs

@@ -5,12 +5,7 @@
 //!
 //! This uses the `k_str_out` syscall, which is part of printk to output to the console.
 
-use core::fmt::{
-    Arguments,
-    Result,
-    Write,
-    write,
-};
+use core::fmt::{write, Arguments, Result, Write};
 
 /// Print to Zephyr's console, without a newline.
 ///

zephyr/src/sync.rs

@@ -30,17 +30,8 @@ pub use portable_atomic_util::Arc;
 
 mod mutex;
 
-pub use mutex::{
-    Mutex,
-    MutexGuard,
-    Condvar,
-    LockResult,
-    TryLockResult,
-};
+pub use mutex::{Condvar, LockResult, Mutex, MutexGuard, TryLockResult};
 
 mod spinmutex;
 
-pub use spinmutex::{
-    SpinMutex,
-    SpinMutexGuard,
-};
+pub use spinmutex::{SpinMutex, SpinMutexGuard};

zephyr/src/sync/channel.rs

@@ -70,13 +70,13 @@ pub fn unbounded_from<T>(queue: Queue) -> (Sender<T>, Receiver<T>) {
         flavor: SenderFlavor::Unbounded {
             queue: s,
             _phantom: PhantomData,
-        }
+        },
     };
     let r = Receiver {
         flavor: ReceiverFlavor::Unbounded {
             queue: r,
             _phantom: PhantomData,
-        }
+        },
     };
     (s, r)
 }
@@ -130,10 +130,7 @@ pub struct Message<T> {
 
 impl<T> Message<T> {
     fn new(data: T) -> Message<T> {
-        Message {
-            _private: 0,
-            data,
-        }
+        Message { _private: 0, data }
     }
 }
 
@@ -155,7 +152,8 @@ impl<T> Sender<T> {
     /// For unbounded channels, this will perform an allocation (and always send immediately).  For
     /// bounded channels, no allocation will be performed.
     pub fn send_timeout<D>(&self, msg: T, timeout: D) -> Result<(), SendError<T>>
-        where D: Into<Timeout>,
+    where
+        D: Into<Timeout>,
     {
         match &self.flavor {
             SenderFlavor::Unbounded { queue, .. } => {
@@ -233,15 +231,11 @@ impl<T> Drop for Sender<T> {
 impl<T> Clone for Sender<T> {
     fn clone(&self) -> Self {
         let flavor = match &self.flavor {
-            SenderFlavor::Unbounded { queue, .. } => {
-                SenderFlavor::Unbounded {
-                    queue: queue.acquire(),
-                    _phantom: PhantomData,
-                }
-            }
-            SenderFlavor::Bounded(chan) => {
-                SenderFlavor::Bounded(chan.acquire())
-            }
+            SenderFlavor::Unbounded { queue, .. } => SenderFlavor::Unbounded {
+                queue: queue.acquire(),
+                _phantom: PhantomData,
+            },
+            SenderFlavor::Bounded(chan) => SenderFlavor::Bounded(chan.acquire()),
         };
 
         Sender { flavor }
@@ -281,7 +275,8 @@ impl<T> Receiver<T> {
     /// operation can proceed or the operation times out.
     /// wake up and return an error.
     pub fn recv_timeout<D>(&self, timeout: D) -> Result<T, RecvError>
-        where D: Into<Timeout>,
+    where
+        D: Into<Timeout>,
     {
         match &self.flavor {
             ReceiverFlavor::Unbounded { queue, .. } => {
@@ -369,15 +364,11 @@ impl<T> Drop for Receiver<T> {
 impl<T> Clone for Receiver<T> {
     fn clone(&self) -> Self {
         let flavor = match &self.flavor {
-            ReceiverFlavor::Unbounded { queue, .. } => {
-                ReceiverFlavor::Unbounded {
-                    queue: queue.acquire(),
-                    _phantom: PhantomData,
-                }
-            }
-            ReceiverFlavor::Bounded(chan) => {
-                ReceiverFlavor::Bounded(chan.acquire())
-            }
+            ReceiverFlavor::Unbounded { queue, .. } => ReceiverFlavor::Unbounded {
+                queue: queue.acquire(),
+                _phantom: PhantomData,
+            },
+            ReceiverFlavor::Bounded(chan) => ReceiverFlavor::Bounded(chan.acquire()),
         };
 
         Receiver { flavor }
@@ -435,10 +426,8 @@ struct Bounded<T> {
 impl<T> Bounded<T> {
     fn new(cap: usize) -> Self {
         let slots: Box<[Slot<T>]> = (0..cap)
-            .map(|_| {
-                UnsafeCell::new(MaybeUninit::uninit())
-            })
-        .collect();
+            .map(|_| UnsafeCell::new(MaybeUninit::uninit()))
+            .collect();
         let slots = Box::into_pin(slots);
 
         let free = Queue::new().unwrap();
@@ -452,7 +441,11 @@ impl<T> Bounded<T> {
             }
         }
 
-        Bounded { _slots: slots, free, chan }
+        Bounded {
+            _slots: slots,
+            free,
+            chan,
+        }
     }
 }
 

zephyr/src/sync/channel/counter.rs

@@ -3,13 +3,12 @@
 
 // This file is taken from crossbeam-channels, with modifications to be nostd.
 
-
 extern crate alloc;
 
+use crate::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use alloc::boxed::Box;
 use core::ops;
 use core::ptr::NonNull;
-use crate::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 
 /// Reference counter internals.
 struct Counter<C> {

zephyr/src/sync/mutex.rs

@@ -11,8 +11,8 @@ use core::{
     ops::{Deref, DerefMut},
 };
 
-use crate::time::{Forever, NoWait};
 use crate::sys::sync as sys;
+use crate::time::{Forever, NoWait};
 
 /// Until poisoning is implemented, mutexes never return an error, and we just get back the guard.
 pub type LockResult<Guard> = Result<Guard, ()>;
@@ -90,7 +90,10 @@ impl<T> Mutex<T> {
     /// sys Mutex will be taken by this structure.  It is safe to share the underlying Mutex between
     /// different items, but without careful use, it is easy to deadlock, so it is not recommended.
     pub const fn new_from(t: T, raw_mutex: sys::Mutex) -> Mutex<T> {
-        Mutex { inner: raw_mutex, data: UnsafeCell::new(t) }
+        Mutex {
+            inner: raw_mutex,
+            data: UnsafeCell::new(t),
+        }
     }
 
     /// Construct a new Mutex, dynamically allocating the underlying sys Mutex.
@@ -114,9 +117,7 @@ impl<T: ?Sized> Mutex<T> {
     pub fn lock(&self) -> LockResult<MutexGuard<'_, T>> {
         // With `Forever`, should never return an error.
         self.inner.lock(Forever).unwrap();
-        unsafe {
-            Ok(MutexGuard::new(self))
-        }
+        unsafe { Ok(MutexGuard::new(self)) }
     }
 
     /// Attempts to acquire this lock.
@@ -127,34 +128,29 @@ impl<T: ?Sized> Mutex<T> {
     /// This function does not block.
     pub fn try_lock(&self) -> TryLockResult<MutexGuard<'_, T>> {
         match self.inner.lock(NoWait) {
-            Ok(()) => {
-                unsafe {
-                    Ok(MutexGuard::new(self))
-                }
-            }
+            Ok(()) => unsafe { Ok(MutexGuard::new(self)) },
             // TODO: It might be better to distinguish these errors, and only return the WouldBlock
             // if that is the corresponding error. But, the lock shouldn't fail in Zephyr.
-            Err(_) => {
-                Err(TryLockError::WouldBlock)
-            }
+            Err(_) => Err(TryLockError::WouldBlock),
         }
     }
 }
 
 impl<'mutex, T: ?Sized> MutexGuard<'mutex, T> {
     unsafe fn new(lock: &'mutex Mutex<T>) -> MutexGuard<'mutex, T> {
         // poison todo
-        MutexGuard { lock, _nosend: PhantomData }
+        MutexGuard {
+            lock,
+            _nosend: PhantomData,
+        }
     }
 }
 
 impl<T: ?Sized> Deref for MutexGuard<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &T {
-        unsafe {
-            &*self.lock.data.get()
-        }
+        unsafe { &*self.lock.data.get() }
     }
 }