refactor: refactor more expressions and statements

Author: LynithDev

packages/engine/src/lexer/mod.rs

@@ -1,7 +1,7 @@
 use std::{iter::Peekable, str::Chars};
 
 use error::LexerResult;
-use tokens::{LexerLiteral, LexerToken, LexerTokenKind, LexerTokenList};
+use tokens::{LexerTokenValue, LexerToken, LexerTokenKind, LexerTokenList};
 
 use crate::{
     component::{ComponentErrors, ComponentIter}, constants::{MAX_I32_LEN, MAX_I64_LEN}, cursor::Cursor, error::{EngineErrorKind, ErrorList}, parser::expr::ShellCommand
@@ -93,7 +93,7 @@ impl<'a> Lexer<'a> {
     fn scan_char(
         &mut self,
         char: &char,
-    ) -> LexerResult<Option<(LexerTokenKind, Option<Box<LexerLiteral>>)>> {
+    ) -> LexerResult<Option<(LexerTokenKind, Option<Box<LexerTokenValue>>)>> {
         macro_rules! check_double {
             ($single_type:expr, $double:tt, $double_type:expr) => {
                 if self.next_if_eq(&$double).is_some() {
@@ -142,7 +142,7 @@ impl<'a> Lexer<'a> {
                             return Ok(None);
                         };
 
-                        return Ok(Some((Integer, Some(Box::from(LexerLiteral::Integer(-self.eat_number(char)?))))));
+                        return Ok(Some((Integer, Some(Box::from(LexerTokenValue::Integer(-self.eat_number(char)?))))));
                     }
                     _ => Minus,
                 },
@@ -187,7 +187,7 @@ impl<'a> Lexer<'a> {
                 '0'..='9' => {
                     return Ok(Some((
                         Integer,
-                        Some(Box::from(LexerLiteral::Integer(self.eat_number(*char)?))),
+                        Some(Box::from(LexerTokenValue::Integer(self.eat_number(*char)?))),
                     )))
                 }
                 '"' => return Ok(Some(self.consume_string()?)),
@@ -219,10 +219,10 @@ impl<'a> Lexer<'a> {
                         "and" => And,
                         "or" => Or,
 
-                        "true" => return Ok(Some((Boolean, Some(Box::from(LexerLiteral::Boolean(true)))))),
-                        "false" => return Ok(Some((Boolean, Some(Box::from(LexerLiteral::Boolean(false)))))),
+                        "true" => return Ok(Some((Boolean, Some(Box::from(LexerTokenValue::Boolean(true)))))),
+                        "false" => return Ok(Some((Boolean, Some(Box::from(LexerTokenValue::Boolean(false)))))),
 
-                        _ if Self::is_valid_identifier(char) => return Ok(Some((Identifier, Some(Box::from(LexerLiteral::Identifier(Box::from(word))))))),
+                        _ if Self::is_valid_identifier(char) => return Ok(Some((Identifier, Some(Box::from(LexerTokenValue::Identifier(Box::from(word))))))),
                         _ => return Err(LexerErrorKind::UnknownToken),
                     }
                 }
@@ -234,7 +234,7 @@ impl<'a> Lexer<'a> {
     fn add_token(
         &mut self,
         token_type: LexerTokenKind,
-        value: Option<Box<LexerLiteral>>,
+        value: Option<Box<LexerTokenValue>>,
         start: Cursor,
     ) {
         self.tokens.push(LexerToken {
@@ -279,7 +279,7 @@ impl<'a> Lexer<'a> {
     }
 
     /// Attempts to return a [`TokenType::String`]
-    fn consume_string(&mut self) -> LexerResult<(LexerTokenKind, Option<Box<LexerLiteral>>)> {
+    fn consume_string(&mut self) -> LexerResult<(LexerTokenKind, Option<Box<LexerTokenValue>>)> {
         let string = self.eat_until(&['"', '\n'], true).unwrap_or_default();
 
         if let Err(err) = self.expect_char(&'"') {
@@ -292,14 +292,14 @@ impl<'a> Lexer<'a> {
 
         Ok((
             LexerTokenKind::String,
-            Some(Box::from(LexerLiteral::String(Box::from(string)))),
+            Some(Box::from(LexerTokenValue::String(Box::from(string)))),
         ))
     }
 
     /// Attempts to return a [`TokenType::ShellCommand`]
     fn consume_shell_command(
         &mut self,
-    ) -> LexerResult<(LexerTokenKind, Option<Box<LexerLiteral>>)> {
+    ) -> LexerResult<(LexerTokenKind, Option<Box<LexerTokenValue>>)> {
         let cmd_name = self
             .eat_until(&[' ', '\t', '\n', '('], false)
             .ok_or(LexerErrorKind::UnexpectedEnd)?;
@@ -323,7 +323,7 @@ impl<'a> Lexer<'a> {
 
         Ok((
             LexerTokenKind::ShellCommand,
-            Some(Box::from(LexerLiteral::ShellCommand(Box::from(ShellCommand(cmd_name, cmd_args))))),
+            Some(Box::from(LexerTokenValue::ShellCommand(Box::from(ShellCommand(cmd_name, cmd_args))))),
         ))
     }
 

packages/engine/src/lexer/tokens.rs

@@ -121,7 +121,7 @@ impl Display for LexerTokenKind {
 }
 
 #[derive(Debug, PartialEq, Eq, Clone)]
-pub enum LexerLiteral {
+pub enum LexerTokenValue {
     Identifier(Box<String>),
     /// `"..."`
     String(Box<String>),
@@ -133,40 +133,25 @@ pub enum LexerLiteral {
     ShellCommand(Box<ShellCommand>),
 }
 
-impl LexerLiteral {
+impl LexerTokenValue {
     pub fn as_identifier(&self) -> Option<&String> {
-        match self {
-            Self::Identifier(identifier) => Some(identifier),
-            _ => None,
-        }
+        self.try_into().ok()
     }
 
     pub fn as_string(&self) -> Option<&String> {
-        match self {
-            Self::String(string) => Some(string),
-            _ => None,
-        }
+        self.try_into().ok()
     }
 
     pub fn as_integer(&self) -> Option<&isize> {
-        match self {
-            Self::Integer(int) => Some(int),
-            _ => None,
-        }
+        self.try_into().ok()
     }
 
     pub fn as_boolean(&self) -> Option<&bool> {
-        match self {
-            Self::Boolean(bool) => Some(bool),
-            _ => None,
-        }
+        self.try_into().ok()
     }
 
     pub fn as_shell_command(&self) -> Option<&ShellCommand> {
-        match self {
-            Self::ShellCommand(cmd) => Some(cmd),
-            _ => None,
-        }
+        self.try_into().ok()
     }
 }
 
@@ -175,58 +160,41 @@ pub struct LexerToken {
     pub kind: LexerTokenKind,
     pub start: Cursor,
     pub end: Cursor,
-    pub value: Option<Box<LexerLiteral>>,
+    pub value: Option<Box<LexerTokenValue>>,
 }
 
-impl LexerToken {
-    pub fn as_identifier(&self) -> EngineResult<&String> {
-        self.value
+macro_rules! as_value {
+    ($self:expr, $token:expr, |$v:ident| => $exp:expr) => {
+        $self.value
             .as_ref()
-            .and_then(|v| v.as_identifier())
+            .and_then(|$v| $exp)
             .ok_or(EngineErrorKind::LiteralExtractionError(
-                LexerTokenKind::Identifier, 
-                self.kind.clone(),
+                $token, 
+                $self.kind.clone(),
             ))
+    };
+}
+
+impl LexerToken {
+
+    pub fn as_identifier(&self) -> EngineResult<&String> {
+        as_value!(self, LexerTokenKind::Identifier, |v| => v.as_identifier())
     }
 
     pub fn as_string(&self) -> EngineResult<&String> {
-        self.value
-            .as_ref()
-            .and_then(|v| v.as_string())
-            .ok_or(EngineErrorKind::LiteralExtractionError(
-                LexerTokenKind::String,
-                self.kind.clone(),
-            ))
+        as_value!(self, LexerTokenKind::String, |v| => v.as_string())
     }
 
     pub fn as_integer(&self) -> EngineResult<&isize> {
-        self.value
-            .as_ref()
-            .and_then(|v| v.as_integer())
-            .ok_or(EngineErrorKind::LiteralExtractionError(
-                LexerTokenKind::Integer,
-                self.kind.clone(),
-            ))
+        as_value!(self, LexerTokenKind::Identifier, |v| => v.as_identifier())
     }
 
     pub fn as_boolean(&self) -> EngineResult<&bool> {
-        self.value
-            .as_ref()
-            .and_then(|v| v.as_boolean())
-            .ok_or(EngineErrorKind::LiteralExtractionError(
-                LexerTokenKind::Boolean,
-                self.kind.clone(),
-            ))
+        as_value!(self, LexerTokenKind::Boolean, |v| => v.as_boolean())
     }
 
     pub fn as_shell_command(&self) -> EngineResult<&ShellCommand> {
-        self.value
-            .as_ref()
-            .and_then(|v| v.as_shell_command())
-            .ok_or(EngineErrorKind::LiteralExtractionError(
-                LexerTokenKind::ShellCommand,
-                self.kind.clone(),
-            ))
+        as_value!(self, LexerTokenKind::ShellCommand, |v| => v.as_shell_command())
     }
 }
 

packages/engine/src/parser/expr/assignment_expr.rs

@@ -1,10 +1,41 @@
-use crate::{lexer::tokens::LexerTokenKind, parser::ParserErrorKind};
+use crate::{component::ComponentIter, lexer::tokens::LexerTokenKind, parser::{ast::Parse, expr::Literal, ParserErrorKind}};
 
-use super::Expression;
+use super::{Expression, ExpressionKind};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Assignment(pub Expression, pub AssignmentOperator, pub Expression);
 
+impl Parse<ExpressionKind> for Assignment {
+    fn parse(parser: &mut crate::parser::Parser) -> crate::parser::ParserResult<ExpressionKind> {
+        let lhs = parser.expr_logic_or()?;
+
+        if let Some(op_token) = parser.next_if_eq_mul(&[
+            &LexerTokenKind::Equal,
+            &LexerTokenKind::PlusEqual,
+            &LexerTokenKind::MinusEqual,
+            &LexerTokenKind::MultiplyEqual,
+            &LexerTokenKind::DivideEqual,
+        ]) {
+            let rhs = parser.expr_logic_or()?;
+
+            if let ExpressionKind::Literal(Literal::Identifier(identifier)) = lhs
+            {
+                let operator: AssignmentOperator = op_token.kind.clone().try_into()?;
+
+                return Ok(
+                    ExpressionKind::Assignment(Assignment(
+                        lhs,
+                        operator,
+                        rhs,
+                    )),
+                );
+            }
+        }
+
+        Ok(lhs)
+    }
+}
+
 #[derive(lang_macro::EnumVariants, Debug, Clone, Copy, PartialEq, Eq)]
 pub enum AssignmentOperator {
     PlusAssign,

packages/engine/src/parser/expr/binary/mod.rs

@@ -0,0 +1,5 @@
+use super::Expression;
+
+pub trait BinaryOp {
+    fn set_left()
+}

packages/engine/src/parser/expr/block_expr.rs

@@ -1,4 +1,28 @@
-use crate::parser::stmt::Statement;
+use crate::{component::ComponentIter, lexer::tokens::LexerTokenKind, parser::{ast::Parse, stmt::Statement}};
+
+use super::ExpressionKind;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Block(pub Vec<Statement>);
+pub struct Block(pub Vec<Statement>);
+
+impl Parse<ExpressionKind> for Block {
+    fn parse(parser: &mut crate::parser::Parser) -> crate::parser::ParserResult<ExpressionKind> {
+        parser.expect_terminator()?;
+
+        let mut statements = vec![];
+
+        while let Some(token) = parser.peek().cloned() {
+            if token.kind == LexerTokenKind::RBracket {
+                parser.next();
+                break;
+            }
+
+            let statement = parser.parse_statement(token)?;
+            statements.push(statement);
+
+            parser.next();
+        }
+
+        Ok(ExpressionKind::Block(Block(statements)))
+    }
+}

packages/engine/src/parser/expr/function_call_expr.rs

@@ -1,4 +1,4 @@
-use super::{literal::identifier::IdentifierLiteral, Expression};
+use super::{Expression, Identifier};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct FunctionCall(pub IdentifierLiteral, pub Vec<Expression>);
+pub struct FunctionCall(pub Identifier, pub Vec<Expression>);

packages/engine/src/parser/expr/literal/identifier.rs renamed to packages/engine/src/parser/expr/identifier.rs

@@ -1,9 +1,9 @@
 use crate::{lexer::tokens::LexerToken, parser::ParserErrorKind};
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct IdentifierLiteral(String);
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct Identifier(String);
 
-impl TryFrom<LexerToken> for IdentifierLiteral {
+impl TryFrom<LexerToken> for Identifier {
     type Error = ParserErrorKind;
 
     fn try_from(value: LexerToken) -> Result<Self, Self::Error> {

packages/engine/src/parser/expr/if_expr.rs

@@ -1,4 +1,48 @@
-use super::{Block, else_expr::ElseExpr, Expression};
+use crate::{component::ComponentIter, lexer::tokens::LexerTokenKind, parser::{ast::Parse, ParserErrorKind}};
+
+use super::{else_expr::ElseExpr, Block, Expression, ExpressionKind};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct IfExpr(pub Expression, pub Block, pub Option<ElseExpr>);
+pub struct IfExpr(pub Expression, pub Block, pub Option<ElseExpr>);
+
+impl Parse<ExpressionKind> for IfExpr {
+    fn parse(parser: &mut crate::parser::Parser) -> crate::parser::ParserResult<ExpressionKind> {
+        let condition = parser.expression()?;
+
+        let start = parser.cursor;
+
+        let truthy_block = if parser.next_if_eq(&&LexerTokenKind::LBracket).is_some() {
+            parser.stmt_block()?
+        } 
+        // TODO:
+        // else if parser.next_if_eq(&&LexerTokenKind::Colon).is_some() {
+        //     parser.parse_inline_block()?
+        // } 
+        else {
+            return Err(ParserErrorKind::ExpectedExpression);
+        };
+
+        let else_condition = if parser.next_if_eq(&&LexerTokenKind::Else).is_some() {
+            let start = parser.cursor;
+
+            Some(match parser.peek().map(|t| t.kind.clone()) {
+                Some(LexerTokenKind::LBracket) => {
+                    parser.next();
+                    parser.stmt_block()?
+                }
+                // Some(LexerTokenKind::Colon) => {
+                //     parser.next();
+                //     parser.parse_inline_block()?
+                // }
+                _ => {
+                    let stmt = parser.stmt_if()?;
+                    vec![stmt]
+                }
+            })
+        } else {
+            None
+        };
+
+        Ok(ExpressionKind::If((condition, truthy_block, else_condition)))
+    }
+}