zephyr: Apply cargo fmt to new work-queue code

The newly added code needs some fixups to comply with rustfmt.  Apply
these.

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

Author: d3zd3z

zephyr/src/kio.rs

@@ -52,9 +52,7 @@ where
     F: Future + 'static,
     F::Output: Send + 'static,
 {
-    WorkBuilder::new()
-        .set_name(name)
-        .start_local(future)
+    WorkBuilder::new().set_name(name).start_local(future)
 }
 
 /// Yield the current thread, returning it to the work queue to be run after other work on that

zephyr/src/lib.rs

@@ -13,6 +13,8 @@
 pub mod align;
 pub mod device;
 pub mod error;
+#[cfg(CONFIG_RUST_ALLOC)]
+pub mod kio;
 pub mod logging;
 pub mod object;
 #[cfg(CONFIG_RUST_ALLOC)]
@@ -24,8 +26,6 @@ pub mod time;
 pub mod timer;
 #[cfg(CONFIG_RUST_ALLOC)]
 pub mod work;
-#[cfg(CONFIG_RUST_ALLOC)]
-pub mod kio;
 
 pub use error::{Error, Result};
 

zephyr/src/simpletls.rs

@@ -75,7 +75,7 @@ impl<T: Copy + Send> StaticTls<T> {
         Self {
             data: AtomicPtr::new(ptr::null_mut()),
         }
-    } 
+    }
 
     /// Get the underlying Mutex out of the data, initializing it with an empty type if necessary.
     fn get_inner(&self) -> &Mutex<SimpleTls<T>> {
@@ -92,7 +92,8 @@ impl<T: Copy + Send> StaticTls<T> {
                     // If there was already a value, just use it.
                     None
                 }
-            });
+            },
+        );
         let data = match data {
             Ok(_) => {
                 // If the update stored something, it unhelpfully returns the old value, which was

zephyr/src/sync.rs

@@ -32,14 +32,7 @@ pub use portable_atomic_util::Weak;
 
 mod mutex;
 
-pub use mutex::{
-    Mutex,
-    MutexGuard,
-    Condvar,
-    LockResult,
-    TryLockResult,
-    TryLockError,
-};
+pub use mutex::{Condvar, LockResult, Mutex, MutexGuard, TryLockError, TryLockResult};
 
 mod spinmutex;
 

zephyr/src/sync/channel.rs

@@ -215,9 +215,11 @@ impl<T: Unpin> Sender<T> {
     /// This has the same behavior as [`send_timeout`], but as an Async function.
     ///
     /// [`send_timeout`]: Sender::send_timeout
-    pub fn send_timeout_async<'a>(&'a self, msg: T, timeout: impl Into<Timeout>)
-        -> impl Future<Output = Result<(), SendError<T>>> + 'a
-    {
+    pub fn send_timeout_async<'a>(
+        &'a self,
+        msg: T,
+        timeout: impl Into<Timeout>,
+    ) -> impl Future<Output = Result<(), SendError<T>>> + 'a {
         SendFuture {
             sender: self,
             msg: Some(msg),
@@ -245,7 +247,10 @@ struct SendFuture<'a, T: Unpin> {
 impl<'a, T: Unpin> Future for SendFuture<'a, T> {
     type Output = Result<(), SendError<T>>;
 
-    fn poll(self: Pin<&mut Self>, cx: &mut core::task::Context<'_>) -> core::task::Poll<Self::Output> {
+    fn poll(
+        self: Pin<&mut Self>,
+        cx: &mut core::task::Context<'_>,
+    ) -> core::task::Poll<Self::Output> {
         /*
         let this = unsafe {
             Pin::get_unchecked_mut(self)
@@ -426,9 +431,10 @@ impl<T> Receiver<T> {
     /// If the channel is empty and not disconnected, this call will block until the receive
     /// operation can proceed or the operation times out.
     /// wake up and return an error.
-    pub fn recv_timeout_async<'a>(&'a self, timeout: impl Into<Timeout>)
-        -> impl Future<Output = Result<T, RecvError>> + 'a
-    {
+    pub fn recv_timeout_async<'a>(
+        &'a self,
+        timeout: impl Into<Timeout>,
+    ) -> impl Future<Output = Result<T, RecvError>> + 'a {
         RecvFuture {
             receiver: self,
             timeout: timeout.into(),
@@ -644,7 +650,7 @@ pub struct RecvError;
 ///
 /// TODO: This function, in general, is completely worthless without Rust support for [async
 /// closures](https://rust-lang.github.io/rfcs/3668-async-closures.html).
-pub async fn event_loop_useless<T, EF, EFF> (
+pub async fn event_loop_useless<T, EF, EFF>(
     events: Receiver<T>,
     period: Duration,
     mut handle: EF,

zephyr/src/sys/sync/semaphore.rs

@@ -11,16 +11,16 @@
 //! operation, which in situation where counting is actually desired, will result in the count being
 //! incorrect.
 
-#[cfg(CONFIG_RUST_ALLOC)]
-use core::pin::Pin;
-#[cfg(CONFIG_RUST_ALLOC)]
-use core::task::{Context, Poll};
-#[cfg(CONFIG_RUST_ALLOC)]
-use core::future::Future;
 use core::ffi::c_uint;
 use core::fmt;
 #[cfg(CONFIG_RUST_ALLOC)]
+use core::future::Future;
+#[cfg(CONFIG_RUST_ALLOC)]
 use core::mem;
+#[cfg(CONFIG_RUST_ALLOC)]
+use core::pin::Pin;
+#[cfg(CONFIG_RUST_ALLOC)]
+use core::task::{Context, Poll};
 
 #[cfg(CONFIG_RUST_ALLOC)]
 use zephyr_sys::ETIMEDOUT;
@@ -81,7 +81,10 @@ impl Semaphore {
     ///
     /// Returns a future that either waits for the semaphore, or returns status.
     #[cfg(CONFIG_RUST_ALLOC)]
-    pub fn take_async<'a>(&'a self, timeout: impl Into<Timeout>) -> impl Future<Output = Result<()>> + 'a {
+    pub fn take_async<'a>(
+        &'a self,
+        timeout: impl Into<Timeout>,
+    ) -> impl Future<Output = Result<()>> + 'a {
         SemTake {
             sem: self,
             timeout: timeout.into(),
@@ -139,7 +142,6 @@ impl<'a> Future for SemTake<'a> {
         if self.ran {
             // If we ran once, and still don't have any data, indicate this as a timeout.
             return Poll::Ready(Err(crate::Error(ETIMEDOUT)));
-
         }
 
         // TODO: Clean this up.

zephyr/src/work.rs

@@ -194,7 +194,10 @@ use zephyr_sys::{
     k_work_queue_start, k_work_submit, k_work_submit_to_queue, ETIMEDOUT,
 };
 
-use crate::{error::to_result_void, kio::ContextExt, object::Fixed, simpletls::StaticTls, sys::thread::ThreadStack, time::Timeout};
+use crate::{
+    error::to_result_void, kio::ContextExt, object::Fixed, simpletls::StaticTls,
+    sys::thread::ThreadStack, time::Timeout,
+};
 
 pub mod futures;
 

zephyr/src/work/futures.rs

@@ -195,7 +195,7 @@ pub struct JoinHandle<F: Future> {
 unsafe impl<F> Send for JoinHandle<F>
 where
     F: Future,
-    F::Output: Send
+    F::Output: Send,
 {
 }
 
@@ -205,12 +205,7 @@ impl<F: Future + Send> JoinHandle<F> {
         // Answer holds the result when the work finishes.
         let answer = Arc::new(Answer::new());
 
-        let work = WorkData::new(
-            future,
-            Arc::downgrade(&answer),
-            builder.queue,
-            builder.name,
-        );
+        let work = WorkData::new(future, Arc::downgrade(&answer), builder.queue, builder.name);
         WorkData::submit(work).expect("Unable to enqueue worker");
 
         Self { answer }
@@ -422,9 +417,7 @@ impl<F: Future> WorkData<F> {
     fn submit(mut this: Pin<Box<Self>>) -> crate::Result<SubmitResult> {
         // SAFETY: This is unsafe because the pointer lose the Pin guarantee, but C code will not
         // move it.
-        let this_ref = unsafe {
-            Pin::get_unchecked_mut(this.as_mut())
-        };
+        let this_ref = unsafe { Pin::get_unchecked_mut(this.as_mut()) };
 
         let result = if let Some(queue) = this_ref.info.queue {
             unsafe {
@@ -474,9 +467,7 @@ impl<F: Future> WorkData<F> {
         // not necessarily at the beginning of the struct.
         let mut this = unsafe { Self::from_raw(work) };
 
-        let this_ref = unsafe {
-            Pin::get_unchecked_mut(this.as_mut())
-        };
+        let this_ref = unsafe { Pin::get_unchecked_mut(this.as_mut()) };
 
         // Set the next work to Forever, with no events.  TODO: This prevents the next poll from
         // being able to determine the reason for the wakeup.