rust: kernel: rustfmt documentation examples cleanups

Signed-off-by: Miguel Ojeda <ojeda@kernel.org>

Author: ojeda

rust/kernel/amba.rs

@@ -243,9 +243,9 @@ macro_rules! module_amba_driver {
 /// #   fn probe(_dev: &mut amba::Device, _id: Option<&Self::IdInfo>) -> Result {
 /// #       Ok(())
 /// #   }
-///     define_amba_id_table! {(), [
-///         ({ id: 0x00041061, mask: 0x000fffff }, None),
-///     ]}
+/// define_amba_id_table! {(), [
+///     ({ id: 0x00041061, mask: 0x000fffff }, None),
+/// ]}
 /// # }
 /// ```
 #[macro_export]

rust/kernel/driver.rs

@@ -280,16 +280,16 @@ macro_rules! first_item {
 /// assert_eq!([] as [u32; 0], second_item!());
 /// assert_eq!([10u32], second_item!((X, 10u32)));
 /// assert_eq!([10u32], second_item!((X, 10u32),));
-/// assert_eq!([10u32], second_item!(({X}, 10u32)));
-/// assert_eq!([10u32], second_item!(({X}, 10u32),));
+/// assert_eq!([10u32], second_item!(({ X }, 10u32)));
+/// assert_eq!([10u32], second_item!(({ X }, 10u32),));
 /// assert_eq!([10u32, 20], second_item!((X, 10u32), (X, 20)));
 /// assert_eq!([10u32, 20], second_item!((X, 10u32), (X, 20),));
-/// assert_eq!([10u32, 20], second_item!(({X}, 10u32), ({X}, 20)));
-/// assert_eq!([10u32, 20], second_item!(({X}, 10u32), ({X}, 20),));
+/// assert_eq!([10u32, 20], second_item!(({ X }, 10u32), ({ X }, 20)));
+/// assert_eq!([10u32, 20], second_item!(({ X }, 10u32), ({ X }, 20),));
 /// assert_eq!([10u32, 20, 30], second_item!((X, 10u32), (X, 20), (X, 30)));
 /// assert_eq!([10u32, 20, 30], second_item!((X, 10u32), (X, 20), (X, 30),));
-/// assert_eq!([10u32, 20, 30], second_item!(({X}, 10u32), ({X}, 20), ({X}, 30)));
-/// assert_eq!([10u32, 20, 30], second_item!(({X}, 10u32), ({X}, 20), ({X}, 30),));
+/// assert_eq!([10u32, 20, 30], second_item!(({ X }, 10u32), ({ X }, 20), ({ X }, 30)));
+/// assert_eq!([10u32, 20, 30], second_item!(({ X }, 10u32), ({ X }, 20), ({ X }, 30),));
 /// ```
 #[macro_export]
 macro_rules! second_item {

rust/kernel/fs/param.rs

@@ -417,12 +417,12 @@ impl<S, T: Fn(&mut S, &bindings::fs_parameter, &bindings::fs_parse_result) -> Re
 /// # use kernel::count_brace_items;
 ///
 /// assert_eq!(0, count_brace_items!());
-/// assert_eq!(1, count_brace_items!({A}));
-/// assert_eq!(1, count_brace_items!({A},));
-/// assert_eq!(2, count_brace_items!({A}, {B}));
-/// assert_eq!(2, count_brace_items!({A}, {B},));
-/// assert_eq!(3, count_brace_items!({A}, {B}, {C}));
-/// assert_eq!(3, count_brace_items!({A}, {B}, {C},));
+/// assert_eq!(1, count_brace_items!({ A }));
+/// assert_eq!(1, count_brace_items!({ A },));
+/// assert_eq!(2, count_brace_items!({ A }, { B }));
+/// assert_eq!(2, count_brace_items!({ A }, { B },));
+/// assert_eq!(3, count_brace_items!({ A }, { B }, { C }));
+/// assert_eq!(3, count_brace_items!({ A }, { B }, { C },));
 /// ```
 #[macro_export]
 macro_rules! count_brace_items {
@@ -462,7 +462,7 @@ macro_rules! count_brace_items {
 /// impl fs::Context<Self> for Example {
 ///     type Data = Box<State>;
 ///
-///     kernel::define_fs_params!{Box<State>,
+///     kernel::define_fs_params! {Box<State>,
 ///         {flag, "flag", |s, v| { s.flag = Some(v); Ok(()) } },
 ///         {flag_no, "flagno", |s, v| { s.flag_no = Some(v); Ok(()) } },
 ///         {bool, "bool", |s, v| { s.bool_value = Some(v); Ok(()) } },

rust/kernel/gpio.rs

@@ -79,7 +79,10 @@ pub trait Chip {
 ///
 /// ```
 /// # use kernel::prelude::*;
-/// use kernel::{device::RawDevice, gpio::{self, Registration}};
+/// use kernel::{
+///     device::RawDevice,
+///     gpio::{self, Registration},
+/// };
 ///
 /// struct MyGpioChip;
 /// #[vtable]

rust/kernel/io_mem.rs

@@ -56,7 +56,6 @@ impl Resource {
 ///
 ///     Ok(())
 /// }
-///
 /// ```
 pub struct IoMem<const SIZE: usize> {
     ptr: usize,

rust/kernel/irq.rs

@@ -395,8 +395,7 @@ pub trait Handler {
 /// }
 ///
 /// fn request_irq(irq: u32, data: Box<u32>) -> Result<irq::Registration<Example>> {
-///     irq::Registration::try_new(
-///         irq, data, irq::flags::SHARED, fmt!("example_{irq}"))
+///     irq::Registration::try_new(irq, data, irq::flags::SHARED, fmt!("example_{irq}"))
 /// }
 /// ```
 pub struct Registration<H: Handler>(InternalRegistration<H::Data>);
@@ -450,7 +449,10 @@ pub trait ThreadedHandler {
 ///
 /// ```
 /// # use kernel::prelude::*;
-/// use kernel::{irq, sync::{Ref, RefBorrow}};
+/// use kernel::{
+///     irq,
+///     sync::{Ref, RefBorrow},
+/// };
 ///
 /// struct Example;
 ///
@@ -463,8 +465,7 @@ pub trait ThreadedHandler {
 /// }
 ///
 /// fn request_irq(irq: u32, data: Ref<u32>) -> Result<irq::ThreadedRegistration<Example>> {
-///     irq::ThreadedRegistration::try_new(
-///         irq, data, irq::flags::SHARED, fmt!("example_{irq}"))
+///     irq::ThreadedRegistration::try_new(irq, data, irq::flags::SHARED, fmt!("example_{irq}"))
 /// }
 /// ```
 pub struct ThreadedRegistration<H: ThreadedHandler>(InternalRegistration<H::Data>);

rust/kernel/kasync/executor/workqueue.rs

@@ -174,8 +174,8 @@ struct ExecutorInner {
 /// ```
 /// # use kernel::prelude::*;
 /// use kernel::kasync::executor::workqueue::Executor;
-/// use kernel::workqueue;
 /// use kernel::spawn_task;
+/// use kernel::workqueue;
 ///
 /// fn example_shared_workqueue() -> Result {
 ///     let mut handle = Executor::try_new(workqueue::system())?;

rust/kernel/sync/nowait.rs

@@ -30,7 +30,7 @@ const CONTENDED: u8 = 2;
 ///     b: u32,
 /// }
 ///
-/// let x = NoWaitLock::new(Example{ a: 10, b: 20 });
+/// let x = NoWaitLock::new(Example { a: 10, b: 20 });
 ///
 /// // Modifying the protected value.
 /// {
@@ -72,7 +72,7 @@ const CONTENDED: u8 = 2;
 ///     b: u32,
 /// }
 ///
-/// let x = NoWaitLock::new(Example{ a: 10, b: 20 });
+/// let x = NoWaitLock::new(Example { a: 10, b: 20 });
 ///
 /// // No contention when lock is released.
 /// let guard = x.try_lock().unwrap();

rust/kernel/sync/seqlock.rs

@@ -18,8 +18,8 @@ use core::{cell::UnsafeCell, marker::PhantomPinned, ops::Deref, pin::Pin};
 /// # Examples
 ///
 ///```
-/// use kernel::sync::{SeqLock, SpinLock};
 /// use core::sync::atomic::{AtomicU32, Ordering};
+/// use kernel::sync::{SeqLock, SpinLock};
 ///
 /// struct Example {
 ///     a: AtomicU32,

rust/kernel/sync/smutex.rs

@@ -71,7 +71,7 @@ const LOCKED: usize = 1;
 ///     b: u32,
 /// }
 ///
-/// static EXAMPLE: Mutex<Example> = Mutex::new(Example{ a: 10, b: 20 });
+/// static EXAMPLE: Mutex<Example> = Mutex::new(Example { a: 10, b: 20 });
 ///
 /// fn inc_a(example: &Mutex<Example>) {
 ///     let mut guard = example.lock();
@@ -84,7 +84,7 @@ const LOCKED: usize = 1;
 /// }
 ///
 /// fn try_new(a: u32, b: u32) -> Result<Ref<Mutex<Example>>> {
-///     Ref::try_new(Mutex::new(Example {a, b}))
+///     Ref::try_new(Mutex::new(Example { a, b }))
 /// }
 ///
 /// assert_eq!(EXAMPLE.lock().a, 10);