refactor: Token -> InfixOperator enum

src/evaluator/expression/infix/mod.rs

@@ -1,87 +1,85 @@
 use crate::evaluator::model::object::Object;
 use crate::evaluator::Evaluator;
-use crate::lexical_analysis::model::token::Token;
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
+use crate::syntax_analysis::model::syntax_tree_node::{Expression, InfixOperator};
 
 impl Evaluator {
     pub(super) fn evaluate_infix_expression(
         &mut self,
         left_hand: Expression,
-        operator_token: Token,
+        operator: InfixOperator,
         right_hand: Expression,
     ) -> 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),
+        fn evaluate_same_boolean(operator: InfixOperator) -> anyhow::Result<Object> {
+            match operator {
+                InfixOperator::Equals => Ok(Object::True),
+                InfixOperator::NotEquals => Ok(Object::False),
                 _ => anyhow::bail!("UnknownOperator"),
             }
         }
 
-        fn evaluate_opposite_boolean(operator_token: Token) -> anyhow::Result<Object> {
-            match operator_token {
-                Token::Equals => Ok(Object::False),
-                Token::NotEquals => Ok(Object::True),
+        fn evaluate_opposite_boolean(operator: InfixOperator) -> anyhow::Result<Object> {
+            match operator {
+                InfixOperator::Equals => Ok(Object::False),
+                InfixOperator::NotEquals => Ok(Object::True),
                 _ => anyhow::bail!("UnknownOperator"),
             }
         }
 
         match self.evaluate_expression(left_hand)? {
             Object::Integer { value: left_value } => match self.evaluate_expression(right_hand)? {
-                Object::Integer { value: right_value } => match operator_token {
-                    Token::Plus => Ok(Object::Integer {
+                Object::Integer { value: right_value } => match operator {
+                    InfixOperator::Plus => Ok(Object::Integer {
                         value: left_value + right_value,
                     }),
-                    Token::Minus => Ok(Object::Integer {
+                    InfixOperator::Minus => Ok(Object::Integer {
                         value: left_value - right_value,
                     }),
-                    Token::Multiply => Ok(Object::Integer {
+                    InfixOperator::Multiply => Ok(Object::Integer {
                         value: left_value * right_value,
                     }),
-                    Token::Divide => Ok(Object::Integer {
+                    InfixOperator::Divide => Ok(Object::Integer {
                         value: left_value / right_value,
                     }),
-                    Token::GreaterThan => match left_value > right_value {
+                    InfixOperator::GreaterThan => match left_value > right_value {
                         true => Ok(Object::True),
                         false => Ok(Object::False),
                     },
-                    Token::LesserThan => match left_value < right_value {
+                    InfixOperator::LesserThan => match left_value < right_value {
                         true => Ok(Object::True),
                         false => Ok(Object::False),
                     },
-                    Token::Equals => match left_value == right_value {
+                    InfixOperator::Equals => match left_value == right_value {
                         true => Ok(Object::True),
                         false => Ok(Object::False),
                     },
-                    Token::NotEquals => match left_value != right_value {
+                    InfixOperator::NotEquals => match left_value != right_value {
                         true => Ok(Object::True),
                         false => Ok(Object::False),
                     },
-                    _ => anyhow::bail!("UnknownOperator"),
                 },
                 _ => 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),
+                Object::True => evaluate_same_boolean(operator),
+                Object::False => evaluate_opposite_boolean(operator),
                 _ => 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),
+                Object::False => evaluate_same_boolean(operator),
+                Object::True => evaluate_opposite_boolean(operator),
                 _ => anyhow::bail!("TypeMismatch"),
             },
             Object::String { value: left_value } => match self.evaluate_expression(right_hand)? {
-                Object::String { value: right_value } => match operator_token {
-                    Token::Equals => match left_value.eq(&right_value) {
+                Object::String { value: right_value } => match operator {
+                    InfixOperator::Equals => match left_value.eq(&right_value) {
                         true => Ok(Object::True),
                         false => Ok(Object::False),
                     },
-                    Token::NotEquals => match left_value.ne(&right_value) {
+                    InfixOperator::NotEquals => match left_value.ne(&right_value) {
                         true => Ok(Object::True),
                         false => Ok(Object::False),
                     },
-                    Token::Plus => {
+                    InfixOperator::Plus => {
                         let mut concatenated = left_value;
                         concatenated.push_str(&right_value);
                         Ok(Object::String {

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

@@ -1,4 +1,6 @@
-use crate::syntax_analysis::model::syntax_tree_node::Expression;
+use crate::lexical_analysis::model::token::Token;
+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<'_> {
@@ -8,20 +10,29 @@ impl SyntaxAnalysis<'_> {
     ) -> anyhow::Result<Expression> {
         debug!("Parsing a infix expression.");
 
-        let operator = self
+        let token = self
             .tokens
             .next()
             .ok_or_else(|| anyhow::anyhow!("No token to parse."))?;
 
-        let precedence =
-            crate::syntax_analysis::model::expression_precedence::get_current_expression_precedence(
-                operator,
-            );
+        let operator = match token {
+            Token::Plus => InfixOperator::Plus,
+            Token::Minus => InfixOperator::Minus,
+            Token::Multiply => InfixOperator::Multiply,
+            Token::Divide => InfixOperator::Divide,
+            Token::Equals => InfixOperator::Equals,
+            Token::NotEquals => InfixOperator::NotEquals,
+            Token::LesserThan => InfixOperator::LesserThan,
+            Token::GreaterThan => InfixOperator::GreaterThan,
+            _ => anyhow::bail!("Unknown infix operator token {:?}.", token),
+        };
+
+        let precedence = get_infix_operator_precedence(&operator);
 
         self.get_expression(precedence)
             .map(|right_hand| Expression::Infix {
                 left_hand: Box::new(left_hand),
-                operator: operator.clone(),
+                operator,
                 right_hand: Box::new(right_hand),
             })
     }

src/syntax_analysis/model/expression_precedence/mod.rs

@@ -1,4 +1,5 @@
 use crate::lexical_analysis::model::token::Token;
+use crate::syntax_analysis::model::syntax_tree_node::InfixOperator;
 
 #[derive(Debug, Copy, Clone, PartialEq, PartialOrd)]
 pub(crate) enum ExpressionPrecedence {
@@ -28,3 +29,14 @@ pub(crate) fn get_current_expression_precedence(token: &Token) -> ExpressionPrec
         }
     }
 }
+
+pub(crate) fn get_infix_operator_precedence(operator: &InfixOperator) -> ExpressionPrecedence {
+    match operator {
+        InfixOperator::Equals | InfixOperator::NotEquals => ExpressionPrecedence::Equals,
+        InfixOperator::LesserThan | InfixOperator::GreaterThan => {
+            ExpressionPrecedence::LesserOrGreater
+        }
+        InfixOperator::Plus | InfixOperator::Minus => ExpressionPrecedence::Plus,
+        InfixOperator::Multiply | InfixOperator::Divide => ExpressionPrecedence::Multiply,
+    }
+}

src/syntax_analysis/model/syntax_tree_node/mod.rs

@@ -1,5 +1,3 @@
-use crate::lexical_analysis::model::token::Token;
-
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct Block {
     pub(crate) nodes: Vec<SyntaxTreeNode>,
@@ -22,6 +20,18 @@ pub(crate) enum Statement {
     },
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) enum InfixOperator {
+    Plus,
+    Minus,
+    Multiply,
+    Divide,
+    Equals,
+    NotEquals,
+    LesserThan,
+    GreaterThan,
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) enum Expression {
     Identifier {
@@ -41,7 +51,7 @@ pub(crate) enum Expression {
     },
     Infix {
         left_hand: Box<Expression>,
-        operator: Token,
+        operator: InfixOperator,
         right_hand: Box<Expression>,
     },
     Boolean {