refactor: moving to anyhow context

Cargo.toml

@@ -19,9 +19,6 @@ pretty_env_logger = "0.5.0"
 # For CLI argument parsing.
 clap = { version = "4.5.0", features = ["derive"] }
 
-# For custom errors.
-thiserror = "2.0.0"
-
 # For error handling.
 anyhow = "1.0.89"
 

src/evaluator/expression/boolean/mod.rs

@@ -1,9 +1,8 @@
-use crate::evaluator::model::evaluation_error::EvaluationError;
 use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
 
 impl Evaluator {
-    pub(super) fn evaluate_boolean(&self, literal: bool) -> Result<Object, EvaluationError> {
+    pub(super) fn evaluate_boolean(&self, literal: bool) -> anyhow::Result<Object> {
         match literal {
             true => Ok(Object::True),
             false => Ok(Object::False),

src/evaluator/expression/call/mod.rs

@@ -1,4 +1,3 @@
-use crate::evaluator::model::evaluation_error::EvaluationError;
 use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
 use crate::syntax_analysis::model::syntax_tree_node::Expression;
@@ -8,7 +7,7 @@ impl Evaluator {
         &mut self,
         function: Expression,
         arguments: Vec<Expression>,
-    ) -> Result<Object, EvaluationError> {
+    ) -> anyhow::Result<Object> {
         match self.evaluate_expression(function)? {
             Object::Function { parameters, block } => {
                 self.environment.push();
@@ -24,7 +23,7 @@ impl Evaluator {
                 self.environment.pop();
                 Ok(block_call_evaluation)
             }
-            _ => Err(EvaluationError::UncallableObject),
+            _ => anyhow::bail!("UncallableObject"),
         }
     }
 }

src/evaluator/expression/function/mod.rs

@@ -1,4 +1,3 @@
-use crate::evaluator::model::evaluation_error::EvaluationError;
 use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
 use crate::syntax_analysis::model::syntax_tree_node::Block;
@@ -8,7 +7,7 @@ impl Evaluator {
         &self,
         parameters: Vec<String>,
         block: Block,
-    ) -> Result<Object, EvaluationError> {
+    ) -> anyhow::Result<Object> {
         Ok(Object::Function { parameters, block })
     }
 }

src/evaluator/expression/if_expression/mod.rs

@@ -1,4 +1,3 @@
-use crate::evaluator::model::evaluation_error::EvaluationError;
 use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
 use crate::syntax_analysis::model::syntax_tree_node::{Block, Expression};
@@ -9,7 +8,7 @@ impl Evaluator {
         condition: Expression,
         consequence: Block,
         alternative: Option<Block>,
-    ) -> Result<Object, EvaluationError> {
+    ) -> anyhow::Result<Object> {
         match self.evaluate_expression(condition)? {
             Object::Null | Object::False => match alternative {
                 Some(block) => self.evaluate_block(block),

src/evaluator/expression/infix/mod.rs

@@ -1,4 +1,3 @@
-use crate::evaluator::model::evaluation_error::EvaluationError;
 use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
 use crate::lexical_analysis::model::token::Token;
@@ -10,20 +9,20 @@ impl Evaluator {
         left_hand: Expression,
         operator_token: Token,
         right_hand: Expression,
-    ) -> Result<Object, EvaluationError> {
-        fn evaluate_same_boolean(operator_token: Token) -> Result<Object, EvaluationError> {
+    ) -> anyhow::Result<Object> {
+        fn evaluate_same_boolean(operator_token: Token) -> anyhow::Result<Object> {
             match operator_token {
                 Token::Equals => Ok(Object::True),
                 Token::NotEquals => Ok(Object::False),
-                _ => Err(EvaluationError::UnknownOperator),
+                _ => anyhow::bail!("UnknownOperator"),
             }
         }
 
-        fn evaluate_opposite_boolean(operator_token: Token) -> Result<Object, EvaluationError> {
+        fn evaluate_opposite_boolean(operator_token: Token) -> anyhow::Result<Object> {
             match operator_token {
                 Token::Equals => Ok(Object::False),
                 Token::NotEquals => Ok(Object::True),
-                _ => Err(EvaluationError::UnknownOperator),
+                _ => anyhow::bail!("UnknownOperator"),
             }
         }
 
@@ -58,19 +57,19 @@ impl Evaluator {
                         true => Ok(Object::True),
                         false => Ok(Object::False),
                     },
-                    _ => Err(EvaluationError::UnknownOperator),
+                    _ => anyhow::bail!("UnknownOperator"),
                 },
-                _ => Err(EvaluationError::TypeMismatch),
+                _ => anyhow::bail!("TypeMismatch"),
             },
             Object::True => match self.evaluate_expression(right_hand)? {
                 Object::True => evaluate_same_boolean(operator_token),
                 Object::False => evaluate_opposite_boolean(operator_token),
-                _ => Err(EvaluationError::TypeMismatch),
+                _ => anyhow::bail!("TypeMismatch"),
             },
             Object::False => match self.evaluate_expression(right_hand)? {
                 Object::False => evaluate_same_boolean(operator_token),
                 Object::True => evaluate_opposite_boolean(operator_token),
-                _ => Err(EvaluationError::TypeMismatch),
+                _ => anyhow::bail!("TypeMismatch"),
             },
             Object::String { value: left_value } => match self.evaluate_expression(right_hand)? {
                 Object::String { value: right_value } => match operator_token {
@@ -89,11 +88,11 @@ impl Evaluator {
                             value: concatenated,
                         })
                     }
-                    _ => Err(EvaluationError::UnknownOperator),
+                    _ => anyhow::bail!("UnknownOperator"),
                 },
-                _ => Err(EvaluationError::TypeMismatch),
+                _ => anyhow::bail!("TypeMismatch"),
             },
-            _ => Err(EvaluationError::UnknownOperator),
+            _ => anyhow::bail!("UnknownOperator"),
         }
     }
 }

src/evaluator/expression/integer/mod.rs

@@ -1,9 +1,8 @@
-use crate::evaluator::model::evaluation_error::EvaluationError;
 use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
 
 impl Evaluator {
-    pub(super) fn evaluate_integer(&self, literal: i64) -> Result<Object, EvaluationError> {
+    pub(super) fn evaluate_integer(&self, literal: i64) -> anyhow::Result<Object> {
         Ok(Object::Integer { value: literal })
     }
 }

src/evaluator/expression/mod.rs

@@ -1,4 +1,3 @@
-use crate::evaluator::model::evaluation_error::EvaluationError;
 use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
 use crate::syntax_analysis::model::syntax_tree_node::*;
@@ -13,10 +12,7 @@ mod prefix;
 mod string;
 
 impl Evaluator {
-    pub(crate) fn evaluate_expression(
-        &mut self,
-        expression: Expression,
-    ) -> Result<Object, EvaluationError> {
+    pub(crate) fn evaluate_expression(&mut self, expression: Expression) -> anyhow::Result<Object> {
         match expression {
             Expression::Integer { literal } => self.evaluate_integer(literal),
             Expression::String { literal } => self.evaluate_string(literal),

src/evaluator/expression/prefix/mod.rs

@@ -1,4 +1,3 @@
-use crate::evaluator::model::evaluation_error::EvaluationError;
 use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
 use crate::syntax_analysis::model::syntax_tree_node::Expression;
@@ -7,25 +6,25 @@ impl Evaluator {
     pub(super) fn evaluate_not_prefix_expression(
         &mut self,
         right_hand_expression: Expression,
-    ) -> Result<Object, EvaluationError> {
+    ) -> anyhow::Result<Object> {
         let object = self.evaluate_expression(right_hand_expression)?;
 
         match object {
             Object::True => Ok(Object::False),
             Object::False => Ok(Object::True),
-            _ => Err(EvaluationError::TypeMismatch),
+            _ => anyhow::bail!("TypeMismatch"),
         }
     }
 
     pub(super) fn evaluate_minus_prefix_expression(
         &mut self,
         right_hand_expression: Expression,
-    ) -> Result<Object, EvaluationError> {
+    ) -> anyhow::Result<Object> {
         let object = self.evaluate_expression(right_hand_expression)?;
 
         match object {
             Object::Integer { value } => Ok(Object::Integer { value: -value }),
-            _ => Err(EvaluationError::TypeMismatch),
+            _ => anyhow::bail!("TypeMismatch"),
         }
     }
 }

src/evaluator/expression/string/mod.rs

@@ -1,9 +1,8 @@
-use crate::evaluator::model::evaluation_error::EvaluationError;
 use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
 
 impl Evaluator {
-    pub(super) fn evaluate_string(&self, string: String) -> Result<Object, EvaluationError> {
+    pub(super) fn evaluate_string(&self, string: String) -> anyhow::Result<Object> {
         Ok(Object::String { value: string })
     }
 }

src/evaluator/mod.rs

@@ -1,5 +1,4 @@
 use crate::evaluator::model::environment::Environment;
-use crate::evaluator::model::evaluation_error::EvaluationError;
 use crate::evaluator::model::object::Object;
 use crate::syntax_analysis::model::syntax_tree_node::*;
 
@@ -23,7 +22,7 @@ impl Evaluator {
     pub(crate) fn evaluate(
         &mut self,
         abstract_syntax_tree: Vec<SyntaxTreeNode>,
-    ) -> Result<Object, EvaluationError> {
+    ) -> anyhow::Result<Object> {
         let mut object = Object::Null;
 
         for syntax_tree_node in abstract_syntax_tree {
@@ -38,7 +37,7 @@ impl Evaluator {
         Ok(object)
     }
 
-    fn evaluate_block(&mut self, block: Block) -> Result<Object, EvaluationError> {
+    fn evaluate_block(&mut self, block: Block) -> anyhow::Result<Object> {
         let mut object = Object::Null;
 
         for syntax_tree_node in block.nodes {
@@ -52,10 +51,7 @@ impl Evaluator {
         Ok(object)
     }
 
-    fn evaluate_node(
-        &mut self,
-        syntax_tree_node: SyntaxTreeNode,
-    ) -> Result<Object, EvaluationError> {
+    fn evaluate_node(&mut self, syntax_tree_node: SyntaxTreeNode) -> anyhow::Result<Object> {
         match syntax_tree_node {
             SyntaxTreeNode::Expression { expression } => self.evaluate_expression(expression),
             SyntaxTreeNode::Statement { statement } => self.evaluate_statement(statement),

src/evaluator/model/mod.rs

@@ -1,3 +1,2 @@
 pub(super) mod environment;
-pub(super) mod evaluation_error;
 pub mod object;

src/evaluator/statement/let_statement/mod.rs

@@ -1,4 +1,3 @@
-use crate::evaluator::model::evaluation_error::EvaluationError;
 use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
 use crate::syntax_analysis::model::syntax_tree_node::*;
@@ -8,11 +7,11 @@ impl Evaluator {
         &mut self,
         identifier: String,
         expression: Expression,
-    ) -> Result<Object, EvaluationError> {
+    ) -> anyhow::Result<Object> {
         let expression = self.evaluate_expression(expression)?;
 
         if let Object::Return { value: _ } = expression {
-            return Err(EvaluationError::UnassignableObject);
+            anyhow::bail!("UnassignableObject");
         }
 
         self.environment.set(identifier, expression);

src/evaluator/statement/mod.rs

@@ -1,4 +1,3 @@
-use crate::evaluator::model::evaluation_error::EvaluationError;
 use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
 use crate::syntax_analysis::model::syntax_tree_node::*;
@@ -7,10 +6,7 @@ mod let_statement;
 mod return_statement;
 
 impl Evaluator {
-    pub(super) fn evaluate_statement(
-        &mut self,
-        statement: Statement,
-    ) -> Result<Object, EvaluationError> {
+    pub(super) fn evaluate_statement(&mut self, statement: Statement) -> anyhow::Result<Object> {
         match statement {
             Statement::Let {
                 identifier,

src/evaluator/statement/return_statement/mod.rs

@@ -1,4 +1,3 @@
-use crate::evaluator::model::evaluation_error::EvaluationError;
 use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
 use crate::syntax_analysis::model::syntax_tree_node::*;
@@ -7,7 +6,7 @@ impl Evaluator {
     pub(super) fn evaluate_return_statement(
         &mut self,
         expression: Expression,
-    ) -> Result<Object, EvaluationError> {
+    ) -> anyhow::Result<Object> {
         Ok(Object::Return {
             value: Box::new(self.evaluate_expression(expression)?),
         })