Fixed most of the clippy warnings/suggestions.

kernel/src/arch/x86_64/gdt.rs

@@ -19,8 +19,8 @@ static TSS: Lazy<TaskStateSegment> = Lazy::new(|| {
         static mut STACK: [u8; STACK_SIZE] = [0; STACK_SIZE];
 
         let stack_start = VirtAddr::from_ptr(&raw const STACK);
-        let stack_end = stack_start + STACK_SIZE.try_into().unwrap();
-        stack_end
+
+        stack_start + STACK_SIZE.try_into().unwrap()
     };
     tss
 });
@@ -40,8 +40,8 @@ static GDT: Lazy<(GlobalDescriptorTable, Selectors)> = Lazy::new(|| {
         Selectors {
             code_selector,
             data_selector,
-            user_code_selector,
-            user_data_selector,
+            _user_code_selector: user_code_selector,
+            _user_data_selector: user_data_selector,
             tss_selector,
         },
     )
@@ -50,8 +50,8 @@ static GDT: Lazy<(GlobalDescriptorTable, Selectors)> = Lazy::new(|| {
 struct Selectors {
     code_selector: SegmentSelector,
     data_selector: SegmentSelector,
-    user_code_selector: SegmentSelector,
-    user_data_selector: SegmentSelector,
+    _user_code_selector: SegmentSelector,
+    _user_data_selector: SegmentSelector,
     tss_selector: SegmentSelector,
 }
 

kernel/src/arch/x86_64/interrupts.rs

@@ -1,6 +1,6 @@
-use lib_ascii::{print, println, println_log};
+use lib_ascii::println_log;
 use lib_serial::serial_println;
-use x86_64::instructions::port::Port;
+// use x86_64::instructions::port::Port;
 use x86_64::registers::control::Cr2;
 use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode};
 
@@ -81,7 +81,8 @@ extern "x86-interrupt" fn double_fault_handler(
 }
 
 extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStackFrame) {
-    use pc_keyboard::{layouts, DecodedKey, HandleControl, Keyboard, ScancodeSet1};
+    use pc_keyboard::{layouts, HandleControl, Keyboard, ScancodeSet1};
+    // use pc_keyboard::DecodedKey;
     use spin::Mutex;
     use x86_64::instructions::port::Port;
 
@@ -93,7 +94,7 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStac
         ))
     });
 
-    let mut keyboard = KEYBOARD.lock();
+    let _keyboard = KEYBOARD.lock();
     let mut port = Port::new(0x60);
 
     let scancode: u8 = unsafe { port.read() };

kernel/src/arch/x86_64/memmap.rs

@@ -35,7 +35,7 @@ static KERNEL_ADDRESS_REQUEST: KernelAddressRequest = KernelAddressRequest::new(
 /// ```
 ///
 /// Returns (virtual_base, physical_base)
-pub static KERNEL_PHYSICAL_MEMORY_OFFSET: Lazy<(u64, u64)> = Lazy::new(|| {
+pub static _KERNEL_PHYSICAL_MEMORY_OFFSET: Lazy<(u64, u64)> = Lazy::new(|| {
     let resp = KERNEL_ADDRESS_REQUEST.get_response().unwrap();
 
     // These are base addresses, using Limine's built in page table.
@@ -49,7 +49,7 @@ 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() {
-        return memory_map;
+        memory_map
     } else {
         unreachable!("Could not fetch memory map from Limine.")
     }

kernel/src/arch/x86_64/memory.rs

@@ -1,12 +1,18 @@
-use lib_alloc::allocator::FoundryAllocator;
+// use lib_alloc::allocator::FoundryAllocator;
 use limine::{memory_map::EntryType, response::MemoryMapResponse};
 use x86_64::{
-    addr,
+    // addr,
     registers::control::Cr3,
     structures::paging::{
-        page_table::FrameError, FrameAllocator, OffsetPageTable, PageTable, PhysFrame, Size4KiB,
+        // page_table::FrameError,
+        FrameAllocator,
+        OffsetPageTable,
+        PageTable,
+        PhysFrame,
+        Size4KiB,
     },
-    PhysAddr, VirtAddr,
+    PhysAddr,
+    VirtAddr,
 };
 
 /// Returns a mutable reference to the current level 4 page table.
@@ -93,7 +99,6 @@ unsafe impl FrameAllocator<Size4KiB> for FoundryOSFrameAllocator {
     ///
     /// - `Some(PhysFrame)`: If a usable frame is available.
     /// - `None`: If there are no more usable frames to allocate.
-
     fn allocate_frame(&mut self) -> Option<PhysFrame> {
         let frame = self.usable_frames().nth(self.next);
         self.next += 1;