Fix clippy warnings and formatting issues

- Use derive(Default) with #[default] attribute for SizeBucket and QueueTier
- Remove unused std::io::Write import in persistent_fdtd.rs
- Apply cargo fmt formatting fixes across multiple files

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: mivertowski

crates/ringkernel-core/src/analytics_context.rs

@@ -178,13 +178,20 @@ impl AnalyticsContext {
     /// # Type Parameters
     ///
     /// * `T` - Element type (must be Copy and have a meaningful zero value)
-    pub fn allocate_typed<T: Copy + Default + 'static>(&mut self, count: usize) -> AllocationHandle {
+    pub fn allocate_typed<T: Copy + Default + 'static>(
+        &mut self,
+        count: usize,
+    ) -> AllocationHandle {
         let size = count * std::mem::size_of::<T>();
         let handle = self.allocate(size);
 
         // Track typed allocation
         self.stats.typed_allocations += 1;
-        *self.stats.allocations_by_type.entry(TypeId::of::<T>()).or_insert(0) += 1;
+        *self
+            .stats
+            .allocations_by_type
+            .entry(TypeId::of::<T>())
+            .or_insert(0) += 1;
 
         handle
     }
@@ -337,7 +344,9 @@ impl AnalyticsContextBuilder {
     /// Build the context.
     pub fn build(self) -> AnalyticsContext {
         let mut ctx = match self.expected_allocations {
-            Some(cap) => AnalyticsContext::with_capacity(self.name, cap.max(self.preallocations.len())),
+            Some(cap) => {
+                AnalyticsContext::with_capacity(self.name, cap.max(self.preallocations.len()))
+            }
             None => AnalyticsContext::new(self.name),
         };
 

crates/ringkernel-core/src/dispatcher.rs

@@ -247,12 +247,7 @@ impl KernelDispatcher {
         // Dispatch via K2K broker
         let receipt = self
             .broker
-            .send_priority(
-                source,
-                kernel_id,
-                envelope,
-                self.config.default_priority,
-            )
+            .send_priority(source, kernel_id, envelope, self.config.default_priority)
             .await?;
 
         // Update metrics

crates/ringkernel-core/src/lib.rs

@@ -86,16 +86,16 @@ pub mod prelude {
     };
     pub use crate::context::*;
     pub use crate::control::*;
+    pub use crate::dispatcher::{
+        DispatcherBuilder, DispatcherConfig, DispatcherMetrics, KernelDispatcher,
+    };
     pub use crate::domain::{Domain, DomainMessage, DomainParseError};
     pub use crate::error::*;
     pub use crate::health::{
         BackoffStrategy, CircuitBreaker, CircuitBreakerConfig, CircuitBreakerStats, CircuitState,
         DegradationLevel, DegradationManager, DegradationStats, HealthCheck, HealthCheckResult,
         HealthChecker, HealthStatus, KernelHealth, KernelWatchdog, LoadSheddingPolicy, RetryPolicy,
     };
-    pub use crate::dispatcher::{
-        DispatcherBuilder, DispatcherConfig, DispatcherMetrics, KernelDispatcher,
-    };
     pub use crate::hlc::*;
     pub use crate::k2k::{
         DeliveryStatus, K2KBroker, K2KBuilder, K2KConfig, K2KEndpoint, K2KMessage,

crates/ringkernel-core/src/memory.rs

@@ -324,13 +324,14 @@ pub fn create_pool(
 ///
 /// Provides predefined size classes for efficient multi-size pooling.
 /// Allocations are rounded up to the smallest bucket that fits.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
 pub enum SizeBucket {
     /// Tiny buffers (256 bytes) - metadata, small messages.
     Tiny,
     /// Small buffers (1 KB) - typical message payloads.
     Small,
     /// Medium buffers (4 KB) - page-sized allocations.
+    #[default]
     Medium,
     /// Large buffers (16 KB) - batch operations.
     Large,
@@ -399,12 +400,6 @@ impl SizeBucket {
     }
 }
 
-impl Default for SizeBucket {
-    fn default() -> Self {
-        Self::Medium
-    }
-}
-
 impl std::fmt::Display for SizeBucket {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -442,7 +437,11 @@ impl StratifiedPoolStats {
 
     /// Get hit rate for a specific bucket.
     pub fn bucket_hit_rate(&self, bucket: SizeBucket) -> f64 {
-        let allocs = self.allocations_per_bucket.get(&bucket).copied().unwrap_or(0);
+        let allocs = self
+            .allocations_per_bucket
+            .get(&bucket)
+            .copied()
+            .unwrap_or(0);
         let hits = self.hits_per_bucket.get(&bucket).copied().unwrap_or(0);
         if allocs == 0 {
             0.0
@@ -495,7 +494,10 @@ impl StratifiedMemoryPool {
 
         for bucket in SizeBucket::ALL {
             let pool_name = format!("{}_{}", name, bucket);
-            buckets.insert(bucket, MemoryPool::new(pool_name, bucket.size(), max_buffers_per_bucket));
+            buckets.insert(
+                bucket,
+                MemoryPool::new(pool_name, bucket.size(), max_buffers_per_bucket),
+            );
         }
 
         Self {
@@ -552,7 +554,10 @@ impl StratifiedMemoryPool {
 
     /// Get current size of a specific bucket pool.
     pub fn bucket_size(&self, bucket: SizeBucket) -> usize {
-        self.buckets.get(&bucket).map(|p| p.current_size()).unwrap_or(0)
+        self.buckets
+            .get(&bucket)
+            .map(|p| p.current_size())
+            .unwrap_or(0)
     }
 
     /// Get total buffers currently pooled across all buckets.
@@ -662,7 +667,10 @@ pub fn create_stratified_pool_with_capacity(
     name: impl Into<String>,
     max_buffers_per_bucket: usize,
 ) -> SharedStratifiedPool {
-    Arc::new(StratifiedMemoryPool::with_capacity(name, max_buffers_per_bucket))
+    Arc::new(StratifiedMemoryPool::with_capacity(
+        name,
+        max_buffers_per_bucket,
+    ))
 }
 
 // ============================================================================
@@ -698,7 +706,11 @@ impl std::fmt::Debug for PressureReaction {
         match self {
             Self::None => write!(f, "PressureReaction::None"),
             Self::Shrink { target_utilization } => {
-                write!(f, "PressureReaction::Shrink {{ target_utilization: {} }}", target_utilization)
+                write!(
+                    f,
+                    "PressureReaction::Shrink {{ target_utilization: {} }}",
+                    target_utilization
+                )
             }
             Self::Callback(_) => write!(f, "PressureReaction::Callback(<fn>)"),
         }
@@ -1006,9 +1018,9 @@ mod tests {
         let pool = StratifiedMemoryPool::new("test");
 
         // Allocate different sizes
-        let buf1 = pool.allocate(100);   // Tiny
-        let buf2 = pool.allocate(500);   // Small
-        let buf3 = pool.allocate(2000);  // Medium
+        let buf1 = pool.allocate(100); // Tiny
+        let buf2 = pool.allocate(500); // Small
+        let buf3 = pool.allocate(2000); // Medium
 
         assert_eq!(buf1.bucket(), SizeBucket::Tiny);
         assert_eq!(buf2.bucket(), SizeBucket::Small);
@@ -1046,14 +1058,20 @@ mod tests {
         let pool = StratifiedMemoryPool::new("test");
 
         // Allocate from different buckets
-        let _buf1 = pool.allocate(100);  // Tiny
-        let _buf2 = pool.allocate(500);  // Small
-        let _buf3 = pool.allocate(100);  // Tiny again
+        let _buf1 = pool.allocate(100); // Tiny
+        let _buf2 = pool.allocate(500); // Small
+        let _buf3 = pool.allocate(100); // Tiny again
 
         let stats = pool.stats();
         assert_eq!(stats.total_allocations, 3);
-        assert_eq!(stats.allocations_per_bucket.get(&SizeBucket::Tiny), Some(&2));
-        assert_eq!(stats.allocations_per_bucket.get(&SizeBucket::Small), Some(&1));
+        assert_eq!(
+            stats.allocations_per_bucket.get(&SizeBucket::Tiny),
+            Some(&2)
+        );
+        assert_eq!(
+            stats.allocations_per_bucket.get(&SizeBucket::Small),
+            Some(&1)
+        );
     }
 
     #[test]
@@ -1173,7 +1191,9 @@ mod tests {
         let none = PressureReaction::None;
         assert!(format!("{:?}", none).contains("None"));
 
-        let shrink = PressureReaction::Shrink { target_utilization: 0.5 };
+        let shrink = PressureReaction::Shrink {
+            target_utilization: 0.5,
+        };
         assert!(format!("{:?}", shrink).contains("0.5"));
 
         let callback = PressureReaction::Callback(Box::new(|_| {}));

crates/ringkernel-core/src/persistent_message.rs

@@ -256,9 +256,7 @@ mod tests {
 
         table.register(HandlerRegistration::new(1, "fraud_check", 1001));
         table.register(HandlerRegistration::new(2, "aggregate", 1002));
-        table.register(
-            HandlerRegistration::new(3, "pattern_detect", 1003).with_response(2003),
-        );
+        table.register(HandlerRegistration::new(3, "pattern_detect", 1003).with_response(2003));
 
         assert_eq!(table.len(), 3);
         assert_eq!(table.max_handler_id(), 3);

crates/ringkernel-core/src/queue.rs

@@ -381,11 +381,12 @@ impl MessageQueue for BoundedQueue {
 ///
 /// Instead of dynamic resizing (which is complex for GPU memory),
 /// we provide predefined tiers that can be selected based on expected load.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
 pub enum QueueTier {
     /// Small queues (256 messages) - low traffic, minimal memory.
     Small,
     /// Medium queues (1024 messages) - moderate traffic.
+    #[default]
     Medium,
     /// Large queues (4096 messages) - high traffic.
     Large,
@@ -449,12 +450,6 @@ impl QueueTier {
     }
 }
 
-impl Default for QueueTier {
-    fn default() -> Self {
-        Self::Medium
-    }
-}
-
 /// Factory for creating appropriately-sized message queues.
 ///
 /// # Example
@@ -492,7 +487,10 @@ impl QueueFactory {
     ///
     /// * `messages_per_second` - Expected message throughput
     /// * `headroom_ms` - Desired buffer time in milliseconds
-    pub fn create_for_throughput(messages_per_second: u64, headroom_ms: u64) -> Box<dyn MessageQueue> {
+    pub fn create_for_throughput(
+        messages_per_second: u64,
+        headroom_ms: u64,
+    ) -> Box<dyn MessageQueue> {
         let tier = QueueTier::for_throughput(messages_per_second, headroom_ms);
         Box::new(Self::create_mpsc(tier))
     }
@@ -586,7 +584,11 @@ impl QueueMonitor {
     /// Suggest whether to upgrade the queue tier based on observed utilization.
     ///
     /// Returns `Some(QueueTier)` if upgrade is recommended, `None` otherwise.
-    pub fn suggest_upgrade(&self, queue: &dyn MessageQueue, current_tier: QueueTier) -> Option<QueueTier> {
+    pub fn suggest_upgrade(
+        &self,
+        queue: &dyn MessageQueue,
+        current_tier: QueueTier,
+    ) -> Option<QueueTier> {
         let stats = queue.stats();
         let utilization = self.utilization(queue);
 
@@ -642,7 +644,11 @@ pub struct QueueMetrics {
 
 impl QueueMetrics {
     /// Capture metrics from a queue.
-    pub fn capture(queue: &dyn MessageQueue, monitor: &QueueMonitor, current_tier: Option<QueueTier>) -> Self {
+    pub fn capture(
+        queue: &dyn MessageQueue,
+        monitor: &QueueMonitor,
+        current_tier: Option<QueueTier>,
+    ) -> Self {
         let health = monitor.check(queue);
         let utilization = monitor.utilization(queue);
         let stats = queue.stats();
@@ -785,7 +791,10 @@ mod tests {
         assert_eq!(QueueTier::for_throughput(20000, 100), QueueTier::Large);
 
         // Very high traffic - 100000 msg/s with 100ms buffer = 10000 msgs needed
-        assert_eq!(QueueTier::for_throughput(100000, 100), QueueTier::ExtraLarge);
+        assert_eq!(
+            QueueTier::for_throughput(100000, 100),
+            QueueTier::ExtraLarge
+        );
     }
 
     #[test]
@@ -899,7 +908,9 @@ mod tests {
         for _ in 0..(QueueTier::ExtraLarge.capacity() * 3 / 4) {
             large_queue.try_enqueue(make_envelope()).unwrap();
         }
-        assert!(monitor.suggest_upgrade(&large_queue, QueueTier::ExtraLarge).is_none());
+        assert!(monitor
+            .suggest_upgrade(&large_queue, QueueTier::ExtraLarge)
+            .is_none());
     }
 
     #[test]

crates/ringkernel-cuda-codegen/src/persistent_fdtd.rs

@@ -850,7 +850,6 @@ pub fn compile_persistent_fdtd_to_ptx(config: &PersistentFdtdConfig) -> Result<S
     let cuda_code = generate_persistent_fdtd_kernel(config);
 
     // Use nvcc to compile to PTX
-    use std::io::Write;
     use std::process::Command;
 
     // Write to temp file

crates/ringkernel-cuda-codegen/src/ring_kernel.rs

@@ -1435,7 +1435,12 @@ pub fn generate_handler_dispatch_code(table: &CudaDispatchTable, indent: &str) -
     let mut code = String::new();
 
     if table.is_empty() {
-        writeln!(code, "{}// No handlers registered - dispatch table empty", indent).unwrap();
+        writeln!(
+            code,
+            "{}// No handlers registered - dispatch table empty",
+            indent
+        )
+        .unwrap();
         return code;
     }
 
@@ -1534,7 +1539,10 @@ struct __align__(64) ExtendedH2KMessage {
 /// # Returns
 ///
 /// Complete CUDA kernel code with handler dispatch.
-pub fn generate_multi_handler_kernel(config: &RingKernelConfig, table: &CudaDispatchTable) -> String {
+pub fn generate_multi_handler_kernel(
+    config: &RingKernelConfig,
+    table: &CudaDispatchTable,
+) -> String {
     let mut code = String::new();
 
     // Struct definitions
@@ -1994,9 +2002,9 @@ mod tests {
 
     #[test]
     fn test_generate_handler_dispatch_code_single_handler() {
-        let table = CudaDispatchTable::new()
-            .with_handler(CudaHandlerInfo::new(1, "handle_fraud")
-                .with_message_type("FraudCheck", 1001));
+        let table = CudaDispatchTable::new().with_handler(
+            CudaHandlerInfo::new(1, "handle_fraud").with_message_type("FraudCheck", 1001),
+        );
 
         let code = generate_handler_dispatch_code(&table, "    ");
 
@@ -2010,13 +2018,17 @@ mod tests {
     #[test]
     fn test_generate_handler_dispatch_code_multiple_handlers() {
         let table = CudaDispatchTable::new()
-            .with_handler(CudaHandlerInfo::new(1, "handle_fraud")
-                .with_message_type("FraudCheck", 1001))
-            .with_handler(CudaHandlerInfo::new(2, "handle_aggregate")
-                .with_message_type("Aggregate", 1002)
-                .with_response())
-            .with_handler(CudaHandlerInfo::new(5, "handle_pattern")
-                .with_message_type("Pattern", 1005));
+            .with_handler(
+                CudaHandlerInfo::new(1, "handle_fraud").with_message_type("FraudCheck", 1001),
+            )
+            .with_handler(
+                CudaHandlerInfo::new(2, "handle_aggregate")
+                    .with_message_type("Aggregate", 1002)
+                    .with_response(),
+            )
+            .with_handler(
+                CudaHandlerInfo::new(5, "handle_pattern").with_message_type("Pattern", 1005),
+            );
 
         let code = generate_handler_dispatch_code(&table, "    ");
 
@@ -2030,9 +2042,10 @@ mod tests {
 
     #[test]
     fn test_generate_handler_dispatch_code_with_inline_body() {
-        let table = CudaDispatchTable::new()
-            .with_handler(CudaHandlerInfo::new(1, "inline_handler")
-                .with_cuda_body("int result = msg->payload[0] * 2;\nresponse->result = result;"));
+        let table = CudaDispatchTable::new().with_handler(
+            CudaHandlerInfo::new(1, "inline_handler")
+                .with_cuda_body("int result = msg->payload[0] * 2;\nresponse->result = result;"),
+        );
 
         let code = generate_handler_dispatch_code(&table, "    ");