From 2171bebc08a5747503c2e96e461c4042e8627481 Mon Sep 17 00:00:00 2001 From: bad Date: Mon, 2 May 2022 12:56:52 +0200 Subject: [PATCH] Refactor expression module tree --- src/ast/expression/binary_expr.rs | 103 +++++++++ src/ast/expression/expression_node.rs | 217 ------------------ src/ast/expression/expression_parser.rs | 124 ---------- src/ast/expression/grouping_expr.rs | 16 ++ src/ast/expression/literal_expr.rs | 10 + src/ast/expression/mod.rs | 103 ++++++++- src/ast/expression/operator.rs | 89 +++++++ src/ast/expression/unary_expr.rs | 41 ++++ src/ast/expression/variable_expr.rs | 17 ++ src/ast/statement/expression_statement.rs | 2 +- src/ast/statement/print_statement.rs | 2 +- .../variable_assignment_statement.rs | 2 +- .../ast_walker/expression_interpreter.rs | 37 +-- src/interpreter/types.rs | 10 +- 14 files changed, 406 insertions(+), 367 deletions(-) create mode 100644 src/ast/expression/binary_expr.rs delete mode 100644 src/ast/expression/expression_parser.rs create mode 100644 src/ast/expression/grouping_expr.rs create mode 100644 src/ast/expression/literal_expr.rs create mode 100644 src/ast/expression/operator.rs create mode 100644 src/ast/expression/unary_expr.rs create mode 100644 src/ast/expression/variable_expr.rs diff --git a/src/ast/expression/binary_expr.rs b/src/ast/expression/binary_expr.rs new file mode 100644 index 0000000..c739fe5 --- /dev/null +++ b/src/ast/expression/binary_expr.rs @@ -0,0 +1,103 @@ +use itertools::PeekingNext; + +use super::operator::Operator; +use super::{ + token::{self, TokenType}, + ExpressionNode, Parser, Result, +}; +use std::fmt::Debug; + +pub struct BinaryExpr { + pub left: Box, + pub operator: Operator, + pub right: Box, +} + +impl BinaryExpr { + pub fn new(left: Box, operator: Operator, right: Box) -> Self { + Self { + left, + operator, + right, + } + } +} + +impl Debug for BinaryExpr { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "({} {:?} {:?})", self.operator, self.left, self.right) + } +} + +impl<'a, T: Iterator>> Parser<'a, T> { + pub(super) fn equality(&mut self) -> Result { + let mut node = self.comparison()?; + while let Some(o) = self + .token_iter + .peeking_next(|t| matches!(t.token_type, TokenType::EqualEqual | TokenType::BangEqual)) + { + node = BinaryExpr::new( + Box::new(node), + o.token_type.try_into().unwrap(), + Box::new(self.comparison()?), + ) + .into(); + } + Ok(node) + } + + pub(super) fn comparison(&mut self) -> Result { + let mut node = self.term()?; + + while let Some(o) = self.token_iter.peeking_next(|t| { + matches!( + t.token_type, + TokenType::Greater + | TokenType::GreaterEqual + | TokenType::Less | TokenType::LessEqual + ) + }) { + node = BinaryExpr::new( + Box::new(node), + o.token_type.try_into().unwrap(), + Box::new(self.comparison()?), + ) + .into(); + } + Ok(node) + } + + pub(super) fn term(&mut self) -> Result { + let mut node = self.factor()?; + + while let Some(o) = self + .token_iter + .peeking_next(|t| matches!(t.token_type, TokenType::Minus | TokenType::Plus)) + { + node = BinaryExpr::new( + Box::new(node), + o.token_type.try_into().unwrap(), + Box::new(self.comparison()?), + ) + .into() + } + Ok(node) + } + + pub(super) fn factor(&mut self) -> Result { + let mut node = self.unary()?; + + while let Some(o) = self + .token_iter + .peeking_next(|t| matches!(t.token_type, TokenType::Star | TokenType::Slash)) + { + node = BinaryExpr::new( + Box::new(node), + o.token_type.try_into().unwrap(), + Box::new(self.comparison()?), + ) + .into(); + } + Ok(node) + } +} diff --git a/src/ast/expression/expression_node.rs b/src/ast/expression/expression_node.rs index 0e92105..8b13789 100644 --- a/src/ast/expression/expression_node.rs +++ b/src/ast/expression/expression_node.rs @@ -1,218 +1 @@ -use crate::lexer::token; -use from_variants::FromVariants; -use match_any::match_any; -use std::fmt::{Debug, Display}; -#[derive(FromVariants)] -pub enum ExpressionNode { - BinaryExpr(BinaryExpr), - GroupingExpr(GroupingExpr), - Literal(Literal), - Variable(VariableExpr), - UnaryExpr(UnaryExpr), -} - -macro_rules! all_variants { - ($expr:expr, $val_name:ident => $expr_arm:expr) => { - { - use match_any::match_any; - use $crate::ast::expression::expression_node::*; - match_any!($expr, - ExpressionNode::BinaryExpr($val_name) | - ExpressionNode::GroupingExpr($val_name) | - ExpressionNode::Literal($val_name) | - ExpressionNode::Variable($val_name) | - ExpressionNode::UnaryExpr($val_name) => $expr_arm) - } - }; -} -pub(crate) use all_variants; - -impl Debug for ExpressionNode { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - all_variants!(self, n => n.fmt(f)) - } -} - -pub enum UnaryOperator { - Minus, - Bang, -} - -impl TryFrom for UnaryOperator { - type Error = EnumConvertError; - - fn try_from(value: token::TokenType) -> Result { - Ok(match value { - token::TokenType::Bang => Self::Bang, - token::TokenType::Minus => Self::Minus, - _ => return Err(EnumConvertError), - }) - } -} - -impl Display for UnaryOperator { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!( - f, - "{}", - match *self { - UnaryOperator::Minus => "-", - UnaryOperator::Bang => "!", - } - ) - } -} - -pub enum Operator { - BangEqual, - Equal, - EqualEqual, - Greater, - GreaterEqual, - Less, - LessEqual, -} - -#[derive(Debug)] -pub struct EnumConvertError; -impl std::fmt::Display for EnumConvertError { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "Couldn't convert between enums") - } -} - -impl std::error::Error for EnumConvertError {} - -impl TryFrom for Operator { - type Error = EnumConvertError; - - fn try_from(value: token::TokenType) -> Result { - Ok(match value { - token::TokenType::BangEqual => Self::BangEqual, - token::TokenType::Equal => Self::Equal, - token::TokenType::EqualEqual => Self::EqualEqual, - token::TokenType::Greater => Self::Greater, - token::TokenType::GreaterEqual => Self::GreaterEqual, - token::TokenType::Less => Self::Less, - token::TokenType::LessEqual => Self::LessEqual, - - _ => return Err(EnumConvertError), - }) - } -} - -impl Display for Operator { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!( - f, - "{}", - match *self { - Operator::Less => "<", - Operator::Equal => "=", - Operator::Greater => ">", - Operator::BangEqual => "!=", - Operator::LessEqual => "<=", - Operator::EqualEqual => "==", - Operator::GreaterEqual => ">=", - } - ) - } -} - -#[derive(Debug, Clone)] -pub enum Literal { - String(String), - Int(i32), - Float(f32), - Bool(bool), - Nil, -} - -pub struct BinaryExpr { - pub left: Box, - pub operator: Operator, - pub right: Box, -} - -impl BinaryExpr { - pub fn new(left: Box, operator: Operator, right: Box) -> Self { - Self { - left, - operator, - right, - } - } -} - -pub struct GroupingExpr(pub Box); - -impl GroupingExpr { - pub(crate) fn new(expr: Box) -> Self { - Self(expr) - } -} - -pub struct UnaryExpr { - pub operator: UnaryOperator, - pub right: Box, -} - -impl UnaryExpr { - pub fn new(operator: UnaryOperator, right: Box) -> Self { - Self { operator, right } - } -} - -impl Debug for BinaryExpr { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "({} {:?} {:?})", self.operator, self.left, self.right) - } -} - -impl Debug for GroupingExpr { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "({:?})", self.0) - } -} - -impl Debug for UnaryExpr { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "({} {:?})", self.operator, self.right) - } -} - -pub struct VariableExpr { - pub var_name: String, -} - -impl Debug for VariableExpr { - fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { - write!(f, "(variable({}))", self.var_name) - } -} - -impl VariableExpr { - pub fn new(var_name: String) -> Self { - Self { var_name } - } -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn expression_node_ast_printer() { - let ast = ExpressionNode::BinaryExpr(BinaryExpr { - left: Box::new(ExpressionNode::UnaryExpr(UnaryExpr { - operator: UnaryOperator::Bang, - right: Box::new(ExpressionNode::Literal(Literal::Int(1))), - })), - operator: Operator::EqualEqual, - right: Box::new(ExpressionNode::Literal(Literal::Int(0))), - }); - let formated = format!("{:?}", ast); - assert_eq!("(== (! Int(1)) Int(0))", formated); - } -} diff --git a/src/ast/expression/expression_parser.rs b/src/ast/expression/expression_parser.rs deleted file mode 100644 index 3ae84db..0000000 --- a/src/ast/expression/expression_parser.rs +++ /dev/null @@ -1,124 +0,0 @@ -use itertools::PeekingNext; - -use crate::lexer::token::{self, TokenType}; - -use super::super::parser::{InnerASTParsingError, Parser, Result}; -use super::expression_node::*; - -impl<'a, T: Iterator>> Parser<'a, T> { - pub fn expression(&mut self) -> Result { - self.equality() - } - - fn equality(&mut self) -> Result { - let mut node = self.comparison()?; - while let Some(o) = self - .token_iter - .peeking_next(|t| matches!(t.token_type, TokenType::EqualEqual | TokenType::BangEqual)) - { - node = BinaryExpr::new( - Box::new(node), - o.token_type.try_into().unwrap(), - Box::new(self.comparison()?), - ) - .into(); - } - Ok(node) - } - - fn comparison(&mut self) -> Result { - let mut node = self.term()?; - - while let Some(o) = self.token_iter.peeking_next(|t| { - matches!( - t.token_type, - TokenType::Greater - | TokenType::GreaterEqual - | TokenType::Less | TokenType::LessEqual - ) - }) { - node = BinaryExpr::new( - Box::new(node), - o.token_type.try_into().unwrap(), - Box::new(self.comparison()?), - ) - .into(); - } - Ok(node) - } - - fn term(&mut self) -> Result { - let mut node = self.factor()?; - - while let Some(o) = self - .token_iter - .peeking_next(|t| matches!(t.token_type, TokenType::Minus | TokenType::Plus)) - { - node = BinaryExpr::new( - Box::new(node), - o.token_type.try_into().unwrap(), - Box::new(self.comparison()?), - ) - .into() - } - Ok(node) - } - - fn factor(&mut self) -> Result { - let mut node = self.unary()?; - - while let Some(o) = self - .token_iter - .peeking_next(|t| matches!(t.token_type, TokenType::Star | TokenType::Slash)) - { - node = BinaryExpr::new( - Box::new(node), - o.token_type.try_into().unwrap(), - Box::new(self.comparison()?), - ) - .into(); - } - Ok(node) - } - - fn unary(&mut self) -> Result { - if let Some(op) = self - .token_iter - .peeking_next(|t| matches!(t.token_type, TokenType::Bang | TokenType::Minus)) - { - let right = Box::new(self.unary()?); - Ok(ExpressionNode::UnaryExpr(UnaryExpr::new( - op.token_type.try_into().unwrap(), - right, - ))) - } else { - self.primary() - } - } - - fn primary(&mut self) -> Result { - let token = self.token_iter.next(); - let node = match token.token_type { - TokenType::False => ExpressionNode::Literal(Literal::Bool(false)), - TokenType::True => ExpressionNode::Literal(Literal::Bool(true)), - TokenType::Int(i) => ExpressionNode::Literal(Literal::Int(i)), - TokenType::String(i) => ExpressionNode::Literal(Literal::String(i)), - TokenType::Float(f) => ExpressionNode::Literal(Literal::Float(f)), - TokenType::Nil => ExpressionNode::Literal(Literal::Nil), - TokenType::LeftParen => { - let expr = self.expression()?; - let group = GroupingExpr::new(Box::new(expr)); - match self - .token_iter - .peeking_next(|v| matches!(v.token_type, TokenType::RightParen)) - { - Some(_) => return Ok(group.into()), - None => return Err(token.location.wrap(InnerASTParsingError::UnmatchedBrace)), - } - } - TokenType::Identifier(var_name) => VariableExpr::new(var_name).into(), - a => return Err(token.location.wrap(InnerASTParsingError::IncorrectToken(a))), - }; - Ok(node) - } -} diff --git a/src/ast/expression/grouping_expr.rs b/src/ast/expression/grouping_expr.rs new file mode 100644 index 0000000..873b826 --- /dev/null +++ b/src/ast/expression/grouping_expr.rs @@ -0,0 +1,16 @@ +use super::ExpressionNode; +use std::fmt::Debug; + +pub struct GroupingExpr(pub Box); + +impl GroupingExpr { + pub(crate) fn new(expr: Box) -> Self { + Self(expr) + } +} + +impl Debug for GroupingExpr { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "({:?})", self.0) + } +} diff --git a/src/ast/expression/literal_expr.rs b/src/ast/expression/literal_expr.rs new file mode 100644 index 0000000..6a9f889 --- /dev/null +++ b/src/ast/expression/literal_expr.rs @@ -0,0 +1,10 @@ +use std::fmt::Debug; + +#[derive(Debug, Clone)] +pub enum Literal { + String(String), + Int(i32), + Float(f32), + Bool(bool), + Nil, +} diff --git a/src/ast/expression/mod.rs b/src/ast/expression/mod.rs index 8b145e4..5601795 100644 --- a/src/ast/expression/mod.rs +++ b/src/ast/expression/mod.rs @@ -1,2 +1,103 @@ +mod binary_expr; pub mod expression_node; -mod expression_parser; +mod grouping_expr; +mod literal_expr; +pub mod operator; +mod unary_expr; +mod variable_expr; + +pub use binary_expr::BinaryExpr; +pub use grouping_expr::GroupingExpr; +use itertools::PeekingNext; +pub use literal_expr::Literal; +pub use unary_expr::UnaryExpr; +pub use variable_expr::VariableExpr; + +use super::parser::{InnerASTParsingError, Parser, Result}; +use crate::lexer::token::{self, TokenType}; + +use from_variants::FromVariants; +use match_any::match_any; +use std::fmt::Debug; + +#[derive(FromVariants)] +pub enum ExpressionNode { + BinaryExpr(BinaryExpr), + GroupingExpr(GroupingExpr), + Literal(Literal), + Variable(VariableExpr), + UnaryExpr(UnaryExpr), +} + +macro_rules! all_variants { + ($expr:expr, $val_name:ident => $expr_arm:expr) => { + { + use match_any::match_any; + use $crate::ast::expression::*; + match_any!($expr, + ExpressionNode::BinaryExpr($val_name) | + ExpressionNode::GroupingExpr($val_name) | + ExpressionNode::Literal($val_name) | + ExpressionNode::Variable($val_name) | + ExpressionNode::UnaryExpr($val_name) => $expr_arm) + } + }; +} +pub(crate) use all_variants; + +impl Debug for ExpressionNode { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + all_variants!(self, n => n.fmt(f)) + } +} + +impl<'a, T: Iterator>> Parser<'a, T> { + pub fn expression(&mut self) -> Result { + self.equality() + } + pub(super) fn primary(&mut self) -> Result { + let token = self.token_iter.next(); + let node = match token.token_type { + TokenType::False => ExpressionNode::Literal(Literal::Bool(false)), + TokenType::True => ExpressionNode::Literal(Literal::Bool(true)), + TokenType::Int(i) => ExpressionNode::Literal(Literal::Int(i)), + TokenType::String(i) => ExpressionNode::Literal(Literal::String(i)), + TokenType::Float(f) => ExpressionNode::Literal(Literal::Float(f)), + TokenType::Nil => ExpressionNode::Literal(Literal::Nil), + TokenType::LeftParen => { + let expr = self.expression()?; + let group = GroupingExpr::new(Box::new(expr)); + match self + .token_iter + .peeking_next(|v| matches!(v.token_type, TokenType::RightParen)) + { + Some(_) => return Ok(group.into()), + None => return Err(token.location.wrap(InnerASTParsingError::UnmatchedBrace)), + } + } + TokenType::Identifier(var_name) => VariableExpr::new(var_name).into(), + a => return Err(token.location.wrap(InnerASTParsingError::IncorrectToken(a))), + }; + Ok(node) + } +} + +#[cfg(test)] +mod tests { + use super::*; + use operator::{Operator, UnaryOperator}; + + #[test] + fn expression_node_ast_printer() { + let ast = ExpressionNode::BinaryExpr(BinaryExpr { + left: Box::new(ExpressionNode::UnaryExpr(UnaryExpr { + operator: UnaryOperator::Bang, + right: Box::new(ExpressionNode::Literal(Literal::Int(1))), + })), + operator: Operator::EqualEqual, + right: Box::new(ExpressionNode::Literal(Literal::Int(0))), + }); + let formated = format!("{:?}", ast); + assert_eq!("(== (! Int(1)) Int(0))", formated); + } +} diff --git a/src/ast/expression/operator.rs b/src/ast/expression/operator.rs new file mode 100644 index 0000000..69dbb74 --- /dev/null +++ b/src/ast/expression/operator.rs @@ -0,0 +1,89 @@ +use std::fmt::Display; + +use crate::lexer::token; + +pub enum UnaryOperator { + Minus, + Bang, +} + +impl TryFrom for UnaryOperator { + type Error = EnumConvertError; + + fn try_from(value: token::TokenType) -> Result { + Ok(match value { + token::TokenType::Bang => Self::Bang, + token::TokenType::Minus => Self::Minus, + _ => return Err(EnumConvertError), + }) + } +} + +impl Display for UnaryOperator { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!( + f, + "{}", + match *self { + UnaryOperator::Minus => "-", + UnaryOperator::Bang => "!", + } + ) + } +} + +pub enum Operator { + BangEqual, + Equal, + EqualEqual, + Greater, + GreaterEqual, + Less, + LessEqual, +} + +#[derive(Debug)] +pub struct EnumConvertError; +impl std::fmt::Display for EnumConvertError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "Couldn't convert between enums") + } +} + +impl std::error::Error for EnumConvertError {} + +impl TryFrom for Operator { + type Error = EnumConvertError; + + fn try_from(value: token::TokenType) -> Result { + Ok(match value { + token::TokenType::BangEqual => Self::BangEqual, + token::TokenType::Equal => Self::Equal, + token::TokenType::EqualEqual => Self::EqualEqual, + token::TokenType::Greater => Self::Greater, + token::TokenType::GreaterEqual => Self::GreaterEqual, + token::TokenType::Less => Self::Less, + token::TokenType::LessEqual => Self::LessEqual, + + _ => return Err(EnumConvertError), + }) + } +} + +impl Display for Operator { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!( + f, + "{}", + match *self { + Operator::Less => "<", + Operator::Equal => "=", + Operator::Greater => ">", + Operator::BangEqual => "!=", + Operator::LessEqual => "<=", + Operator::EqualEqual => "==", + Operator::GreaterEqual => ">=", + } + ) + } +} diff --git a/src/ast/expression/unary_expr.rs b/src/ast/expression/unary_expr.rs new file mode 100644 index 0000000..e3c011e --- /dev/null +++ b/src/ast/expression/unary_expr.rs @@ -0,0 +1,41 @@ +use super::operator::UnaryOperator; +use super::{ + token::{self, TokenType}, + ExpressionNode, Parser, Result, +}; +use itertools::PeekingNext; +use std::fmt::Debug; + +pub struct UnaryExpr { + pub operator: UnaryOperator, + pub right: Box, +} + +impl UnaryExpr { + pub fn new(operator: UnaryOperator, right: Box) -> Self { + Self { operator, right } + } +} + +impl Debug for UnaryExpr { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "({} {:?})", self.operator, self.right) + } +} + +impl<'a, T: Iterator>> Parser<'a, T> { + pub(super) fn unary(&mut self) -> Result { + if let Some(op) = self + .token_iter + .peeking_next(|t| matches!(t.token_type, TokenType::Bang | TokenType::Minus)) + { + let right = Box::new(self.unary()?); + Ok(ExpressionNode::UnaryExpr(UnaryExpr::new( + op.token_type.try_into().unwrap(), + right, + ))) + } else { + self.primary() + } + } +} diff --git a/src/ast/expression/variable_expr.rs b/src/ast/expression/variable_expr.rs new file mode 100644 index 0000000..971254c --- /dev/null +++ b/src/ast/expression/variable_expr.rs @@ -0,0 +1,17 @@ +use std::fmt::Debug; + +pub struct VariableExpr { + pub var_name: String, +} + +impl Debug for VariableExpr { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + write!(f, "(variable({}))", self.var_name) + } +} + +impl VariableExpr { + pub fn new(var_name: String) -> Self { + Self { var_name } + } +} diff --git a/src/ast/statement/expression_statement.rs b/src/ast/statement/expression_statement.rs index 1c7a859..f690163 100644 --- a/src/ast/statement/expression_statement.rs +++ b/src/ast/statement/expression_statement.rs @@ -1,5 +1,5 @@ use crate::{ - ast::expression::expression_node::ExpressionNode, + ast::expression::ExpressionNode, ast::parser::{InnerASTParsingError, Parser, Result}, lexer::token::{self, TokenType}, }; diff --git a/src/ast/statement/print_statement.rs b/src/ast/statement/print_statement.rs index 3969a23..9256a3a 100644 --- a/src/ast/statement/print_statement.rs +++ b/src/ast/statement/print_statement.rs @@ -1,7 +1,7 @@ use itertools::PeekingNext; use super::{InnerASTParsingError, Parser, Result, Statement}; -use crate::ast::expression::expression_node::ExpressionNode; +use crate::ast::expression::ExpressionNode; use crate::lexer::token::{self, Token}; #[derive(Debug)] diff --git a/src/ast/statement/variable_assignment_statement.rs b/src/ast/statement/variable_assignment_statement.rs index 9f15292..d331f65 100644 --- a/src/ast/statement/variable_assignment_statement.rs +++ b/src/ast/statement/variable_assignment_statement.rs @@ -1,6 +1,6 @@ use super::Statement; use super::{InnerASTParsingError, Parser, Result}; -use crate::ast::expression::expression_node::ExpressionNode; +use crate::ast::expression::ExpressionNode; use crate::lexer::token::{self, TokenType}; #[derive(Debug)] diff --git a/src/interpreter/ast_walker/expression_interpreter.rs b/src/interpreter/ast_walker/expression_interpreter.rs index f467c0d..e93c394 100644 --- a/src/interpreter/ast_walker/expression_interpreter.rs +++ b/src/interpreter/ast_walker/expression_interpreter.rs @@ -1,42 +1,45 @@ use super::Interpret; use super::{types::Value, RuntimeError}; -use crate::ast::expression::expression_node; +use crate::ast::expression::{ + self, + operator::{Operator, UnaryOperator}, +}; use crate::interpreter::world::World; -impl Interpret for expression_node::ExpressionNode { +impl Interpret for expression::ExpressionNode { fn interpret(&self, w: &mut World) -> Result { - expression_node::all_variants!(self, n => n.interpret(w)) + expression::all_variants!(self, n => n.interpret(w)) } } -impl Interpret for expression_node::Literal { +impl Interpret for expression::Literal { fn interpret(&self, _: &mut World) -> Result { Ok(self.clone().into()) } } -impl Interpret for expression_node::BinaryExpr { +impl Interpret for expression::BinaryExpr { fn interpret(&self, w: &mut World) -> Result { let left_val = self.left.interpret(w).expect("expected lval"); let right_val = self.right.interpret(w).expect("expected rval"); match self.operator { - expression_node::Operator::BangEqual => Ok((left_val != right_val).into()), - expression_node::Operator::Less => Ok((left_val < right_val).into()), - expression_node::Operator::LessEqual => Ok((left_val <= right_val).into()), - expression_node::Operator::Greater => Ok((left_val > right_val).into()), - expression_node::Operator::GreaterEqual => Ok((left_val >= right_val).into()), - expression_node::Operator::EqualEqual => Ok((left_val == right_val).into()), - expression_node::Operator::Equal => todo!(), + Operator::BangEqual => Ok((left_val != right_val).into()), + Operator::Less => Ok((left_val < right_val).into()), + Operator::LessEqual => Ok((left_val <= right_val).into()), + Operator::Greater => Ok((left_val > right_val).into()), + Operator::GreaterEqual => Ok((left_val >= right_val).into()), + Operator::EqualEqual => Ok((left_val == right_val).into()), + Operator::Equal => todo!(), } } } -impl Interpret for expression_node::UnaryExpr { +impl Interpret for expression::UnaryExpr { fn interpret(&self, w: &mut World) -> Result { let val = self.right.interpret(w)?; match self.operator { - expression_node::UnaryOperator::Bang => Ok(Value::Bool(!val.truthy())), - expression_node::UnaryOperator::Minus => match val { + UnaryOperator::Bang => Ok(Value::Bool(!val.truthy())), + UnaryOperator::Minus => match val { Value::Int(i) => Ok(Value::Int(-i)), Value::Float(f) => Ok(Value::Float(-f)), _ => Err(RuntimeError), @@ -45,13 +48,13 @@ impl Interpret for expression_node::UnaryExpr { } } -impl Interpret for expression_node::GroupingExpr { +impl Interpret for expression::GroupingExpr { fn interpret(&self, w: &mut World) -> Result { self.0.interpret(w) } } -impl Interpret for expression_node::VariableExpr { +impl Interpret for expression::VariableExpr { fn interpret(&self, world: &mut World) -> Result { match world.get_var(&self.var_name) { Some(v) => Ok(v.clone()), diff --git a/src/interpreter/types.rs b/src/interpreter/types.rs index a942eb3..10ac1f4 100644 --- a/src/interpreter/types.rs +++ b/src/interpreter/types.rs @@ -1,4 +1,4 @@ -use crate::ast::expression::expression_node; +use crate::ast::expression; use from_variants::FromVariants; #[derive(Debug, PartialEq, PartialOrd, Clone, FromVariants)] @@ -11,11 +11,11 @@ pub enum Value { String(String), } -impl From for Value { - fn from(l: expression_node::Literal) -> Self { +impl From for Value { + fn from(l: expression::Literal) -> Self { match_any::match_any!(l, - expression_node::Literal::Int(v) | expression_node::Literal::Bool(v) | expression_node::Literal::Float(v) | expression_node::Literal::String(v) => v.into(), - expression_node::Literal::Nil => Self::Nil + expression::Literal::Int(v) | expression::Literal::Bool(v) | expression::Literal::Float(v) | expression::Literal::String(v) => v.into(), + expression::Literal::Nil => Self::Nil ) } }