refactor: moving to anyhow context

Closed issue #50

Author: DeveloperC286

Cargo.lock

@@ -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"
 

Cargo.toml

@@ -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/boolean/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/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::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/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, 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/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::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/infix/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/integer/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/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"),
         }
     }
 }