fix: apply formatter and linter fixes

- Fix formatting and linting issues across platform modules
- Improve code style consistency in wrt-foundation and wrt-platform
- Address clippy warnings in type conversion modules

Author: avrabe

wrt-component/src/type_conversion/bidirectional.rs

@@ -840,8 +840,8 @@ pub fn core_value_to_types_componentvalue(
         wrt_foundation::values::Value::I64(v) => Ok(ComponentValue::S64(*v)),
         wrt_foundation::values::Value::F32(v) => Ok(ComponentValue::F32(*v)),
         wrt_foundation::values::Value::F64(v) => Ok(ComponentValue::F64(*v)),
-        wrt_foundation::values::Value::Ref(v) => Ok(ComponentValue::U32(*v)), /* Map reference
-                                                                                * to U32 */
+        wrt_foundation::values::Value::Ref(v) => Ok(ComponentValue::U32(*v)), // Map reference
+        // to U32
         _ => Err(Error::new(
             ErrorCategory::Type,
             codes::CONVERSION_ERROR,

wrt-foundation/src/bounded.rs

@@ -602,10 +602,7 @@ where
             })?;
 
         self.handler.write_data(offset, &item_bytes_buffer[..bytes_written]).map_err(|e| {
-            BoundedError::new(
-                BoundedErrorKind::SliceError,
-                e.message().unwrap_or("Write data failed"),
-            )
+            BoundedError::new(BoundedErrorKind::SliceError, "Write data failed: error occurred")
         })?;
 
         self.length += 1;
@@ -1030,10 +1027,7 @@ where
             })?;
 
         self.provider.write_data(offset, &item_bytes_buffer[..bytes_written]).map_err(|e| {
-            BoundedError::new(
-                BoundedErrorKind::SliceError,
-                e.message().unwrap_or("Write data failed"),
-            )
+            BoundedError::new(BoundedErrorKind::SliceError, "Write data failed: error occurred")
         })?;
 
         self.length += 1;
@@ -2854,11 +2848,8 @@ where
 {
     fn serialized_size(&self) -> usize {
         // Length (u32) + checksum + items
-        4 + self.checksum.serialized_size() + (self.length * if self.length > 0 { 
-            T::default().serialized_size() 
-        } else { 
-            0 
-        })
+        4 + self.checksum.serialized_size()
+            + (self.length * if self.length > 0 { T::default().serialized_size() } else { 0 })
     }
 
     fn to_bytes_with_provider<'a, PStream: crate::MemoryProvider>(
@@ -3674,8 +3665,9 @@ impl<const N_BYTES: usize, P: MemoryProvider + Default + Clone + PartialEq + Eq>
     }
 }
 
-// Note: This impl block was removed due to overlapping type bounds with the main impl block.
-// All necessary methods are already defined in the main impl block.
+// Note: This impl block was removed due to overlapping type bounds with the
+// main impl block. All necessary methods are already defined in the main impl
+// block.
 
 // ... (other BoundedVec impl methods, make sure to use `Error::` where it was
 // `Error::` before) For example, in BoundedVec::get:
@@ -3760,7 +3752,8 @@ where
     P: MemoryProvider + Clone + PartialEq + Eq,
 {
     // This impl block provides methods with additional constraints
-    // The verify_item_checksum_at_offset method is already defined in the main impl block
+    // The verify_item_checksum_at_offset method is already defined in the main impl
+    // block
 }
 
 // Alloc-dependent methods for BoundedString

wrt-foundation/src/prelude.rs

@@ -61,6 +61,11 @@ pub use hashbrown::HashMap;
 pub use wrt_error::prelude::*;
 pub use wrt_error::{codes, kinds, Error, ErrorCategory, Result};
 
+// Feature-gated re-exports that can't be included in the main use block
+#[cfg(feature = "alloc")]
+pub use crate::component_builder::{
+    ComponentTypeBuilder, ExportBuilder, ImportBuilder, NamespaceBuilder,
+};
 // Re-export from wrt_sync, only if the feature is active
 // #[cfg(feature = "wrt-sync")] // Or a more specific feature if wrt-sync is always a dep
 
@@ -132,7 +137,3 @@ pub use crate::{
     SafeMemoryHandler,
     SafeSlice,
 };
-
-// Feature-gated re-exports that can't be included in the main use block
-#[cfg(feature = "alloc")]
-pub use crate::component_builder::{ComponentTypeBuilder, ExportBuilder, ImportBuilder, NamespaceBuilder};

wrt-foundation/src/traits.rs

@@ -34,34 +34,6 @@ use alloc::vec::Vec;
 // This module provides common traits used for type conversions between format
 // and runtime representations.
 
-/// A writer that counts the number of bytes written without storing them.
-/// Used for calculating serialized sizes.
-struct CountingWriter {
-    count: usize,
-}
-
-impl CountingWriter {
-    fn new() -> Self {
-        Self { count: 0 }
-    }
-    
-    fn bytes_written(&self) -> usize {
-        self.count
-    }
-}
-
-impl BytesWriter for CountingWriter {
-    fn write_byte(&mut self, _byte: u8) -> WrtResult<()> {
-        self.count += 1;
-        Ok(())
-    }
-    
-    fn write_all(&mut self, bytes: &[u8]) -> WrtResult<()> {
-        self.count += bytes.len();
-        Ok(())
-    }
-}
-
 /// Trait for types that can be converted from a format representation
 pub trait FromFormat<T> {
     /// Convert from a format representation
@@ -174,16 +146,9 @@ impl Checksummable for alloc::string::String {
 pub trait ToBytes: Sized {
     /// Returns the size in bytes required to serialize this type.
     /// This should be a constant for fixed-size types.
-    /// Default implementation uses a temporary buffer to calculate size.
+    /// Default implementation returns 0 - types should override this.
     fn serialized_size(&self) -> usize {
-        // Default implementation - serialize to a counting writer to get size
-        let mut counter = CountingWriter::new();
-        let provider = NoStdProvider;
-        if self.to_bytes_with_provider(&mut WriteStream::new(&mut counter), &provider).is_ok() {
-            counter.bytes_written()
-        } else {
-            0 // Fallback if serialization fails
-        }
+        0 // Default fallback - should be overridden by implementations
     }
 
     /// Serializes the type into a byte stream using a provided memory stream
@@ -647,7 +612,7 @@ impl<T: ToBytes> ToBytes for Option<T> {
     fn serialized_size(&self) -> usize {
         match self {
             Some(value) => 1 + value.serialized_size(), // 1 byte for tag + value size
-            None => 1, // 1 byte for tag
+            None => 1,                                  // 1 byte for tag
         }
     }
 

wrt-foundation/src/validation.rs

@@ -18,10 +18,11 @@
 extern crate alloc;
 
 // Added BoundedVec for tests
+use wrt_error::ErrorCategory;
+
 #[cfg(test)]
 use crate::bounded::BoundedVec;
 use crate::prelude::{Debug /* Removed format, ToString as _ToString */};
-use wrt_error::ErrorCategory;
 #[cfg(test)]
 use crate::safe_memory::NoStdProvider;
 #[cfg(all(feature = "alloc", not(feature = "std")))]

wrt-platform/src/lib.rs

@@ -117,15 +117,14 @@ pub use qnx_partition::{
 };
 #[cfg(all(feature = "platform-qnx", target_os = "nto"))]
 pub use qnx_sync::{QnxFutex, QnxFutexBuilder, QnxSyncPriority};
-
+pub use sync::{FutexLike, SpinFutex, SpinFutexBuilder, TimeoutResult}; /* FutexLike is always available */
+// Re-export core error type (also available via prelude)
+pub use wrt_error::Error;
 // Export Zephyr specific implementations if enabled
 #[cfg(feature = "platform-zephyr")]
 pub use zephyr_memory::{ZephyrAllocator, ZephyrAllocatorBuilder, ZephyrMemoryFlags};
 #[cfg(feature = "platform-zephyr")]
-pub use zephyr_sync::{ZephyrFutex, ZephyrFutexBuilder, ZephyrSemaphoreFutex};
-pub use sync::{FutexLike, SpinFutex, SpinFutexBuilder, TimeoutResult}; /* FutexLike is always available */
-// Re-export core error type (also available via prelude)
-pub use wrt_error::Error; // This is fine as wrt_error::Error is always available
+pub use zephyr_sync::{ZephyrFutex, ZephyrFutexBuilder, ZephyrSemaphoreFutex}; // This is fine as wrt_error::Error is always available
 
 #[cfg(test)]
 #[allow(clippy::panic)] // Allow panics in the test module

wrt-platform/src/linux_memory.rs

@@ -17,7 +17,8 @@
 
 use core::ptr::{self, NonNull};
 
-// Safety: NonNull<u8> is safe to send between threads as it's just a pointer wrapper
+// Safety: NonNull<u8> is safe to send between threads as it's just a pointer
+// wrapper
 unsafe impl Send for LinuxAllocator {}
 unsafe impl Sync for LinuxAllocator {}
 

wrt-platform/src/linux_memory_arm64_mte.rs

@@ -17,7 +17,8 @@
 
 use core::ptr::{self, NonNull};
 
-// Safety: NonNull<u8> is safe to send between threads as it's just a pointer wrapper
+// Safety: NonNull<u8> is safe to send between threads as it's just a pointer
+// wrapper
 unsafe impl Send for LinuxArm64MteAllocator {}
 unsafe impl Sync for LinuxArm64MteAllocator {}
 

wrt-platform/src/linux_sync.rs

@@ -8,8 +8,8 @@
 // Licensed under the MIT license.
 // SPDX-License-Identifier: MIT
 
-//! Linux-specific `FutexLike` implementation using direct futex syscalls without
-//! libc.
+//! Linux-specific `FutexLike` implementation using direct futex syscalls
+//! without libc.
 //!
 //! This implementation provides wait/notify synchronization using Linux futex
 //! system calls directly, supporting no_std/no_alloc environments.
@@ -51,10 +51,7 @@ struct TimeSpec {
 impl TimeSpec {
     /// Create a new TimeSpec from Duration
     fn from_duration(duration: Duration) -> Self {
-        Self {
-            tv_sec: duration.as_secs() as i64,
-            tv_nsec: duration.subsec_nanos() as i64,
-        }
+        Self { tv_sec: duration.as_secs() as i64, tv_nsec: duration.subsec_nanos() as i64 }
     }
 
     /// Create a zero timeout (immediate)
@@ -75,17 +72,15 @@ pub struct LinuxFutex {
     _padding: [u8; 60], // 64 - sizeof(AtomicU32)
 }
 
-// Safety: LinuxFutex only contains AtomicU32 and padding, which are safe to send/sync
+// Safety: LinuxFutex only contains AtomicU32 and padding, which are safe to
+// send/sync
 unsafe impl Send for LinuxFutex {}
 unsafe impl Sync for LinuxFutex {}
 
 impl LinuxFutex {
     /// Creates a new `LinuxFutex` with the given initial value.
     pub fn new(initial_value: u32) -> Self {
-        Self {
-            value: AtomicU32::new(initial_value),
-            _padding: [0; 60],
-        }
+        Self { value: AtomicU32::new(initial_value), _padding: [0; 60] }
     }
 
     /// Direct syscall implementation of futex
@@ -135,14 +130,7 @@ impl LinuxFutex {
         // Call futex wake
         // SAFETY: We're calling futex wake with valid parameters.
         let result = unsafe {
-            Self::futex(
-                addr,
-                FUTEX_WAKE_PRIVATE,
-                count,
-                core::ptr::null(),
-                core::ptr::null(),
-                0,
-            )
+            Self::futex(addr, FUTEX_WAKE_PRIVATE, count, core::ptr::null(), core::ptr::null(), 0)
         };
 
         if result >= 0 {
@@ -203,25 +191,14 @@ impl FutexLike for LinuxFutex {
         // SAFETY: We're calling futex with valid parameters. addr points to self.value,
         // which is valid for the lifetime of self.
         let result = unsafe {
-            Self::futex(
-                addr,
-                FUTEX_WAIT_PRIVATE,
-                expected,
-                timeout_ptr,
-                core::ptr::null(),
-                0,
-            )
+            Self::futex(addr, FUTEX_WAIT_PRIVATE, expected, timeout_ptr, core::ptr::null(), 0)
         };
 
         match result {
             0 => Ok(()), // Woken up by notify
             -110 => {
                 // ETIMEDOUT - convert to system error as per trait contract
-                Err(Error::new(
-                    ErrorCategory::System,
-                    codes::SYSTEM_ERROR,
-                    "Futex wait timed out",
-                ))
+                Err(Error::new(ErrorCategory::System, codes::SYSTEM_ERROR, "Futex wait timed out"))
             }
             -11 => {
                 // EAGAIN - value changed before we could wait, this is success
@@ -247,10 +224,6 @@ impl FutexLike for LinuxFutex {
 
 impl fmt::Display for LinuxFutex {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(
-            f,
-            "LinuxFutex({})",
-            self.value.load(core::sync::atomic::Ordering::Relaxed)
-        )
+        write!(f, "LinuxFutex({})", self.value.load(core::sync::atomic::Ordering::Relaxed))
     }
-}
+}