refactor: updating to Rust edtion 2024

Cargo.toml

@@ -3,7 +3,7 @@ name = "monkey_interpreter"
 version = "0.17.0"
 description = "Implementation of an interpreter for the Monkey language written in Rust, currently under active development."
 authors = ["C <DeveloperC@protonmail.com>"]
-edition = "2021"
+edition = "2024"
 license = "AGPL-3.0"
 repository = "https://github.com/DeveloperC286/monkey_interpreter"
 readme = "README.md"

src/evaluator/expression/boolean/mod.rs

@@ -1,5 +1,5 @@
-use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
+use crate::evaluator::model::object::Object;
 
 impl Evaluator {
     pub(super) fn evaluate_boolean(&self, literal: bool) -> anyhow::Result<Object> {

src/evaluator/expression/call/mod.rs

@@ -1,5 +1,5 @@
-use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
+use crate::evaluator::model::object::Object;
 use crate::syntax_analysis::model::syntax_tree_node::Expression;
 
 impl Evaluator {

src/evaluator/expression/function/mod.rs

@@ -1,5 +1,5 @@
-use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
+use crate::evaluator::model::object::Object;
 use crate::syntax_analysis::model::syntax_tree_node::Block;
 
 impl Evaluator {

src/evaluator/expression/if_expression/mod.rs

@@ -1,5 +1,5 @@
-use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
+use crate::evaluator::model::object::Object;
 use crate::syntax_analysis::model::syntax_tree_node::{Block, Expression};
 
 impl Evaluator {

src/evaluator/expression/infix/mod.rs

@@ -1,5 +1,5 @@
-use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
+use crate::evaluator::model::object::Object;
 use crate::syntax_analysis::model::syntax_tree_node::{Expression, InfixOperator};
 
 impl Evaluator {

src/evaluator/expression/integer/mod.rs

@@ -1,5 +1,5 @@
-use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
+use crate::evaluator::model::object::Object;
 
 impl Evaluator {
     pub(super) fn evaluate_integer(&self, literal: i64) -> anyhow::Result<Object> {

src/evaluator/expression/mod.rs

@@ -1,5 +1,5 @@
-use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
+use crate::evaluator::model::object::Object;
 use crate::syntax_analysis::model::syntax_tree_node::*;
 
 mod boolean;

src/evaluator/expression/prefix/mod.rs

@@ -1,5 +1,5 @@
-use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
+use crate::evaluator::model::object::Object;
 use crate::syntax_analysis::model::syntax_tree_node::Expression;
 
 impl Evaluator {

src/evaluator/expression/string/mod.rs

@@ -1,5 +1,5 @@
-use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
+use crate::evaluator::model::object::Object;
 
 impl Evaluator {
     pub(super) fn evaluate_string(&self, string: String) -> anyhow::Result<Object> {

src/evaluator/statement/let_statement/mod.rs

@@ -1,5 +1,5 @@
-use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
+use crate::evaluator::model::object::Object;
 use crate::syntax_analysis::model::syntax_tree_node::*;
 
 impl Evaluator {

src/evaluator/statement/mod.rs

@@ -1,5 +1,5 @@
-use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
+use crate::evaluator::model::object::Object;
 use crate::syntax_analysis::model::syntax_tree_node::*;
 
 mod let_statement;

src/evaluator/statement/return_statement/mod.rs

@@ -1,5 +1,5 @@
-use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
+use crate::evaluator::model::object::Object;
 use crate::syntax_analysis::model::syntax_tree_node::*;
 
 impl Evaluator {

src/main.rs

@@ -1,4 +1,4 @@
-use std::io::{stdin, stdout, Write};
+use std::io::{Write, stdin, stdout};
 
 use anyhow::{Context, Result};
 use clap::Parser;

src/syntax_analysis/expression/function_expression/mod.rs

@@ -1,9 +1,9 @@
 use log::debug;
 
 use crate::lexical_analysis::model::token::Token;
+use crate::syntax_analysis::SyntaxAnalysis;
 use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
 use crate::syntax_analysis::model::syntax_tree_node::Expression;
-use crate::syntax_analysis::SyntaxAnalysis;
 
 impl SyntaxAnalysis<'_> {
     pub(crate) fn parse_function_expression(&mut self) -> anyhow::Result<Expression> {
@@ -36,34 +36,34 @@ impl SyntaxAnalysis<'_> {
         );
         let mut parameters = vec![];
 
-        if let Some(token) = self.tokens.peek() {
-            if **token != Token::ClosingRoundBracket {
-                loop {
-                    let expression = self.get_expression(ExpressionPrecedence::Lowest)?;
-                    match expression {
-                        Expression::Identifier { identifier } => {
-                            parameters.push(identifier);
-                        }
-                        _ => {
-                            anyhow::bail!(
-                                "Only allowed identifiers in function expression's parameters."
-                            );
-                        }
+        if let Some(token) = self.tokens.peek()
+            && **token != Token::ClosingRoundBracket
+        {
+            loop {
+                let expression = self.get_expression(ExpressionPrecedence::Lowest)?;
+                match expression {
+                    Expression::Identifier { identifier } => {
+                        parameters.push(identifier);
                     }
+                    _ => {
+                        anyhow::bail!(
+                            "Only allowed identifiers in function expression's parameters."
+                        );
+                    }
+                }
 
-                    match self.tokens.peek() {
-                        Some(token) => match token {
-                            Token::ClosingRoundBracket => break,
-                            Token::Comma => {
-                                self.tokens.next();
-                            }
-                            _ => {
-                                anyhow::bail!("Parameters must be comma seperated identifiers.");
-                            }
-                        },
-                        None => {
-                            anyhow::bail!("FunctionParametersEndedAbruptly.");
+                match self.tokens.peek() {
+                    Some(token) => match token {
+                        Token::ClosingRoundBracket => break,
+                        Token::Comma => {
+                            self.tokens.next();
+                        }
+                        _ => {
+                            anyhow::bail!("Parameters must be comma seperated identifiers.");
                         }
+                    },
+                    None => {
+                        anyhow::bail!("FunctionParametersEndedAbruptly.");
                     }
                 }
             }

src/syntax_analysis/expression/grouped_expression/mod.rs

@@ -1,9 +1,9 @@
 use log::debug;
 
 use crate::lexical_analysis::model::token::Token;
+use crate::syntax_analysis::SyntaxAnalysis;
 use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
 use crate::syntax_analysis::model::syntax_tree_node::Expression;
-use crate::syntax_analysis::SyntaxAnalysis;
 
 impl SyntaxAnalysis<'_> {
     pub(crate) fn parse_grouped_expression(&mut self) -> anyhow::Result<Expression> {

src/syntax_analysis/expression/if_expression/mod.rs

@@ -1,9 +1,9 @@
 use log::debug;
 
 use crate::lexical_analysis::model::token::Token;
+use crate::syntax_analysis::SyntaxAnalysis;
 use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
 use crate::syntax_analysis::model::syntax_tree_node::Expression;
-use crate::syntax_analysis::SyntaxAnalysis;
 
 impl SyntaxAnalysis<'_> {
     pub(crate) fn parse_if_expression(&mut self) -> anyhow::Result<Expression> {
@@ -25,12 +25,12 @@ impl SyntaxAnalysis<'_> {
         let consequence = self.parse_block()?;
         let mut alternative = None;
 
-        if let Some(token) = self.tokens.peek() {
-            if **token == Token::Else {
-                // Consume else.
-                self.tokens.next();
-                alternative = Some(self.parse_block()?);
-            }
+        if let Some(token) = self.tokens.peek()
+            && **token == Token::Else
+        {
+            // Consume else.
+            self.tokens.next();
+            alternative = Some(self.parse_block()?);
         }
 
         Ok(Expression::If {

src/syntax_analysis/expression/mod.rs

@@ -1,9 +1,9 @@
 use log::{debug, trace};
 
 use crate::lexical_analysis::model::token::Token;
+use crate::syntax_analysis::SyntaxAnalysis;
 use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
 use crate::syntax_analysis::model::syntax_tree_node::{Expression, SyntaxTreeNode};
-use crate::syntax_analysis::SyntaxAnalysis;
 
 mod function_expression;
 mod grouped_expression;

src/syntax_analysis/expression/pratt_parsing/call_expression/mod.rs

@@ -1,9 +1,9 @@
 use log::debug;
 
 use crate::lexical_analysis::model::token::Token;
+use crate::syntax_analysis::SyntaxAnalysis;
 use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
 use crate::syntax_analysis::model::syntax_tree_node::Expression;
-use crate::syntax_analysis::SyntaxAnalysis;
 
 impl SyntaxAnalysis<'_> {
     pub(crate) fn parse_call_expression(
@@ -45,25 +45,25 @@ impl SyntaxAnalysis<'_> {
         );
         let mut arguments = vec![];
 
-        if let Some(token) = self.tokens.peek() {
-            if **token != Token::ClosingRoundBracket {
-                loop {
-                    let expression = self.get_expression(ExpressionPrecedence::Lowest)?;
-                    arguments.push(expression);
+        if let Some(token) = self.tokens.peek()
+            && **token != Token::ClosingRoundBracket
+        {
+            loop {
+                let expression = self.get_expression(ExpressionPrecedence::Lowest)?;
+                arguments.push(expression);
 
-                    match self.tokens.peek() {
-                        Some(token) => match token {
-                            Token::ClosingRoundBracket => break,
-                            Token::Comma => {
-                                self.tokens.next();
-                            }
-                            _ => {
-                                anyhow::bail!("Parameters must be comma seperated identifiers.");
-                            }
-                        },
-                        None => {
-                            anyhow::bail!("CallExpressionParametersEndedAbruptly.");
+                match self.tokens.peek() {
+                    Some(token) => match token {
+                        Token::ClosingRoundBracket => break,
+                        Token::Comma => {
+                            self.tokens.next();
+                        }
+                        _ => {
+                            anyhow::bail!("Parameters must be comma seperated identifiers.");
                         }
+                    },
+                    None => {
+                        anyhow::bail!("CallExpressionParametersEndedAbruptly.");
                     }
                 }
             }

src/syntax_analysis/expression/pratt_parsing/infix_expression/mod.rs

@@ -1,9 +1,9 @@
 use log::debug;
 
 use crate::lexical_analysis::model::token::Token;
+use crate::syntax_analysis::SyntaxAnalysis;
 use crate::syntax_analysis::model::expression_precedence::get_infix_operator_precedence;
 use crate::syntax_analysis::model::syntax_tree_node::{Expression, InfixOperator};
-use crate::syntax_analysis::SyntaxAnalysis;
 
 impl SyntaxAnalysis<'_> {
     pub(crate) fn parse_infix_expression(

src/syntax_analysis/expression/pratt_parsing/mod.rs

@@ -1,9 +1,9 @@
 use std::cmp::Ordering;
 
 use crate::lexical_analysis::model::token::Token;
+use crate::syntax_analysis::SyntaxAnalysis;
 use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
 use crate::syntax_analysis::model::syntax_tree_node::Expression;
-use crate::syntax_analysis::SyntaxAnalysis;
 
 mod call_expression;
 mod infix_expression;

src/syntax_analysis/expression/utilities/mod.rs

@@ -1,8 +1,8 @@
 use log::debug;
 
 use crate::lexical_analysis::model::token::Token;
-use crate::syntax_analysis::model::syntax_tree_node::Block;
 use crate::syntax_analysis::SyntaxAnalysis;
+use crate::syntax_analysis::model::syntax_tree_node::Block;
 
 impl SyntaxAnalysis<'_> {
     pub(crate) fn parse_block(&mut self) -> anyhow::Result<Block> {

src/syntax_analysis/statement/mod.rs

@@ -1,9 +1,9 @@
 use log::{debug, trace};
 
 use crate::lexical_analysis::model::token::Token;
+use crate::syntax_analysis::SyntaxAnalysis;
 use crate::syntax_analysis::model::expression_precedence::ExpressionPrecedence;
 use crate::syntax_analysis::model::syntax_tree_node::{Statement, SyntaxTreeNode};
-use crate::syntax_analysis::SyntaxAnalysis;
 
 impl SyntaxAnalysis<'_> {
     pub(crate) fn parse_return_statement(&mut self) -> anyhow::Result<SyntaxTreeNode> {

src/tests/macros.rs

@@ -43,12 +43,14 @@ macro_rules! assert_evaluation {
 
         // When
         let mut evaluator = crate::evaluator::Evaluator::new();
-        let evaluation = assert_ok!(evaluator.evaluate(
-            crate::syntax_analysis::SyntaxAnalysis::from(
-                crate::lexical_analysis::LexicalAnalysis::from($code).unwrap(),
+        let evaluation = assert_ok!(
+            evaluator.evaluate(
+                crate::syntax_analysis::SyntaxAnalysis::from(
+                    crate::lexical_analysis::LexicalAnalysis::from($code).unwrap(),
+                )
+                .unwrap(),
             )
-            .unwrap(),
-        ));
+        );
 
         // Then
         insta::assert_debug_snapshot!(format!("test_{}_evaluation", $snapshot_name), evaluation);
@@ -63,12 +65,14 @@ macro_rules! assert_environment {
 
         // When
         let mut evaluator = crate::evaluator::Evaluator::new();
-        let _evaluation = assert_ok!(evaluator.evaluate(
-            crate::syntax_analysis::SyntaxAnalysis::from(
-                crate::lexical_analysis::LexicalAnalysis::from($code).unwrap(),
+        let _evaluation = assert_ok!(
+            evaluator.evaluate(
+                crate::syntax_analysis::SyntaxAnalysis::from(
+                    crate::lexical_analysis::LexicalAnalysis::from($code).unwrap(),
+                )
+                .unwrap(),
             )
-            .unwrap(),
-        ));
+        );
 
         // Then
         insta::assert_debug_snapshot!(format!("test_{}_environment", $snapshot_name), evaluator);
@@ -82,12 +86,14 @@ macro_rules! assert_successive_environment {
         });
 
         // When
-        let evaluation = assert_ok!($evaluator.evaluate(
-            crate::syntax_analysis::SyntaxAnalysis::from(
-                crate::lexical_analysis::LexicalAnalysis::from($code).unwrap(),
+        let evaluation = assert_ok!(
+            $evaluator.evaluate(
+                crate::syntax_analysis::SyntaxAnalysis::from(
+                    crate::lexical_analysis::LexicalAnalysis::from($code).unwrap(),
+                )
+                .unwrap(),
             )
-            .unwrap(),
-        ));
+        );
 
         // Then
         insta::assert_debug_snapshot!(format!("test_{}_evaluation", $snapshot_name), evaluation);