refactor: refactor more expressions and statements

Author: LynithDev

packages/engine/src/lexer/tokens.rs

@@ -135,23 +135,38 @@ pub enum LexerTokenValue {
 
 impl LexerTokenValue {
     pub fn as_identifier(&self) -> Option<&String> {
-        self.try_into().ok()
+        match self {
+            Self::Identifier(identifier) => Some(identifier),
+            _ => None,
+        }
     }
 
     pub fn as_string(&self) -> Option<&String> {
-        self.try_into().ok()
+        match self {
+            Self::String(string) => Some(string),
+            _ => None,
+        }
     }
 
     pub fn as_integer(&self) -> Option<&isize> {
-        self.try_into().ok()
+        match self {
+            Self::Integer(int) => Some(int),
+            _ => None,
+        }
     }
 
     pub fn as_boolean(&self) -> Option<&bool> {
-        self.try_into().ok()
+        match self {
+            Self::Boolean(bool) => Some(bool),
+            _ => None,
+        }
     }
 
     pub fn as_shell_command(&self) -> Option<&ShellCommand> {
-        self.try_into().ok()
+        match self {
+            Self::ShellCommand(cmd) => Some(cmd),
+            _ => None,
+        }
     }
 }
 
@@ -186,7 +201,7 @@ impl LexerToken {
     }
 
     pub fn as_integer(&self) -> EngineResult<&isize> {
-        as_value!(self, LexerTokenKind::Identifier, |v| => v.as_identifier())
+        as_value!(self, LexerTokenKind::Identifier, |v| => v.as_integer())
     }
 
     pub fn as_boolean(&self) -> EngineResult<&bool> {

packages/engine/src/lib.rs

@@ -11,7 +11,6 @@ use component::ComponentErrors;
 use error::EngineResult;
 use lexer::Lexer;
 use parser::Parser;
-use transpiler::Transpiler;
 
 pub mod component;
 pub mod constants;
@@ -76,8 +75,8 @@ impl Engine {
         parser.parse();
         parser.print_errors();
 
-        let mut transpiler = Transpiler::create(&transpiler::TranspilerTarget::Bash, parser.parse());
-        println!("---START---\n{}\n---END---", transpiler.transpile());
+        // let mut transpiler = Transpiler::create(&transpiler::TranspilerTarget::Bash, parser.parse());
+        // println!("---START---\n{}\n---END---", transpiler.transpile());
 
 
         Ok(0)

packages/engine/src/parser/ast.rs

@@ -1,7 +1,83 @@
-use super::{stmt::Statement, Parser, ParserResult};
+use super::{expr::ExpressionKind, stmt::{Statement, StatementKind}, Parser, ParserResult};
 
 pub type ProgramTree = Vec<Statement>;
 
 pub trait Parse<T> {
-    fn parse(parser: &mut Parser) -> ParserResult<T>;
+    fn parse(parser: &mut Parser) -> ParserResult<Option<T>>;
+}
+
+#[macro_export]
+macro_rules! parseable {
+    ($name:ident = |$parser:ident| $body:block) => {
+        impl $crate::parser::ast::Parse<$name> for $name {
+            fn parse($parser: &mut $crate::parser::Parser) -> $crate::parser::ParserResult<Option<$name>> {
+                #[allow(unused_imports)]
+                use $crate::{component::ComponentIter, lexer::tokens::LexerTokenKind, parser::{expr::ExpressionKind, stmt::StatementKind, ParserErrorKind}};
+                
+                $body
+            }
+        }
+    };
+}
+
+#[macro_export]
+macro_rules! parse {
+    ($parser:expr, $expr:ident = $name:ty) => {
+        let Some($expr) = <$name>::parse($parser)? else {
+            return Ok(None);
+        };
+    };
+}
+
+#[macro_export]
+macro_rules! ast {
+    ($name:ident { $($param_k:ident: $param_v:ty),* $(,)* }) => {
+        #[derive(Debug, Clone, PartialEq, Eq)]
+        pub struct $name {
+            $(pub $param_k: $param_v),*
+        }
+    };
+
+    ($name:ident($($param:ty),*) $(,)*) => {
+        #[derive(Debug, Clone, PartialEq, Eq)]
+        pub struct $name($(pub $param),*);
+    };
+}
+
+pub trait ToExpression {
+    fn as_expr(self) -> ExpressionKind;
+}
+
+#[macro_export]
+macro_rules! as_expr {
+    ($name:ident) => {
+        $crate::as_expr!($name = $name);
+    };
+
+    ($name:ident = $kind:ident) => {
+        impl $crate::parser::ast::ToExpression for $name {
+            fn as_expr(self) -> $crate::parser::expr::ExpressionKind {
+                $crate::parser::expr::ExpressionKind::$kind(self)
+            }
+        }
+    };
+}
+
+pub trait ToStatement {
+    fn as_stmt(self) -> StatementKind;
+}
+
+#[macro_export]
+macro_rules! as_stmt {
+    ($name:ident) => {
+        $crate::as_stmt!($name = $name);
+    };
+
+    ($name:ident = $kind:ident) => {
+        impl $crate::parser::ast::ToStatement for $name {
+            fn as_stmt(self) -> $crate::parser::stmt::StatementKind {
+                $crate::parser::stmt::StatementKind::$kind(self)
+            }
+        }
+    };
 }

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

@@ -1,38 +1,37 @@
-use crate::{component::ComponentIter, lexer::tokens::LexerTokenKind, parser::{ast::Parse, expr::Literal, ParserErrorKind}};
+use crate::{as_expr, ast, lexer::tokens::LexerTokenKind, parseable, parser::{expr::Identifier, ParserErrorKind}};
 
-use super::{Expression, ExpressionKind};
+use super::Expression;
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Assignment(pub Expression, pub AssignmentOperator, pub Expression);
+ast!(Assignment(Expression, AssignmentOperator, Expression));
+as_expr!(Assignment);
 
-impl Parse<ExpressionKind> for Assignment {
-    fn parse(parser: &mut crate::parser::Parser) -> crate::parser::ParserResult<ExpressionKind> {
+parseable! {
+    Assignment = |parser| {
         let lhs = parser.expr_logic_or()?;
 
-        if let Some(op_token) = parser.next_if_eq_mul(&[
+        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)
+        ]) else {
+            return Ok(None);
+        };
+
+        let rhs = parser.expr_logic_or()?;
+
+        let ExpressionKind::Identifier(Identifier(identifier)) = lhs else {
+            return Ok(None);
+        };
+
+        let operator: AssignmentOperator = op_token.kind.clone().try_into()?;
+
+        Ok(Some(Assignment(
+            lhs,
+            operator,
+            rhs,
+        )))
     }
 }
 

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

@@ -1,12 +1,10 @@
-use crate::{component::ComponentIter, lexer::tokens::LexerTokenKind, parser::{ast::Parse, stmt::Statement}};
+use crate::{as_expr, ast, parseable, parser::stmt::Statement};
 
-use super::ExpressionKind;
+ast!(Block(Vec<Statement>)); 
+as_expr!(Block);
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Block(pub Vec<Statement>);
-
-impl Parse<ExpressionKind> for Block {
-    fn parse(parser: &mut crate::parser::Parser) -> crate::parser::ParserResult<ExpressionKind> {
+parseable! {
+    Block = |parser| {
         parser.expect_terminator()?;
 
         let mut statements = vec![];
@@ -23,6 +21,6 @@ impl Parse<ExpressionKind> for Block {
             parser.next();
         }
 
-        Ok(ExpressionKind::Block(Block(statements)))
+        Ok(Some(Block(statements)))
     }
-}
+}

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

@@ -1,4 +1,42 @@
+use crate::{as_expr, ast, parseable};
+
 use super::{Expression, Identifier};
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct FunctionCall(pub Identifier, pub Vec<Expression>);
+ast!(FunctionCall(Identifier, Vec<Expression>));
+as_expr!(FunctionCall);
+
+parseable! {
+    FunctionCall = |parser| {
+        let expr = parser.expr_primary()?;
+
+        let ExpressionKind::Identifier(identifier) = &expr.value else {
+            return Ok(None);
+        };
+
+        if parser.next_if_eq(&&LexerTokenKind::LParen).is_none() {
+            return Ok(None);
+        }
+
+        let mut args = vec![];
+        let mut end = parser.cursor;
+
+        while let Some(token) = parser.peek() {
+            dbg!(token);
+
+            if parser.next_if_eq(&&LexerTokenKind::RParen).is_some() {
+                end = parser.cursor;
+                break;
+            }
+
+            if parser.next_if_eq(&&LexerTokenKind::Comma).is_some() {
+                continue;
+            }
+
+            let arg = parser.expression()?;
+
+            args.push(arg);
+        }
+
+        Ok(Some(FunctionCall(identifier, args)))
+    }
+}

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

@@ -1,4 +1,18 @@
+use crate::{as_expr, ast, parseable};
+
 use super::Expression;
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Group(pub Expression);
+ast!(Group(Expression));
+as_expr!(Group);
+
+parseable! {
+    Group = |parser| {
+        let mut expr = parser.expression()?;
+
+        parser.expect_token(&LexerTokenKind::RParen)?;
+
+        expr.value = ExpressionKind::Group(expr.value);
+
+        Ok(expr)
+    }
+}