formatting: align formatting

Align to recent changes to formatting.

Author: arkjedrz

src/containers/fixed_capacity/string.rs

@@ -38,7 +38,10 @@ impl FixedCapacityString {
     /// - Panics if the memory allocation fails.
     #[must_use]
     pub fn new(capacity: usize) -> Self {
-        assert!(capacity <= u32::MAX as usize, "FixedCapacityString can hold at most u32::MAX bytes");
+        assert!(
+            capacity <= u32::MAX as usize,
+            "FixedCapacityString can hold at most u32::MAX bytes"
+        );
         Self {
             inner: GenericString::new(capacity as u32),
         }

src/containers/generic/queue.rs

@@ -16,8 +16,8 @@ use core::mem::needs_drop;
 use core::ops::Range;
 use core::ptr;
 
-use crate::InsufficientCapacity;
 use crate::storage::Storage;
+use crate::InsufficientCapacity;
 
 #[repr(C)]
 pub struct GenericQueue<T, S: Storage<T>> {

src/containers/generic/string.rs

@@ -16,8 +16,8 @@ use core::ops;
 use core::str;
 
 use super::vec::GenericVec;
-use crate::InsufficientCapacity;
 use crate::storage::Storage;
+use crate::InsufficientCapacity;
 
 /// A UTF-8 encoded string which is generic over its storage method.
 #[repr(transparent)]

src/containers/generic/vec.rs

@@ -17,8 +17,8 @@ use core::mem::needs_drop;
 use core::ops;
 use core::ptr;
 
-use crate::InsufficientCapacity;
 use crate::storage::Storage;
+use crate::InsufficientCapacity;
 
 #[repr(C)]
 pub struct GenericVec<T, S: Storage<T>> {
@@ -143,12 +143,14 @@ impl<T: Copy, S: Storage<T>> GenericVec<T, S> {
     /// If the vector has sufficient spare capacity, the operation succeeds and a reference to those elements is returned;
     /// otherwise, `Err(InsufficientCapacity)` is returned.
     pub fn extend_from_slice(&mut self, other: &[T]) -> Result<&mut [T], InsufficientCapacity> {
-        let new_len = (self.len as usize).checked_add(other.len()).ok_or(InsufficientCapacity)?;
+        let new_len = (self.len as usize)
+            .checked_add(other.len())
+            .ok_or(InsufficientCapacity)?;
         if new_len <= self.capacity() {
             let new_len = new_len as u32; // No overflow, because new_len <= capacity <= u32::MAX
-            // SAFETY:
-            // - `self.len <= new_len``, because the addition didn't overflow
-            // - `new_len <= self.capacity()` as per check above
+                                          // SAFETY:
+                                          // - `self.len <= new_len``, because the addition didn't overflow
+                                          // - `new_len <= self.capacity()` as per check above
             let target = unsafe { self.storage.subslice_mut(self.len, new_len) };
             // SAFETY:
             // - `other.as_ptr()` is valid for reads of `other.len()` elements, because it's a valid slice reference

src/containers/storage/heap.rs

@@ -11,9 +11,9 @@
 // SPDX-License-Identifier: Apache-2.0
 // *******************************************************************************
 
-use alloc::alloc::Layout;
 use alloc::alloc::alloc;
 use alloc::alloc::dealloc;
+use alloc::alloc::Layout;
 use core::marker::PhantomData;
 use core::mem::MaybeUninit;
 use core::ptr;
@@ -47,7 +47,12 @@ impl<T> Storage<T> for Heap<T> {
     ///
     /// Panics if the memory allocation failed.
     fn new(capacity: u32) -> Self {
-        Self::try_new(capacity).unwrap_or_else(|| panic!("failed to allocate {capacity} elements of {typ}", typ = core::any::type_name::<T>()))
+        Self::try_new(capacity).unwrap_or_else(|| {
+            panic!(
+                "failed to allocate {capacity} elements of {typ}",
+                typ = core::any::type_name::<T>()
+            )
+        })
     }
 
     /// Tries to create a new instance with capacity for exactly the given number of elements.
@@ -147,11 +152,20 @@ mod tests {
             if capacity > 2 {
                 let partial_slice = unsafe { instance.subslice(1, 2) };
                 assert_eq!(partial_slice.len(), 1);
-                assert_eq!(partial_slice as *const T, instance.elements.as_ptr().wrapping_add(1));
+                assert_eq!(
+                    partial_slice as *const T,
+                    instance.elements.as_ptr().wrapping_add(1)
+                );
 
                 let end_slice = unsafe { instance.subslice(capacity - 1, capacity) };
                 assert_eq!(end_slice.len(), 1);
-                assert_eq!(end_slice as *const T, instance.elements.as_ptr().wrapping_add(capacity as usize - 1));
+                assert_eq!(
+                    end_slice as *const T,
+                    instance
+                        .elements
+                        .as_ptr()
+                        .wrapping_add(capacity as usize - 1)
+                );
             }
         }
 
@@ -178,11 +192,20 @@ mod tests {
             if capacity >= 2 {
                 let partial_slice = unsafe { instance.subslice_mut(1, 2) };
                 assert_eq!(partial_slice.len(), 1);
-                assert_eq!(partial_slice as *mut T, instance.elements.as_ptr().wrapping_add(1));
+                assert_eq!(
+                    partial_slice as *mut T,
+                    instance.elements.as_ptr().wrapping_add(1)
+                );
 
                 let end_slice = unsafe { instance.subslice_mut(capacity - 1, capacity) };
                 assert_eq!(end_slice.len(), 1);
-                assert_eq!(end_slice as *mut T, instance.elements.as_ptr().wrapping_add(capacity as usize - 1));
+                assert_eq!(
+                    end_slice as *mut T,
+                    instance
+                        .elements
+                        .as_ptr()
+                        .wrapping_add(capacity as usize - 1)
+                );
             }
         }
 
@@ -203,15 +226,30 @@ mod tests {
                 assert_eq!(first_element.as_ptr(), instance.elements.as_ptr());
 
                 let last_element = unsafe { instance.element(capacity - 1) };
-                assert_eq!(last_element.as_ptr(), instance.elements.as_ptr().wrapping_add(capacity as usize - 1));
+                assert_eq!(
+                    last_element.as_ptr(),
+                    instance
+                        .elements
+                        .as_ptr()
+                        .wrapping_add(capacity as usize - 1)
+                );
             }
 
             if capacity >= 2 {
                 let second_element = unsafe { instance.element(1) };
-                assert_eq!(second_element.as_ptr(), instance.elements.as_ptr().wrapping_add(1));
+                assert_eq!(
+                    second_element.as_ptr(),
+                    instance.elements.as_ptr().wrapping_add(1)
+                );
 
                 let last_element = unsafe { instance.element(capacity - 2) };
-                assert_eq!(last_element.as_ptr(), instance.elements.as_ptr().wrapping_add(capacity as usize - 2));
+                assert_eq!(
+                    last_element.as_ptr(),
+                    instance
+                        .elements
+                        .as_ptr()
+                        .wrapping_add(capacity as usize - 2)
+                );
             }
         }
 
@@ -232,15 +270,30 @@ mod tests {
                 assert_eq!(first_element.as_ptr(), instance.elements.as_ptr());
 
                 let last_element = unsafe { instance.element_mut(capacity - 1) };
-                assert_eq!(last_element.as_ptr(), instance.elements.as_ptr().wrapping_add(capacity as usize - 1));
+                assert_eq!(
+                    last_element.as_ptr(),
+                    instance
+                        .elements
+                        .as_ptr()
+                        .wrapping_add(capacity as usize - 1)
+                );
             }
 
             if capacity >= 2 {
                 let second_element = unsafe { instance.element_mut(1) };
-                assert_eq!(second_element.as_ptr(), instance.elements.as_ptr().wrapping_add(1));
+                assert_eq!(
+                    second_element.as_ptr(),
+                    instance.elements.as_ptr().wrapping_add(1)
+                );
 
                 let last_element = unsafe { instance.element_mut(capacity - 2) };
-                assert_eq!(last_element.as_ptr(), instance.elements.as_ptr().wrapping_add(capacity as usize - 2));
+                assert_eq!(
+                    last_element.as_ptr(),
+                    instance
+                        .elements
+                        .as_ptr()
+                        .wrapping_add(capacity as usize - 2)
+                );
             }
         }
 

src/containers/storage/mod.rs

@@ -80,7 +80,8 @@ mod test_utils {
 
     impl<T> Storage<T> for Vec<MaybeUninit<T>> {
         fn new(capacity: u32) -> Self {
-            Self::try_new(capacity).unwrap_or_else(|| panic!("failed to allocate for {capacity} elements"))
+            Self::try_new(capacity)
+                .unwrap_or_else(|| panic!("failed to allocate for {capacity} elements"))
         }
 
         fn try_new(capacity: u32) -> Option<Self>

src/log/mw_log_fmt/builders.rs

@@ -80,7 +80,9 @@ impl<'a> DebugStruct<'a> {
     pub fn finish(&mut self) -> Result {
         if self.has_fields {
             let empty_spec = FormatSpec::new();
-            self.result = self.result.and_then(|_| self.writer.write_str(" }", &empty_spec));
+            self.result = self
+                .result
+                .and_then(|_| self.writer.write_str(" }", &empty_spec));
         }
         self.result
     }
@@ -253,7 +255,10 @@ impl<'a> DebugSet<'a> {
 
     /// Finishes output and returns any error encountered.
     pub fn finish(&mut self) -> Result {
-        self.inner.result = self.inner.result.and_then(|_| self.inner.writer.write_str("}", &FormatSpec::new()));
+        self.inner.result = self
+            .inner
+            .result
+            .and_then(|_| self.inner.writer.write_str("}", &FormatSpec::new()));
         self.inner.result
     }
 }
@@ -323,7 +328,10 @@ impl<'a> DebugList<'a> {
 
     /// Finishes output and returns any error encountered.
     pub fn finish(&mut self) -> Result {
-        self.inner.result = self.inner.result.and_then(|_| self.inner.writer.write_str("]", &FormatSpec::new()));
+        self.inner.result = self
+            .inner
+            .result
+            .and_then(|_| self.inner.writer.write_str("]", &FormatSpec::new()));
         self.inner.result
     }
 }
@@ -420,7 +428,10 @@ impl<'a> DebugMap<'a> {
         F: FnOnce(Writer) -> Result,
     {
         self.result = self.result.and_then(|_| {
-            assert!(self.has_key, "attempted to format a map value before its key");
+            assert!(
+                self.has_key,
+                "attempted to format a map value before its key"
+            );
             value_fmt(self.writer)?;
             self.has_key = false;
             Ok(())
@@ -446,7 +457,10 @@ impl<'a> DebugMap<'a> {
     /// Marks the map as non-exhaustive, indicating to the reader that there are some other entries that are not shown in the debug representation.
     pub fn finish_non_exhaustive(&mut self) -> Result {
         self.result = self.result.and_then(|_| {
-            assert!(!self.has_key, "attempted to finish a map with a partial entry");
+            assert!(
+                !self.has_key,
+                "attempted to finish a map with a partial entry"
+            );
 
             let empty_spec = FormatSpec::new();
             if self.has_fields {
@@ -466,7 +480,10 @@ impl<'a> DebugMap<'a> {
     /// Otherwise this method will panic.
     pub fn finish(&mut self) -> Result {
         self.result = self.result.and_then(|_| {
-            assert!(!self.has_key, "attempted to finish a map with a partial entry");
+            assert!(
+                !self.has_key,
+                "attempted to finish a map with a partial entry"
+            );
             let empty_spec = FormatSpec::new();
             self.writer.write_str("}", &empty_spec)
         });
@@ -542,7 +559,9 @@ mod tests {
 
         let mut writer = StringWriter::new();
         let spec = FormatSpec::new();
-        let _ = DebugStruct::new(&mut writer, &spec, "X").finish().map_err(|_| panic!("failed to finish"));
+        let _ = DebugStruct::new(&mut writer, &spec, "X")
+            .finish()
+            .map_err(|_| panic!("failed to finish"));
 
         assert_eq!(writer.get(), format!("{:?}", v));
     }
@@ -594,7 +613,9 @@ mod tests {
     fn test_tuple_empty_finish() {
         let mut writer = StringWriter::new();
         let spec = FormatSpec::new();
-        let _ = DebugTuple::new(&mut writer, &spec, "").finish().map_err(|_| panic!("failed to finish"));
+        let _ = DebugTuple::new(&mut writer, &spec, "")
+            .finish()
+            .map_err(|_| panic!("failed to finish"));
 
         assert_eq!(writer.get(), "");
     }
@@ -730,7 +751,10 @@ mod tests {
             .finish_non_exhaustive()
             .map_err(|_| panic!("failed to finish"));
 
-        assert_eq!(writer.get(), "{\"first\": 123, \"second\": 456, \"third\": 789, ..}");
+        assert_eq!(
+            writer.get(),
+            "{\"first\": 123, \"second\": 456, \"third\": 789, ..}"
+        );
     }
 
     #[test]

src/log/mw_log_fmt/fmt.rs

@@ -153,7 +153,10 @@ mod tests {
             Fragment::Placeholder(Placeholder::new(&-100i8, FormatSpec::new())),
             Fragment::Placeholder(Placeholder::new(&-1234i16, FormatSpec::new())),
             Fragment::Placeholder(Placeholder::new(&-123456i32, FormatSpec::new())),
-            Fragment::Placeholder(Placeholder::new(&-1200000000000000000i64, FormatSpec::new())),
+            Fragment::Placeholder(Placeholder::new(
+                &-1200000000000000000i64,
+                FormatSpec::new(),
+            )),
             Fragment::Placeholder(Placeholder::new(&123u8, FormatSpec::new())),
             Fragment::Placeholder(Placeholder::new(&1234u16, FormatSpec::new())),
             Fragment::Placeholder(Placeholder::new(&123456u32, FormatSpec::new())),
@@ -192,7 +195,10 @@ mod tests {
             Fragment::Placeholder(Placeholder::new(&-100i8, FormatSpec::new())),
             Fragment::Placeholder(Placeholder::new(&-1234i16, FormatSpec::new())),
             Fragment::Placeholder(Placeholder::new(&-123456i32, FormatSpec::new())),
-            Fragment::Placeholder(Placeholder::new(&-1200000000000000000i64, FormatSpec::new())),
+            Fragment::Placeholder(Placeholder::new(
+                &-1200000000000000000i64,
+                FormatSpec::new(),
+            )),
             Fragment::Placeholder(Placeholder::new(&123u8, FormatSpec::new())),
             Fragment::Placeholder(Placeholder::new(&1234u16, FormatSpec::new())),
             Fragment::Placeholder(Placeholder::new(&123456u32, FormatSpec::new())),

src/log/mw_log_fmt/fmt_impl_qm.rs

@@ -35,7 +35,10 @@ impl ScoreDebug for Path {
             }
 
             f.write_str(valid, spec)?;
-            f.write_str(core::char::REPLACEMENT_CHARACTER.encode_utf8(&mut [0; MAX_LEN_UTF8]), spec)?;
+            f.write_str(
+                core::char::REPLACEMENT_CHARACTER.encode_utf8(&mut [0; MAX_LEN_UTF8]),
+                spec,
+            )?;
         }
 
         Ok(())

src/log/mw_log_fmt/fmt_spec.rs

@@ -291,7 +291,17 @@ mod tests {
         let width = Some(1234);
         let precision = Some(5);
 
-        let format_spec = FormatSpec::from_params(display_hint, fill, align, sign, alternate, zero_pad, debug_as_hex, width, precision);
+        let format_spec = FormatSpec::from_params(
+            display_hint,
+            fill,
+            align,
+            sign,
+            alternate,
+            zero_pad,
+            debug_as_hex,
+            width,
+            precision,
+        );
 
         assert!(format_spec.get_display_hint() == display_hint);
         assert!(format_spec.get_fill() == fill);