Fix clippy errors

kernel/src/arch/x86_64/interrupts.rs

@@ -40,7 +40,7 @@ pub enum InterruptIndex {
 }
 
 impl InterruptIndex {
-    fn as_u8(self) -> u8 {
+    const fn as_u8(self) -> u8 {
         self as u8
     }
 

kernel/src/arch/x86_64/memmap.rs

@@ -48,9 +48,8 @@ pub static _KERNEL_PHYSICAL_MEMORY_OFFSET: Lazy<(u64, u64)> = Lazy::new(|| {
 ///
 /// Panics if the memory map was not found in MEMORY_MAP_REQUEST.
 pub fn get_memory_map() -> &'static MemoryMapResponse {
-    if let Some(memory_map) = MEMORY_MAP_REQUEST.get_response() {
-        memory_map
-    } else {
-        unreachable!("Could not fetch memory map from Limine.")
-    }
+    MEMORY_MAP_REQUEST.get_response().map_or_else(
+        || unreachable!("Could not fetch memory map from Limine."),
+        |memory_map| memory_map,
+    )
 }

kernel/src/arch/x86_64/memory.rs

@@ -55,7 +55,7 @@ pub unsafe fn init(physical_memory_offset: VirtAddr) -> OffsetPageTable<'static>
     }
 }
 
-pub(crate) struct FoundryOSFrameAllocator {
+pub struct FoundryOSFrameAllocator {
     memory_map: &'static MemoryMapResponse,
     next: usize,
 }
@@ -66,8 +66,8 @@ impl FoundryOSFrameAllocator {
     /// This function takes a reference to a `MemoryMapResponse` and initializes a
     /// `FoundryOSFrameAllocator` with it. The `next` field is set to 0, indicating that
     /// the first frame to be allocated is the first frame in the memory map.
-    pub unsafe fn init(memory_map: &'static MemoryMapResponse) -> FoundryOSFrameAllocator {
-        FoundryOSFrameAllocator {
+    pub const unsafe fn init(memory_map: &'static MemoryMapResponse) -> Self {
+        Self {
             memory_map,
             next: 0,
         }

kernel/src/arch/x86_64/mod.rs

@@ -4,4 +4,4 @@ pub mod interrupts;
 
 pub mod memory;
 
-pub(crate) mod memmap;
+pub mod memmap;

kernel/src/lib.rs

@@ -1,5 +1,15 @@
 #![no_std]
 #![feature(abi_x86_interrupt)]
+#![warn(
+    clippy::correctness,
+    clippy::nursery,
+    clippy::unnecessary_cast,
+    clippy::all,
+    clippy::suspicious,
+    clippy::perf,
+    rustdoc::missing_errors_doc,
+    rustdoc::missing_panics_doc
+)]
 
 extern crate alloc;
 

kernel/src/main.rs

@@ -4,13 +4,11 @@
 extern crate alloc;
 
 use libk::{
-    // scheduling::task::{Executor, Task},
     drivers::{
-        io::{self, ascii::WRITER, keyboard},
+        io::{self, keyboard},
         scheduling::task::{Executor, Task},
     },
     prelude::*,
-    resources::font::FONT_SPLEEN_8X16,
 };
 
 #[unsafe(no_mangle)]

libk/src/drivers/io/ascii/mod.rs

@@ -60,7 +60,7 @@ impl Writer {
         )
     }
 
-    pub fn set_font(&mut self, font: &'static Font) {
+    pub const fn set_font(&mut self, font: &'static Font) {
         self.font = font;
     }
 

libk/src/drivers/io/keyboard.rs

@@ -17,7 +17,7 @@ static WAKER: AtomicWaker = AtomicWaker::new();
 
 pub fn add_scancode(scancode: u8) {
     if let Some(queue) = KBD_QUEUE.get() {
-        if let Err(_) = queue.push(scancode) {
+        if queue.push(scancode).is_err() {
             println!("WARNING: scancode queue full; dropping keyboard input");
         } else {
             WAKER.wake();
@@ -34,7 +34,13 @@ pub struct ScancodeStream {
 impl ScancodeStream {
     pub fn new() -> Self {
         KBD_QUEUE.call_once(|| ArrayQueue::new(5));
-        ScancodeStream { _private: () }
+        Self { _private: () }
+    }
+}
+
+impl Default for ScancodeStream {
+    fn default() -> Self {
+        Self::new()
     }
 }
 
@@ -48,15 +54,12 @@ impl Stream for ScancodeStream {
             return Poll::Ready(Some(scancode));
         }
 
-        WAKER.register(&cx.waker());
+        WAKER.register(cx.waker());
 
-        match queue.pop() {
-            Some(scancode) => {
+        queue.pop().map_or(Poll::Pending, |scancode| {
             WAKER.take();
             Poll::Ready(Some(scancode))
-            }
-            None => Poll::Pending,
-        }
+        })
     }
 }
 

libk/src/drivers/scheduling/task.rs

@@ -13,8 +13,8 @@ pub struct Task {
 }
 
 impl Task {
-    pub fn new(future: impl Future<Output = ()> + 'static) -> Task {
-        Task {
+    pub fn new(future: impl Future<Output = ()> + 'static) -> Self {
+        Self {
             id: TaskId::new(),
             future: Box::pin(future),
         }
@@ -31,7 +31,7 @@ struct TaskId(u64);
 impl TaskId {
     fn new() -> Self {
         static NEXT: AtomicU64 = AtomicU64::new(0);
-        TaskId(NEXT.fetch_add(1, core::sync::atomic::Ordering::Relaxed))
+        Self(NEXT.fetch_add(1, core::sync::atomic::Ordering::Relaxed))
     }
 }
 
@@ -43,7 +43,7 @@ pub struct Executor {
 
 impl Executor {
     pub fn new() -> Self {
-        Executor {
+        Self {
             tasks: BTreeMap::new(),
             task_queue: Arc::new(ArrayQueue::new(100)),
             waker_cache: BTreeMap::new(),
@@ -73,7 +73,7 @@ impl Executor {
             };
             let waker = waker_cache
                 .entry(task_id)
-                .or_insert_with(|| TaskWaker::new(task_id, task_queue.clone()));
+                .or_insert_with(|| TaskWaker::new_waker(task_id, task_queue.clone()));
             let mut context = Context::from_waker(waker);
             match task.poll(&mut context) {
                 Poll::Ready(()) => {
@@ -103,6 +103,12 @@ impl Executor {
     }
 }
 
+impl Default for Executor {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 struct TaskWaker {
     task_id: TaskId,
     task_queue: Arc<ArrayQueue<TaskId>>,
@@ -113,8 +119,8 @@ impl TaskWaker {
         self.task_queue.push(self.task_id).expect("task_queue full");
     }
 
-    fn new(task_id: TaskId, task_queue: Arc<ArrayQueue<TaskId>>) -> Waker {
-        Waker::from(Arc::new(TaskWaker {
+    fn new_waker(task_id: TaskId, task_queue: Arc<ArrayQueue<TaskId>>) -> Waker {
+        Waker::from(Arc::new(Self {
             task_id,
             task_queue,
         }))

libk/src/lib.rs

@@ -1,7 +1,16 @@
 #![no_std]
 #![allow(async_fn_in_trait)]
 #![warn(tail_expr_drop_order)]
-#![warn(clippy::correctness, clippy::perf, clippy::nursery)]
+#![warn(
+    clippy::correctness,
+    clippy::nursery,
+    clippy::unnecessary_cast,
+    clippy::all,
+    clippy::suspicious,
+    clippy::perf,
+    rustdoc::missing_errors_doc,
+    rustdoc::missing_panics_doc
+)]
 // alloc
 // io : serial, framebuffer, ascii(?), keyboard
 // ?????
@@ -11,6 +20,8 @@ extern crate alloc;
 
 pub mod drivers;
 pub mod resources;
+
+#[allow(unused)] // We aren't using much of this right now.
 pub mod std;
 
 /// Re-exports most of the IO macros as well as standard allocation stuff

libk/src/std/application.rs

@@ -1,5 +1,7 @@
 use crate::prelude::*;
 
+mod window;
+
 pub trait Application {
     type Output;
 

libk/src/std/application/mod.rs

@@ -1,2 +0,0 @@
-pub mod application;
-pub mod window;

libk/src/std/application/window.rs

@@ -9,8 +9,8 @@ pub struct Window {
 }
 
 impl Window {
-    pub const fn new() -> Window {
-        Window {
+    pub const fn new() -> Self {
+        Self {
             dimensions: Vec2::new(0, 0),
             position: Vec2::new(0, 0),
             bordered: true,
@@ -19,32 +19,32 @@ impl Window {
         }
     }
 
-    pub fn is_bordered(&self) -> bool {
+    pub const fn is_bordered(&self) -> bool {
         self.bordered
     }
 
-    pub fn is_open(&self) -> bool {
+    pub const fn is_open(&self) -> bool {
         self.opened
     }
 
-    pub fn open(&mut self) {
+    pub const fn open(&mut self) {
         self.opened = true;
     }
 
-    pub fn close(&mut self) {
+    pub const fn close(&mut self) {
         self.opened = false;
     }
 
     // some basic getters and setters for utility.
-    pub fn title(&self) -> &str {
-        &self.title
+    pub fn title(&'static self) -> &'static str {
+        self.title.as_str()
     }
 
-    pub fn dimensions(&self) -> Vec2<usize> {
+    pub const fn dimensions(&self) -> Vec2<usize> {
         self.dimensions
     }
 
-    pub fn position(&self) -> Vec2<usize> {
+    pub const fn position(&self) -> Vec2<usize> {
         self.position
     }
 
@@ -56,15 +56,21 @@ impl Window {
         self.position += offset;
     }
 
-    pub fn set_position(&mut self, position: Vec2<usize>) {
+    pub const fn set_position(&mut self, position: Vec2<usize>) {
         self.position = position;
     }
 
-    pub fn set_dimensions(&mut self, dimensions: Vec2<usize>) {
+    pub const fn set_dimensions(&mut self, dimensions: Vec2<usize>) {
         self.dimensions = dimensions;
     }
 }
 
+impl Default for Window {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Drop for Window {
     fn drop(&mut self) {
         if self.opened {

libk/src/std/maths/geometry.rs

@@ -20,7 +20,7 @@ impl Coordinate for i128 {}
 impl Coordinate for f32 {}
 impl Coordinate for f64 {}
 
-#[derive(Copy, Clone, PartialEq, PartialOrd, Debug)]
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Debug)]
 pub struct Vec2<T: Coordinate> {
     x: T,
     y: T,
@@ -32,14 +32,14 @@ impl<T: Coordinate> Vec2<T> {
     }
 
     pub fn into<S: Coordinate + From<T>>(&self) -> Vec2<S> {
-        Vec2::new(self.x.clone().into(), self.y.clone().into())
+        Vec2::new(self.x.into(), self.y.into())
     }
 
-    pub fn x(&self) -> T {
+    pub const fn x(&self) -> T {
         self.x
     }
 
-    pub fn y(&self) -> T {
+    pub const fn y(&self) -> T {
         self.y
     }
 }

libm/src/lib.rs

@@ -1,3 +1,14 @@
+#![warn(
+    clippy::correctness,
+    clippy::nursery,
+    clippy::unnecessary_cast,
+    clippy::all,
+    clippy::suspicious,
+    clippy::perf,
+    rustdoc::missing_errors_doc,
+    rustdoc::missing_panics_doc
+)]
+
 use std::fs::File;
 use std::io::{Read, Seek, SeekFrom};
 
@@ -10,13 +21,18 @@ extern crate proc_macro;
 #[proc_macro]
 pub fn include_font(item: TokenStream) -> TokenStream {
     let filename = parse_macro_input!(item as LitStr);
-    let file_path = filename.value().to_string();
+    let file_path = filename.value();
 
     println!("Loading font: [{}]", file_path);
 
-    let font_data = match Font::new(load_file(file_path)) {
+    let font_bytes = match load_file(file_path) {
+        Ok(bytes) => bytes,
+        Err(why) => panic!("{}", why),
+    };
+
+    let font_data = match Font::new(font_bytes) {
         Ok(font) => font.0,
-        Err(e) => panic!("{}", e),
+        Err(why) => panic!("{}", why),
     };
 
     quote!(
@@ -34,7 +50,7 @@ struct Font([[u8; 16]; 512]);
 impl Font {
     const MAGIC: u16 = 0x3604;
 
-    pub fn new(data: [u8; (32 + 2) * 512 + 4]) -> Result<Font, &'static str> {
+    pub fn new(data: [u8; (32 + 2) * 512 + 4]) -> Result<Self, &'static str> {
         let magic: u16 = (data[0] as u16) << 8 | data[1] as u16;
         let mode = data[2];
         let size = data[3];
@@ -55,15 +71,29 @@ impl Font {
             glyphs[i] = buff;
         }
 
-        Ok(Font(glyphs))
+        Ok(Self(glyphs))
     }
 }
 
-fn load_file(filename: String) -> [u8; (32 + 2) * 512 + 4] {
+type FileContents = [u8; (32 + 2) * 512 + 4];
+fn load_file(filename: String) -> Result<FileContents, std::io::Error> {
     let mut buf = [0; (32 + 2) * 512 + 4];
     let mut f = File::open(filename).unwrap();
     f.seek(SeekFrom::Start(0)).unwrap();
-    f.read(&mut buf).unwrap();
 
-    return buf;
+    loop {
+        match f.read(&mut buf) {
+            Ok(read) => {
+                if read == 0 {
+                    break;
+                }
+            }
+            Err(why) => {
+                eprintln!("Failed to read PS1 font file: {}", why);
+                return Err(why);
+            }
+        }
+    }
+
+    Ok(buf)
 }