From 2a58e8cff28338a3e5f423ff25304aaee30bc07a Mon Sep 17 00:00:00 2001 From: DeveloperC Date: Fri, 20 Feb 2026 01:58:08 +0000 Subject: [PATCH] refactor: Token -> InfixOperator enum --- src/evaluator/expression/infix/mod.rs | 56 +++++++++---------- .../pratt_parsing/infix_expression/mod.rs | 25 ++++++--- .../model/expression_precedence/mod.rs | 12 ++++ .../model/syntax_tree_node/mod.rs | 16 +++++- 4 files changed, 70 insertions(+), 39 deletions(-) diff --git a/src/evaluator/expression/infix/mod.rs b/src/evaluator/expression/infix/mod.rs index 48e3b292..7077fd6b 100644 --- a/src/evaluator/expression/infix/mod.rs +++ b/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 { - fn evaluate_same_boolean(operator_token: Token) -> anyhow::Result { - match operator_token { - Token::Equals => Ok(Object::True), - Token::NotEquals => Ok(Object::False), + fn evaluate_same_boolean(operator: InfixOperator) -> anyhow::Result { + match operator { + InfixOperator::Equals => Ok(Object::True), + InfixOperator::NotEquals => Ok(Object::False), _ => anyhow::bail!("UnknownOperator"), } } - fn evaluate_opposite_boolean(operator_token: Token) -> anyhow::Result { - match operator_token { - Token::Equals => Ok(Object::False), - Token::NotEquals => Ok(Object::True), + fn evaluate_opposite_boolean(operator: InfixOperator) -> anyhow::Result { + 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 { diff --git a/src/syntax_analysis/expression/pratt_parsing/infix_expression/mod.rs b/src/syntax_analysis/expression/pratt_parsing/infix_expression/mod.rs index 2a4dc76f..c30befc4 100644 --- a/src/syntax_analysis/expression/pratt_parsing/infix_expression/mod.rs +++ b/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 { 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), }) } diff --git a/src/syntax_analysis/model/expression_precedence/mod.rs b/src/syntax_analysis/model/expression_precedence/mod.rs index b2ee7d27..6b702330 100644 --- a/src/syntax_analysis/model/expression_precedence/mod.rs +++ b/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, + } +} diff --git a/src/syntax_analysis/model/syntax_tree_node/mod.rs b/src/syntax_analysis/model/syntax_tree_node/mod.rs index 118e66ad..493f9a7b 100644 --- a/src/syntax_analysis/model/syntax_tree_node/mod.rs +++ b/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, @@ -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, - operator: Token, + operator: InfixOperator, right_hand: Box, }, Boolean {