Fixed issues reported by clippy

Author: LimeEng

src/interpreter.rs

@@ -1,5 +1,4 @@
 use std::io;
-use std::io::Error as IoError;
 
 #[derive(Debug, Copy, Clone, PartialEq)]
 pub enum Instruction {
@@ -16,14 +15,14 @@ pub enum Instruction {
 
 #[derive(Debug)]
 pub enum Error {
-    Io(IoError),
+    Io(io::Error),
     PointerOverflow,
     PointerUnderflow,
 }
 
-impl From<IoError> for Error {
-    fn from(io_error: IoError) -> Self {
-        Error::Io(io_error)
+impl From<io::Error> for Error {
+    fn from(error: io::Error) -> Self {
+        Error::Io(error)
     }
 }
 
@@ -33,6 +32,7 @@ pub struct Interpreter {
 }
 
 impl Interpreter {
+    #[must_use]
     pub fn new(memory_size: usize) -> Self {
         Interpreter {
             memory: vec![0; memory_size],
@@ -45,12 +45,12 @@ impl Interpreter {
     }
 
     fn write_current_cell(&mut self, value: u8) {
-        self.memory[self.pointer] = value
+        self.memory[self.pointer] = value;
     }
 
     pub fn run(
         &mut self,
-        program: Vec<Instruction>,
+        program: &[Instruction],
         input: &mut dyn io::Read,
         output: &mut dyn io::Write,
     ) -> Result<(), Error> {

src/main.rs

@@ -1,20 +1,9 @@
-use std::env;
-use std::fs;
-use std::io;
-use std::time::Instant;
-
-use brainrust::interpreter;
-use brainrust::interpreter::Interpreter;
-use brainrust::lexer;
-use brainrust::optimizer;
-use brainrust::parser;
-use clap::Arg;
-use clap::ArgAction;
-use clap::ArgMatches;
-use clap::Command;
-use clap::crate_name;
-use clap::crate_version;
-use clap::value_parser;
+use brainrust::{
+    interpreter::{self, Interpreter},
+    lexer, optimizer, parser,
+};
+use clap::{Arg, ArgAction, ArgMatches, Command, crate_name, crate_version, value_parser};
+use std::{env, fs, io, time::Instant};
 
 const DEFAULT_MEMORY_SIZE: usize = 32768;
 const CLI_SUB_CMD_RUN: &str = "run";
@@ -66,16 +55,15 @@ fn main() -> Result<(), CliError> {
                 )
                 .arg(
                     Arg::new(CLI_SUB_CMD_RUN_MEMORY)
-                        .help(&format!(
-                            "Sets the number of memory cells, defaults to {:?}",
-                            DEFAULT_MEMORY_SIZE
+                        .help(format!(
+                            "Sets the number of memory cells, defaults to {DEFAULT_MEMORY_SIZE:?}"
                         ))
                         .long(CLI_SUB_CMD_RUN_MEMORY)
                         .value_parser(value_parser!(u32)),
                 )
                 .arg(
                     Arg::new(CLI_SUB_CMD_RUN_TIME)
-                        .help(&"Prints time of various metrics".to_string())
+                        .help("Prints time of various metrics")
                         .long(CLI_SUB_CMD_RUN_TIME)
                         .value_parser(CLI_SUB_CMD_RUN_TIME_OPTIONS)
                         .action(ArgAction::Append),
@@ -107,14 +95,14 @@ fn handle_run(matches: &ArgMatches) -> Result<(), CliError> {
             let total_start = Instant::now();
             let contents = fs::read_to_string(input)?;
             let tokens = lexer::lex(&contents);
-            let parsed = parser::parse(tokens)?;
+            let parsed = parser::parse(&tokens)?;
             let optimized = optimizer::optimize(parsed);
             let parse_elapsed = total_start.elapsed();
 
             let mut interpreter = Interpreter::new(memory);
 
             let exec_start = Instant::now();
-            interpreter.run(optimized, &mut io::stdin(), &mut io::stdout())?;
+            interpreter.run(&optimized, &mut io::stdin(), &mut io::stdout())?;
             let exec_elapsed = exec_start.elapsed();
             let total_elapsed = total_start.elapsed();
 

src/optimizer.rs

@@ -1,16 +1,18 @@
-use std::ops::RangeInclusive;
-
+use crate::{
+    interpreter::Instruction::{
+        self, Add, Clear, JumpIfNotZero, JumpIfZero, MoveLeft, MoveRight, Sub,
+    },
+    parser,
+};
 use itertools::Itertools;
+use std::ops::RangeInclusive;
 
-use crate::interpreter::Instruction;
-use crate::interpreter::Instruction::*;
-use crate::parser;
-
+#[must_use]
 pub fn optimize(instructions: Vec<Instruction>) -> Vec<Instruction> {
     let iter = instructions.into_iter();
     let iter = combine_instructions(iter);
     let iter = optimize_clear_loop(iter);
-    let mut optimized = iter.collect();
+    let mut optimized: Vec<_> = iter.collect();
     parser::link_loops(&mut optimized).unwrap()
 }
 

src/parser.rs

@@ -1,7 +1,6 @@
-use crate::interpreter::Instruction;
-use crate::lexer::Command;
+use crate::{interpreter::Instruction, lexer::Command};
 
-pub fn parse(commands: Vec<Command>) -> Result<Vec<Instruction>, Error> {
+pub fn parse(commands: &[Command]) -> Result<Vec<Instruction>, Error> {
     let mut instructions: Vec<Instruction> = commands
         .iter()
         .map(|cmd| match cmd {
@@ -19,7 +18,7 @@ pub fn parse(commands: Vec<Command>) -> Result<Vec<Instruction>, Error> {
     link_loops(&mut instructions)
 }
 
-pub fn link_loops(program: &mut Vec<Instruction>) -> Result<Vec<Instruction>, Error> {
+pub fn link_loops(program: &mut [Instruction]) -> Result<Vec<Instruction>, Error> {
     let mut jump_stack = Vec::new();
 
     for i in 0..program.len() {
@@ -78,7 +77,7 @@ mod tests {
             Instruction::Print,
             Instruction::Read,
         ];
-        assert_eq!(parse(input).unwrap(), expected);
+        assert_eq!(parse(&input).unwrap(), expected);
     }
 
     #[test]
@@ -103,7 +102,7 @@ mod tests {
             Instruction::Sub(1),
             Instruction::Read,
         ];
-        assert_eq!(parse(input).unwrap(), expected);
+        assert_eq!(parse(&input).unwrap(), expected);
     }
 
     #[test]
@@ -130,18 +129,18 @@ mod tests {
             Instruction::JumpIfNotZero(1),
             Instruction::JumpIfNotZero(0),
         ];
-        assert_eq!(parse(input).unwrap(), expected);
+        assert_eq!(parse(&input).unwrap(), expected);
     }
 
     #[test]
     fn test_missing_closing_bracket() {
         let input = vec![Command::JumpIfZero, Command::Add];
-        assert!(parse(input).is_err());
+        assert!(parse(&input).is_err());
     }
 
     #[test]
     fn test_missing_opening_bracket() {
         let input = vec![Command::Add, Command::JumpIfNotZero];
-        assert!(parse(input).is_err());
+        assert!(parse(&input).is_err());
     }
 }

tests/integration_test.rs

@@ -1,11 +1,8 @@
-use brainrust::interpreter;
-use brainrust::interpreter::Interpreter;
-use brainrust::lexer;
-use brainrust::optimizer;
-use brainrust::parser;
-
-use std::fs;
-use std::str;
+use brainrust::{
+    interpreter::{self, Interpreter},
+    lexer, optimizer, parser,
+};
+use std::{fs, io, str};
 
 const PROGRAM_PREFIX: &str = "tests/programs/";
 const PROGRAM_EXTENSION: &str = ".b";
@@ -19,18 +16,16 @@ macro_rules! test_programs {
     $(
         #[test]
         fn $test_name() -> Result<(), TestError> {
-            let program = format!("{}{}{}", PROGRAM_PREFIX, $program_name, PROGRAM_EXTENSION);
-            let input = format!("{}{}{}", PROGRAM_PREFIX, $program_name, INPUT_EXTENSION);
-            let output = format!("{}{}{}", PROGRAM_PREFIX, $program_name, OUTPUT_EXTENSION);
+            let program_name = $program_name;
+            let program = format!("{PROGRAM_PREFIX}{program_name}{PROGRAM_EXTENSION}");
+            let input = format!("{PROGRAM_PREFIX}{program_name}{INPUT_EXTENSION}");
+            let output = format!("{PROGRAM_PREFIX}{program_name}{OUTPUT_EXTENSION}");
 
-            let program = fs::read(program)?;
-            let input = fs::read(input)?;
+            let program = fs::read_to_string(program)?;
+            let input = fs::read_to_string(input)?;
             let output = fs::read(output)?;
 
-            let program = str::from_utf8(&program)?;
-            let input = str::from_utf8(&input)?;
-
-            let result = run_program(program, input)?;
+            let result = run_program(&program, &input)?;
 
             assert_eq!(result, output);
             Ok(())
@@ -44,45 +39,45 @@ test_programs! {
 }
 
 fn run_program(file: &str, input: &str) -> Result<Vec<u8>, TestError> {
-    let tokens = lexer::lex(&file);
-    let parsed = parser::parse(tokens)?;
+    let tokens = lexer::lex(file);
+    let parsed = parser::parse(&tokens)?;
     let optimized = optimizer::optimize(parsed);
     let mut interpreter = Interpreter::new(MEMORY_SIZE);
 
     let mut output: Vec<u8> = vec![];
 
-    interpreter.run(optimized, &mut input.as_bytes(), &mut output)?;
+    interpreter.run(&optimized, &mut input.as_bytes(), &mut output)?;
     Ok(output)
 }
 
 #[derive(Debug)]
 enum TestError {
-    Io(std::io::Error),
-    Parsing(parser::Error),
-    Interpreter(interpreter::Error),
-    ConversationError(std::str::Utf8Error),
+    Io,
+    Parsing,
+    Interpreter,
+    ConversationError,
 }
 
-impl From<std::io::Error> for TestError {
-    fn from(io_error: std::io::Error) -> Self {
-        TestError::Io(io_error)
+impl From<io::Error> for TestError {
+    fn from(_error: io::Error) -> Self {
+        TestError::Io
     }
 }
 
 impl From<parser::Error> for TestError {
-    fn from(parser_error: parser::Error) -> Self {
-        TestError::Parsing(parser_error)
+    fn from(_error: parser::Error) -> Self {
+        TestError::Parsing
     }
 }
 
 impl From<interpreter::Error> for TestError {
-    fn from(interpreter_error: interpreter::Error) -> Self {
-        TestError::Interpreter(interpreter_error)
+    fn from(_error: interpreter::Error) -> Self {
+        TestError::Interpreter
     }
 }
 
-impl From<std::str::Utf8Error> for TestError {
-    fn from(utf8_error: std::str::Utf8Error) -> Self {
-        TestError::ConversationError(utf8_error)
+impl From<str::Utf8Error> for TestError {
+    fn from(_error: str::Utf8Error) -> Self {
+        TestError::ConversationError
     }
 }