misc: fixed some shit thanks to Clippy, have fun with the merge conflicts lmao

assembler/src/parser.rs

@@ -1,6 +1,4 @@
-use std::path::Iter;
-
-use common::prelude::Register;
+use std::str::FromStr;
 
 use crate::AssembleError;
 use crate::lexer::{Symbol, Token};
@@ -58,6 +56,7 @@ impl TokenType {
 // TODO: MAKE SURE I DO THE BIT SHIFT FOR LUI CODEGEN
 
 #[derive(Debug)]
+#[expect(dead_code)]
 pub struct Node(Option<Symbol>, Opcode, Vec<Token>);
 
 impl Iterator for Parser {
@@ -116,7 +115,8 @@ impl Parser {
             Opcode::Ldb | Opcode::Ldbs | Opcode::Ldh | Opcode::Ldhs | Opcode::Ldw => {
                 let base = self.expect_any(&[TokenType::Register, TokenType::Symbol])?;
                 let dest = self.expect_any(&[TokenType::Register, TokenType::Symbol])?;
-                let offset = self.maybe_expect(&[TokenType::Register, TokenType::Immediate]);
+                let offset =
+                    self.maybe_expect(&[TokenType::Register, TokenType::Immediate]);
                 if offset.is_some() {
                     self.tokens.pop();
                     args = vec![base, offset.unwrap(), dest];
@@ -129,7 +129,8 @@ impl Parser {
                 let base = self.expect_any(&[TokenType::Register, TokenType::Symbol])?;
                 let dest = self.expect_any(&[TokenType::Register, TokenType::Symbol])?;
 
-                let offset = self.maybe_expect(&[TokenType::Register, TokenType::Immediate]);
+                let offset =
+                    self.maybe_expect(&[TokenType::Register, TokenType::Immediate]);
                 if offset.is_some() {
                     self.tokens.pop();
                     args = vec![base, offset.unwrap(), dest];
@@ -224,10 +225,13 @@ impl Parser {
         Ok(Node(label, opcode, args))
     }
 
-    fn parse_data_definition(&mut self, opcode: Opcode) -> Result<Vec<Token>, AssembleError> {
+    fn parse_data_definition(
+        &mut self,
+        opcode: Opcode,
+    ) -> Result<Vec<Token>, AssembleError> {
         let mut values = Vec::new();
 
-        let name = self.expect(TokenType::Symbol)?;
+        let _name = self.expect(TokenType::Symbol)?;
         values.push(self.tokens.pop().unwrap());
 
         match opcode {
@@ -301,7 +305,7 @@ impl Parser {
     fn maybe_expect(&mut self, types: &[TokenType]) -> Option<Token> {
         let tok = self.tokens.last().unwrap();
 
-        if types.contains(&TokenType::from_token(&tok)) {
+        if types.contains(&TokenType::from_token(tok)) {
             Some(tok.clone())
         } else {
             None
@@ -363,70 +367,89 @@ pub enum Opcode {
     Lwi,
 }
 
+#[derive(Debug)]
+pub enum OpcodeFromStrError {
+    InvalidRegister(&'static str),
+}
+
+impl std::fmt::Display for OpcodeFromStrError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::InvalidRegister(reg) => write!(f, "register does not exist: {reg}"),
+        }
+    }
+}
+
+impl std::error::Error for OpcodeFromStrError {}
+
+impl FromStr for Opcode {
+    type Err = OpcodeFromStrError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "nop" => Ok(Self::Nop),
+            "mov" => Ok(Self::Mov),
+            "movs" => Ok(Self::Movs),
+            "ldb" => Ok(Self::Ldb),
+            "ldbs" => Ok(Self::Ldbs),
+            "ldh" => Ok(Self::Ldh),
+            "ldhs" => Ok(Self::Ldhs),
+            "ldw" => Ok(Self::Ldw),
+            "stb" => Ok(Self::Stb),
+            "sth" => Ok(Self::Sth),
+            "stw" => Ok(Self::Stw),
+            "lli" => Ok(Self::Lli),
+            "lui" => Ok(Self::Lui),
+            "jmp" => Ok(Self::Jmp),
+            "jeq" => Ok(Self::Jeq),
+            "jne" => Ok(Self::Jne),
+            "jgt" => Ok(Self::Jgt),
+            "jge" => Ok(Self::Jge),
+            "jlt" => Ok(Self::Jlt),
+            "jle" => Ok(Self::Jle),
+            "cmp" => Ok(Self::Cmp),
+            "inc" => Ok(Self::Inc),
+            "dec" => Ok(Self::Dec),
+            "shl" => Ok(Self::Shl),
+            "shr" => Ok(Self::Shr),
+            "add" => Ok(Self::Add),
+            "sub" => Ok(Self::Sub),
+            "and" => Ok(Self::And),
+            "or" => Ok(Self::Or),
+            "not" => Ok(Self::Not),
+            "xor" => Ok(Self::Xor),
+            "nand" => Ok(Self::Nand),
+            "nor" => Ok(Self::Nor),
+            "xnor" => Ok(Self::Xnor),
+            "int" => Ok(Self::Int),
+            "irt" => Ok(Self::Irt),
+            "hlt" => Ok(Self::Hlt),
+            "iadd" => Ok(Self::Iadd),
+            "isub" => Ok(Self::Isub),
+            "db" => Ok(Self::Db),
+            "dh" => Ok(Self::Dh),
+            "dw" => Ok(Self::Dw),
+            "resb" => Ok(Self::Resb),
+            "resh" => Ok(Self::Resh),
+            "resw" => Ok(Self::Resw),
+            "push" => Ok(Self::Push),
+            "pop" => Ok(Self::Pop),
+            "lwi" => Ok(Self::Lwi),
+            _ => Err(OpcodeFromStrError::InvalidRegister("unknown opcode")),
+        }
+    }
+}
+
 impl Opcode {
     pub const OPCODES: &[&str] = &[
         // Real instructions (0x00-0x26)
-        "nop", "mov", "movs", "ldb", "ldbs", "ldh", "ldhs", "ldw", "stb", "sth", "stw", "lli",
-        "lui", "jmp", "jeq", "jne", "jgt", "jge", "jlt", "jle", "cmp", "inc", "dec", "shl", "shr",
-        "add", "sub", "and", "or", "not", "xor", "nand", "nor", "xnor", "int", "irt", "hlt",
-        "iadd", "isub", // Pseudo-instructions
+        "nop", "mov", "movs", "ldb", "ldbs", "ldh", "ldhs", "ldw", "stb", "sth", "stw",
+        "lli", "lui", "jmp", "jeq", "jne", "jgt", "jge", "jlt", "jle", "cmp", "inc",
+        "dec", "shl", "shr", "add", "sub", "and", "or", "not", "xor", "nand", "nor",
+        "xnor", "int", "irt", "hlt", "iadd", "isub", // Pseudo-instructions
         "db", "dh", "dw", "resb", "resh", "resw", "push", "pop", "lwi",
     ];
 
-    pub fn from_str(s: &str) -> Option<Self> {
-        match s.to_lowercase().as_str() {
-            "nop" => Some(Self::Nop),
-            "mov" => Some(Self::Mov),
-            "movs" => Some(Self::Movs),
-            "ldb" => Some(Self::Ldb),
-            "ldbs" => Some(Self::Ldbs),
-            "ldh" => Some(Self::Ldh),
-            "ldhs" => Some(Self::Ldhs),
-            "ldw" => Some(Self::Ldw),
-            "stb" => Some(Self::Stb),
-            "sth" => Some(Self::Sth),
-            "stw" => Some(Self::Stw),
-            "lli" => Some(Self::Lli),
-            "lui" => Some(Self::Lui),
-            "jmp" => Some(Self::Jmp),
-            "jeq" => Some(Self::Jeq),
-            "jne" => Some(Self::Jne),
-            "jgt" => Some(Self::Jgt),
-            "jge" => Some(Self::Jge),
-            "jlt" => Some(Self::Jlt),
-            "jle" => Some(Self::Jle),
-            "cmp" => Some(Self::Cmp),
-            "inc" => Some(Self::Inc),
-            "dec" => Some(Self::Dec),
-            "shl" => Some(Self::Shl),
-            "shr" => Some(Self::Shr),
-            "add" => Some(Self::Add),
-            "sub" => Some(Self::Sub),
-            "and" => Some(Self::And),
-            "or" => Some(Self::Or),
-            "not" => Some(Self::Not),
-            "xor" => Some(Self::Xor),
-            "nand" => Some(Self::Nand),
-            "nor" => Some(Self::Nor),
-            "xnor" => Some(Self::Xnor),
-            "int" => Some(Self::Int),
-            "irt" => Some(Self::Irt),
-            "hlt" => Some(Self::Hlt),
-            "iadd" => Some(Self::Iadd),
-            "isub" => Some(Self::Isub),
-            "db" => Some(Self::Db),
-            "dh" => Some(Self::Dh),
-            "dw" => Some(Self::Dw),
-            "resb" => Some(Self::Resb),
-            "resh" => Some(Self::Resh),
-            "resw" => Some(Self::Resw),
-            "push" => Some(Self::Push),
-            "pop" => Some(Self::Pop),
-            "lwi" => Some(Self::Lwi),
-            _ => None,
-        }
-    }
-
     pub fn to_opcode_value(&self) -> Option<u8> {
         match self {
             Self::Nop => Some(0x00),