assembler: purge unwrap and use more AssembleErrors

assembler/src/brainf.rs

@@ -10,25 +10,28 @@ use crate::{
     node,
 };
 
+#[must_use]
 pub fn build(src: &Path) -> Vec<Instruction> {
-    let src = fs::read_to_string(src).unwrap();
-    let mut nodes = parse(src);
+    let src = fs::read_to_string(src).expect("Failed to read source file");
+    let mut nodes = parse(&src);
 
     // we need to expand pseudoinstructions etc now
-    nodes = expand_pseudo_ops(nodes, 0).unwrap();
+    nodes = expand_pseudo_ops(nodes, 0).expect("Failed to expand pseudo-operations");
 
-    create_sections(&mut nodes).unwrap();
+    create_sections(&mut nodes).expect("Failed to create sections");
 
-    for n in nodes.iter() {
-        println!("{}", n);
+    for n in &nodes {
+        println!("{n}");
     }
 
-    resolve_symbols(&mut nodes).unwrap();
+    resolve_symbols(&mut nodes).expect("Failed to resolve symbols");
 
-    codegen(nodes).unwrap()
+    codegen(nodes).expect("Failed to generate code from nodes")
 }
 
-pub fn parse(src: String) -> Vec<Node> {
+#[must_use]
+#[expect(clippy::too_many_lines)]
+pub fn parse(src: &str) -> Vec<Node> {
     let stack = Token::Immediate(0x10000);
     let acc = Token::Register(Register::Acc);
     let rga = Token::Register(Register::Rga);
@@ -45,7 +48,7 @@ pub fn parse(src: String) -> Vec<Node> {
 
     let tokens = lex(src);
 
-    let _id = 0;
+    // let _id = 0;
     let mut idstack = Vec::<u32>::new();
 
     nodes.extend(vec![
@@ -115,8 +118,8 @@ pub fn parse(src: String) -> Vec<Node> {
             }
             BfToken::Forward => {
                 // Start of loop [
-                let loop_start = format!("loop_start_{}", id);
-                let loop_end = format!("loop_end_{}", id);
+                let loop_start = format!("loop_start_{id}");
+                let loop_end = format!("loop_end_{id}");
 
                 // Push the current position for the matching ]
                 idstack.push(id as u32);
@@ -149,8 +152,8 @@ pub fn parse(src: String) -> Vec<Node> {
             BfToken::Back => {
                 // End of loop ]
                 if let Some(start_id) = idstack.pop() {
-                    let loop_start = format!("loop_start_{}", start_id);
-                    let loop_end = format!("loop_end_{}", start_id);
+                    let loop_start = format!("loop_start_{start_id}");
+                    let loop_end = format!("loop_end_{start_id}");
 
                     // Jump back to the start of the loop
                     nodes.extend(vec![
@@ -177,7 +180,7 @@ pub fn parse(src: String) -> Vec<Node> {
                     ]);
                 } else {
                     // Unmatched closing bracket - could add error handling here
-                    eprintln!("Warning: Unmatched ']' at position {}", id);
+                    eprintln!("Warning: Unmatched ']' at position {id}");
                 }
             }
         }
@@ -215,47 +218,29 @@ fn insert_lib(nodes: &mut Vec<Node>) {
         ),
         // print function
         // initialisation
-        node!(Some(print_start.clone()), Opcode::Push, bpr.clone()),
-        node!(None, Opcode::Mov, spr.clone(), bpr.clone()),
+        node!(Some(print_start), Opcode::Push, bpr),
+        node!(None, Opcode::Mov, spr, bpr),
         // function body
-        node!(
-            None,
-            Opcode::Ldw,
-            bpr.clone(),
-            rg0.clone(),
-            Token::Immediate(8)
-        ),
+        node!(None, Opcode::Ldw, bpr, rg0, Token::Immediate(8)),
         node!(
             None,
             Opcode::Ldw,
             Token::Symbol(current.clone()), // Load address of current
-            rg1.clone(),
+            rg1,
             Token::Immediate(0)
         ),
-        node!(
-            None,
-            Opcode::Stb,
-            rg0.clone(),
-            rg1.clone(),
-            Token::Immediate(0)
-        ),
-        node!(
-            None,
-            Opcode::AddI,
-            rg1.clone(),
-            Token::Immediate(1),
-            rg1.clone()
-        ),
+        node!(None, Opcode::Stb, rg0, rg1, Token::Immediate(0)),
+        node!(None, Opcode::AddI, rg1, Token::Immediate(1), rg1),
         // function return according to spec.
         node!(
             None,
             Opcode::Stw,
-            rg1.clone(),
-            Token::Symbol(current.clone()), // Store back to current
+            rg1,
+            Token::Symbol(current), // Store back to current
             Token::Immediate(0)
         ),
-        node!(None, Opcode::Mov, bpr.clone(), spr.clone()),
-        node!(None, Opcode::Pop, bpr.clone()),
+        node!(None, Opcode::Mov, bpr, spr),
+        node!(None, Opcode::Pop, bpr),
         node!(None, Opcode::Return),
     ]);
 }
@@ -271,7 +256,7 @@ enum BfToken {
     Back,
 }
 
-fn lex(src: String) -> Vec<BfToken> {
+fn lex(src: &str) -> Vec<BfToken> {
     src.chars()
         .filter_map(|c| match c {
             '+' => Some(BfToken::Inc),
@@ -289,7 +274,7 @@ fn lex(src: String) -> Vec<BfToken> {
 
 fn _create_symbol(id: u32) -> Symbol {
     Symbol {
-        name: format!("label_{}", id),
+        name: format!("label_{id}"),
         module: Module::Resolved(0),
     }
 }