kernel: apply clippy suggestions

Author: MabezDev

kernel/src/application/application_manager.rs

@@ -66,7 +66,7 @@ impl ApplicationManager {
     /// Create a new application manager from a chunk of ram
     pub fn new(ram: Ram, os_table_ptr: &'static mut Table) -> Self {
         Self {
-            ram: ram,
+            ram,
             target_cs: [0u8; 4],
             target_cs_idx: 0,
             service_fn: None,
@@ -111,21 +111,21 @@ impl ApplicationManager {
     fn digest_from_bytes(bytes: &[u8]) -> u32 {
         assert_eq!(bytes.len(), 4);
         // bytes arrive in reversed order                
-        let digest = ((u32::from(bytes[0])) << 24)
+        
+        ((u32::from(bytes[0])) << 24)
             | ((u32::from(bytes[1])) << 16)
             | ((u32::from(bytes[2])) << 8)
-            | (u32::from(bytes[3]));
-        digest
+            | (u32::from(bytes[3]))
     }
 
     /// Run the application
     pub fn execute(&mut self) -> Result<(), Error> {
         if !self.status.is_loaded {
             return Err(Error::NoApplication);
         }
-        let setup_ptr = Self::fn_ptr_from_slice(&self.ram.as_ref()[..4]);
-        let service_ptr = Self::fn_ptr_from_slice(&self.ram.as_ref()[4..8]);
-        let input_ptr = Self::fn_ptr_from_slice(&self.ram.as_ref()[8..12]);
+        let setup_ptr = Self::fn_ptr_from_slice(&self.ram.bytes()[..4]);
+        let service_ptr = Self::fn_ptr_from_slice(&self.ram.bytes()[4..8]);
+        let input_ptr = Self::fn_ptr_from_slice(&self.ram.bytes()[8..12]);
         let _result = unsafe {
             let setup: SetupFn = ::core::mem::transmute(setup_ptr);
             let service: ServiceFn = ::core::mem::transmute(service_ptr);
@@ -250,8 +250,8 @@ impl Ram {
     }
 
     /// Get an immutable reference to the internal ram buffer
-    pub fn as_ref(&self) -> &[u8] {
-        &self.ram
+    pub fn bytes(&self) -> &[u8] {
+        self.ram
     }
 
     pub fn as_slice(&self) -> &[u8] {

kernel/src/application/mod.rs

@@ -35,6 +35,10 @@ pub struct FrameBuffer {
 
 impl FrameBuffer {
     /// Create a frame buffer from a pointer
+    /// 
+    /// # Safety
+    /// 
+    /// The pointer passed **must** but a unique pointer and not shared or aliased.
     pub unsafe fn new(ptr: *mut u8, len: usize, width: u8, height: u8) -> Self {
         Self {
             ptr,

kernel/src/application/states/clock.rs

@@ -72,7 +72,7 @@ impl State for ClockState {
             .ok();
             self.buffer.clear();
 
-            write!(self.buffer, "{:02}%", soc).unwrap();
+            write!(self.buffer, "{soc:02}%").unwrap();
             Text::new(self.buffer.as_str(), Point::new(110, 12), style)
                 .draw(display)
                 .ok();

kernel/src/application/states/mwatch.rs

@@ -11,13 +11,10 @@ use embedded_graphics::pixelcolor::Rgb565;
 use embedded_graphics::prelude::*;
 use embedded_graphics::text::{Alignment, Text};
 
+#[derive(Default)]
 pub struct MWState {}
 
-impl Default for MWState {
-    fn default() -> Self {
-        Self {}
-    }
-}
+
 
 impl State for MWState {
     fn render(&mut self, _system: &mut System<impl Host>, display: &mut FrameBuffer) -> Option<Signal> {

kernel/src/application/states/notifications.rs

@@ -78,7 +78,7 @@ impl State for NotificationState {
                 system
                     .nm
                     .peek_notification(self.menu.selected() as usize, |notification| {
-                        self.body.render(display, &notification);
+                        self.body.render(display, notification);
                     });
             }
         }

kernel/src/application/states/uop.rs

@@ -4,15 +4,10 @@ use crate::{application::{states::prelude::*, FrameBuffer}, system::{System, inp
 
 use embedded_graphics::{image::{Image, ImageRaw}, pixelcolor::{Rgb565, raw::LittleEndian}, prelude::{Point, OriginDimensions, Dimensions}, Drawable};
 
+#[derive(Default)]
 pub struct UopState {}
 
-impl Default for UopState {
-    fn default() -> Self {
-        Self {
-            
-        }
-    }
-}
+
 
 impl State for UopState {
     fn render(&mut self, _system: &mut System<impl Host>, display: &mut FrameBuffer) -> Option<Signal> {

kernel/src/ingress/ingress_manager.rs

@@ -53,7 +53,7 @@ pub struct IngressManager {
 impl IngressManager {
     /// Constructs a new IngressManager
     pub fn new() -> Self {
-        IngressManager {
+        Self {
             rb: Queue::new(),
             state: State::Init,
             hex_chars: [0u8; 2],
@@ -253,6 +253,12 @@ impl IngressManager {
     }
 }
 
+impl Default for IngressManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;

kernel/src/system/input.rs

@@ -43,7 +43,7 @@ pub struct InputManager {
 
 impl InputManager {
     /// Creates a new instance of the InputManager
-    pub fn new() -> Self {
+    pub const fn new() -> Self {
         Self {
             raw_vector: 0,
             last_vector: 0,

kernel/src/system/notification.rs

@@ -31,8 +31,8 @@ impl Notification {
 
     pub fn from_buffer(buffer: &Buffer, idxs: &[usize; 3]) -> Result<Notification, NotificationError> {
         Ok(Notification {
-            section_indexes: idxs.clone(),
-            inner: buffer.clone()
+            section_indexes: *idxs,
+            inner: *buffer
         })
     }
 
@@ -60,7 +60,7 @@ pub struct NotificationManager {
 }
 
 impl NotificationManager {
-    pub fn new() -> NotificationManager {
+    pub const fn new() -> NotificationManager {
         NotificationManager {
             pool: [Notification::default(); BUFF_COUNT],
             idx: 0,
@@ -73,7 +73,7 @@ impl NotificationManager {
         F: FnOnce(&Notification),
     {
         let notification = &self.pool[index];
-        f(&notification);
+        f(notification);
     }
 
     pub fn idx(&self) -> usize {

kernel/src/system/syscall.rs

@@ -74,7 +74,7 @@ impl Syscall {
             }
         }
         // vals[0] // TODO day in week
-        Ok(Date::from_calendar_date(vals[3], (vals[2] as u8).try_into().map_err(|_| Error::ParseError)?, vals[1] as u8).map_err(|_| Error::ParseError)?)
+        Date::from_calendar_date(vals[3], (vals[2] as u8).try_into().map_err(|_| Error::ParseError)?, vals[1] as u8).map_err(|_| Error::ParseError)
     }
 
     pub fn time_from_str(s: &str) -> Result<Time, Error> {
@@ -88,7 +88,7 @@ impl Syscall {
                 }
             }
         }
-        Ok(Time::from_hms(vals[0], vals[1], vals[2]).map_err(|_| Error::ParseError)?)
+        Time::from_hms(vals[0], vals[1], vals[2]).map_err(|_| Error::ParseError)
     }
 }