clippy

2 files changed, 59 insertions, 80 deletions

diff --git a/src/forth/compiler.rs b/src/forth/compiler.rs
index 9120506..17f0113 100644
--- a/src/forth/compiler.rs
+++ b/src/forth/compiler.rs
@@ -19,7 +19,7 @@ impl std::fmt::Display for CompileError {
             Self::DefStackEmpty => write!(f, "def stack empty"),
             Self::MissingIf => write!(f, "missing if"),
             Self::MissingQuote => write!(f, "missing ending quote"),
-            Self::UnknownWord(word) => write!(f, "unknown word: {}", word),
+            Self::UnknownWord(word) => write!(f, "unknown word: {word}"),
         }
     }
 }
@@ -66,13 +66,11 @@ pub struct Compiler<'a> {
 
 impl<'a> Compiler<'a> {
     pub fn new(text: &'a str) -> Self {
-        let mut wl = vec![];
-        // main routine is always the first entry.
-        wl.push(ByteCode(vec![]));
         Self {
             text,
             enumerator: text.chars().enumerate(),
-            wordlist: WordList(wl),
+            // we always need something at index 0
+            wordlist: WordList(vec![ByteCode(vec![])]),
             annotations: vec![vec![]],
             wordalog: WordCatalog(HashMap::new()),
             defstack: vec![],
@@ -127,7 +125,7 @@ impl<'a> Compiler<'a> {
                     r#"s""# => {
                         let (s_end, _) =
                             self.enumerator
-                                .find(|(_i, c)| return *c == '"')
+                                .find(|(_i, c)| *c == '"')
                                 .ok_or(CompileError::MissingQuote)?;
                         self.bc_push(OpCode::Str(end+1, s_end), anno);
                     },
@@ -235,32 +233,28 @@ mod tests {
     fn literal_num() {
         let comp = compiler_for("1\n");
         let main = &comp.wordlist.0[0];
-        assert_eq!(main.len(), 1);
-        assert_eq!(main[0], OpCode::Num(1));
+        assert_eq!(main, vec![OpCode::Num(1)]);
     }
 
     #[test]
     fn literal_string() {
         let comp = compiler_for(r#"s" hello there""#);
         let main = &comp.wordlist.0[0];
-        assert_eq!(main.len(), 1);
-        assert_eq!(main[0], OpCode::Str(3, 14));
+        assert_eq!(main, vec![OpCode::Str(3, 14)]);
     }
 
     #[test]
     fn add_opcode() {
         let comp = compiler_for("+\n");
         let main = &comp.wordlist.0[0];
-        assert_eq!(main.len(), 1);
-        assert_eq!(main[0], OpCode::Add);
+        assert_eq!(main, vec![OpCode::Add]);
     }
 
     #[test]
     fn sub_opcode() {
         let comp = compiler_for("-\n");
         let main = &comp.wordlist.0[0];
-        assert_eq!(main.len(), 1);
-        assert_eq!(main[0], OpCode::Sub);
+        assert_eq!(main, vec![OpCode::Sub]);
     }
 
     #[test]
@@ -268,14 +262,10 @@ mod tests {
         let comp = compiler_for(": add2 2 + ; 3 add2\n");
         let main = &comp.wordlist.0[0];
         let add2_index = comp.wordalog.0.get("add2").expect("add2 has entry in wordlist");
+        assert_eq!(main, vec![OpCode::Num(3), OpCode::Call(*add2_index)]);
+
         let add2 = &comp.wordlist.0[*add2_index];
-        assert_eq!(main.len(), 2);
-        assert_eq!(main[0], OpCode::Num(3));
-        assert_eq!(main[1], OpCode::Call(*add2_index));
-        assert_eq!(add2.len(), 3);
-        assert_eq!(add2[0], OpCode::Num(2));
-        assert_eq!(add2[1], OpCode::Add);
-        assert_eq!(add2[2], OpCode::Ret);
+        assert_eq!(add2, vec![OpCode::Num(2), OpCode::Add, OpCode::Ret]);
     }
 
     #[test]
@@ -284,14 +274,9 @@ mod tests {
         eprintwordlist(&comp.wordlist);
         assert_eq!(comp.wordlist.0.len(), 2);
         let main = &comp.wordlist.0[0];
-        assert_eq!(main.len(), 1);
-        assert_eq!(main[0], OpCode::If(1, None));
+        assert_eq!(main, vec![OpCode::If(1, None)]);
         let tr = &comp.wordlist.0[1];
-        assert_eq!(tr.len(), 4);
-        assert_eq!(tr[0], OpCode::Num(1));
-        assert_eq!(tr[1], OpCode::Num(2));
-        assert_eq!(tr[2], OpCode::Add);
-        assert_eq!(tr[3], OpCode::Ret);
+        assert_eq!(tr, vec![OpCode::Num(1), OpCode::Num(2), OpCode::Add, OpCode::Ret]);
     }
 
     #[test]
@@ -302,18 +287,11 @@ mod tests {
         let main = &comp.wordlist.0[0];
         assert_eq!(main.len(), 1);
         assert_eq!(main[0], OpCode::If(1, Some(2)));
+        assert_eq!(main, vec![OpCode::If(1, Some(2))]);
         let tr = &comp.wordlist.0[1];
-        assert_eq!(tr.len(), 4);
-        assert_eq!(tr[0], OpCode::Num(1));
-        assert_eq!(tr[1], OpCode::Num(2));
-        assert_eq!(tr[2], OpCode::Add);
-        assert_eq!(tr[3], OpCode::Ret);
+        assert_eq!(tr, vec![OpCode::Num(1), OpCode::Num(2), OpCode::Add, OpCode::Ret]);
         let fl = &comp.wordlist.0[2];
-        assert_eq!(fl.len(), 4);
-        assert_eq!(fl[0], OpCode::Num(1));
-        assert_eq!(fl[1], OpCode::Num(2));
-        assert_eq!(fl[2], OpCode::Sub);
-        assert_eq!(fl[3], OpCode::Ret);
+        assert_eq!(fl, vec![OpCode::Num(1), OpCode::Num(2), OpCode::Sub, OpCode::Ret]);
     }
 
     #[test]
@@ -321,6 +299,12 @@ mod tests {
         let comp = compiler_for(": first + ; : second 3 first ; 1 second\n");
         assert_eq!(comp.wordlist.0.len(), 3, "wordlist length");
         eprintwordlist(&comp.wordlist);
+        let main = &comp.wordlist.0[0];
+        assert_eq!(main, vec![OpCode::Num(1), OpCode::Call(2)]);
+        let first = &comp.wordlist.0[1];
+        assert_eq!(first, vec![OpCode::Add, OpCode::Ret]);
+        let second = &comp.wordlist.0[2];
+        assert_eq!(second, vec![OpCode::Num(3), OpCode::TCall(1)]);
     }
 
     #[test]
@@ -329,18 +313,11 @@ mod tests {
         eprintwordlist(&comp.wordlist);
         assert_eq!(comp.wordlist.0.len(), 3);
         let main = &comp.wordlist.0[0];
-        assert_eq!(main.len(), 1);
-        assert_eq!(main[0], OpCode::Call(1));
+        assert_eq!(main, vec![OpCode::Call(1)]);
         let t = &comp.wordlist.0[1];
-        assert_eq!(t.len(), 2);
-        assert_eq!(t[0], OpCode::TIf(2, None));
-        assert_eq!(t[1], OpCode::Ret);
+        assert_eq!(t, vec![OpCode::TIf(2, None), OpCode::Ret]);
         let tr = &comp.wordlist.0[2];
-        assert_eq!(tr.len(), 4);
-        assert_eq!(tr[0], OpCode::Num(1));
-        assert_eq!(tr[1], OpCode::Num(2));
-        assert_eq!(tr[2], OpCode::Add);
-        assert_eq!(tr[3], OpCode::Ret);
+        assert_eq!(tr, vec![OpCode::Num(1), OpCode::Num(2), OpCode::Add, OpCode::Ret]);
     }
 
     #[test]
@@ -349,24 +326,13 @@ mod tests {
         eprintwordlist(&comp.wordlist);
         assert_eq!(comp.wordlist.0.len(), 4, "wordlist length");
         let main = &comp.wordlist.0[0];
-        assert_eq!(main.len(), 1);
-        assert_eq!(main[0], OpCode::Call(1));
+        assert_eq!(main, vec![OpCode::Call(1)]);
         let t = &comp.wordlist.0[1];
-        assert_eq!(t.len(), 2);
-        assert_eq!(t[0], OpCode::TIf(2, Some(3)));
-        assert_eq!(t[1], OpCode::Ret);
+        assert_eq!(t, vec![OpCode::TIf(2, Some(3)), OpCode::Ret]);
         let tr = &comp.wordlist.0[2];
-        assert_eq!(tr.len(), 4);
-        assert_eq!(tr[0], OpCode::Num(1));
-        assert_eq!(tr[1], OpCode::Num(2));
-        assert_eq!(tr[2], OpCode::Add);
-        assert_eq!(tr[3], OpCode::Ret);
+        assert_eq!(tr, vec![OpCode::Num(1), OpCode::Num(2), OpCode::Add, OpCode::Ret]);
         let fl = &comp.wordlist.0[3];
-        assert_eq!(fl.len(), 4);
-        assert_eq!(fl[0], OpCode::Num(1));
-        assert_eq!(fl[1], OpCode::Num(2));
-        assert_eq!(fl[2], OpCode::Sub);
-        assert_eq!(fl[3], OpCode::Ret);
+        assert_eq!(fl, vec![OpCode::Num(1), OpCode::Num(2), OpCode::Sub, OpCode::Ret]);
     }
 
     #[test]
@@ -375,10 +341,8 @@ mod tests {
         eprintwordlist(&comp.wordlist);
         assert_eq!(comp.wordlist.0.len(), 2);
         let main = &comp.wordlist.0[0];
-        assert_eq!(main.len(), 1);
-        assert_eq!(main[0], OpCode::Call(1));
+        assert_eq!(main, vec![OpCode::Call(1)]);
         let foo = &comp.wordlist.0[1];
-        assert_eq!(foo.len(), 1);
-        assert_eq!(foo[0], OpCode::TCall(1));
+        assert_eq!(foo, vec![OpCode::TCall(1)]);
     }
 }
diff --git a/src/forth/vm.rs b/src/forth/vm.rs
index b4ce674..fe034a6 100644
--- a/src/forth/vm.rs
+++ b/src/forth/vm.rs
@@ -2,7 +2,7 @@ use log::debug;
 
 use std::ops::Index;
 
-#[derive(Clone, Debug, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub enum OpCode {
     Num(i32),
     Str(usize, usize),
@@ -27,7 +27,7 @@ pub enum OpCode {
     Ret,
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct ByteCode(pub Vec<OpCode>);
 impl std::ops::Deref for ByteCode {
     type Target = Vec<OpCode>;
@@ -40,6 +40,19 @@ impl ByteCode {
     pub fn len(&self) -> usize {
         self.0.len()
     }
+
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+}
+
+// really just to make unit testing look nicer. should probably move
+// it there.
+impl PartialEq<Vec<OpCode>> for &ByteCode {
+    fn eq(&self, other: &Vec<OpCode>) -> bool {
+        self.0.len() == other.len() &&
+            std::iter::zip(&self.0, other).all(|(a, b)| a == b)
+    }
 }
 
 impl Index<usize> for ByteCode {
@@ -65,6 +78,12 @@ impl InstructionPointer {
     }
 }
 
+impl Default for InstructionPointer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 #[derive(Debug)]
 pub struct DataStack(pub Vec<i32>);
 
@@ -119,7 +138,7 @@ impl VM {
         let bc = &self.wordlist.0[self.ip.word];
         match bc[self.ip.offset] {
             OpCode::Num(n) => self.stack.0.push(n),
-            OpCode::Str(start, end) => debug!("got str: {} to {}", start, end),
+            OpCode::Str(start, end) => debug!("got str: {start} to {end}"),
             OpCode::Add => {
                 let n1 = self.stack.0.pop().ok_or(RuntimeError::StackUnderflow)?;
                 let n2 = self.stack.0.pop().ok_or(RuntimeError::StackUnderflow)?;
@@ -511,21 +530,17 @@ mod tests {
         let mut vm = VM::new(wordlist);
 
         vm.tick()?;
-        assert_eq!(vm.stack.0.len(), 0, "call(1) stack len");
+        assert_eq!(vm.stack.0, vec![], "call(1) stack");
         vm.tick()?;
-        assert_eq!(vm.stack.0.len(), 1, "push 0 stack len");
-        assert_eq!(vm.stack.0[0], 0, "push 0 val");
+        assert_eq!(vm.stack.0, vec![0], "push 0 stack");
         vm.tick()?;
-        assert_eq!(vm.stack.0.len(), 0, "tif stack len");
+        assert_eq!(vm.stack.0, vec![], "tif stack");
         vm.tick()?;
-        assert_eq!(vm.stack.0.len(), 1, "push 2 stack len");
-        assert_eq!(vm.stack.0[0], 2, "push 2 val");
+        assert_eq!(vm.stack.0, vec![2], "push 2 stack");
         vm.tick()?;
-        assert_eq!(vm.stack.0.len(), 1, "ret stack len");
-        assert_eq!(vm.stack.0[0], 2, "ret val");
+        assert_eq!(vm.stack.0, vec![2], "ret stack");
         vm.tick()?;
-        assert_eq!(vm.stack.0.len(), 2, "push -2 stack len");
-        assert_eq!(vm.stack.0[1], -2, "push -2 val");
+        assert_eq!(vm.stack.0, vec![2, -2], "push -2 stack");
 
         Ok(())
     }