clippy

1 files changed, 31 insertions, 67 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)]);
     }
 }