no idea

Author: LynithDev

packages/engine/src/parser/ast.rs

@@ -44,38 +44,38 @@ macro_rules! ast {
     };
 }
 
-pub trait ToExpression {
-    fn as_expr(self) -> ExpressionKind;
+pub trait ToExpressionKind {
+    fn as_expr_kind(self) -> ExpressionKind;
 }
 
 #[macro_export]
-macro_rules! as_expr {
+macro_rules! to_expr_kind {
     ($name:ident) => {
-        $crate::as_expr!($name = $name);
+        $crate::to_expr_kind!($name = $name);
     };
 
     ($name:ident = $kind:ident) => {
-        impl $crate::parser::ast::ToExpression for $name {
-            fn as_expr(self) -> $crate::parser::expr::ExpressionKind {
+        impl $crate::parser::ast::ToExpressionKind for $name {
+            fn as_expr_kind(self) -> $crate::parser::expr::ExpressionKind {
                 $crate::parser::expr::ExpressionKind::$kind(self)
             }
         }
     };
 }
 
-pub trait ToStatement {
-    fn as_stmt(self) -> StatementKind;
+pub trait ToStatementKind {
+    fn as_stmt_kind(self) -> StatementKind;
 }
 
 #[macro_export]
-macro_rules! as_stmt {
+macro_rules! as_stmt_kind {
     ($name:ident) => {
-        $crate::as_stmt!($name = $name);
+        $crate::as_stmt_kind!($name = $name);
     };
 
     ($name:ident = $kind:ident) => {
-        impl $crate::parser::ast::ToStatement for $name {
-            fn as_stmt(self) -> $crate::parser::stmt::StatementKind {
+        impl $crate::parser::ast::ToStatementKind for $name {
+            fn as_stmt_kind(self) -> $crate::parser::stmt::StatementKind {
                 $crate::parser::stmt::StatementKind::$kind(self)
             }
         }

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

@@ -1,9 +1,9 @@
-use crate::{lexer::tokens::LexerTokenKind, parser::ParserErrorKind};
+use crate::{to_expr_kind, ast, lexer::tokens::LexerTokenKind, parser::ParserErrorKind};
 
 use super::Expression;
 
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Arithmetic(pub Expression, pub ArithmeticOperator, pub Expression);
+ast!(Arithmetic(Expression, ArithmeticOperator, Expression));
+to_expr_kind!(Arithmetic);
 
 #[derive(lang_macro::EnumVariants, Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ArithmeticOperator {

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

@@ -1,9 +1,9 @@
-use crate::{as_expr, ast, lexer::tokens::LexerTokenKind, parseable, parser::{expr::Identifier, ParserErrorKind}};
+use crate::{to_expr_kind, ast, lexer::tokens::LexerTokenKind, parseable, parser::{expr::Identifier, ParserErrorKind}};
 
 use super::Expression;
 
 ast!(Assignment(Expression, AssignmentOperator, Expression));
-as_expr!(Assignment);
+to_expr_kind!(Assignment);
 
 parseable! {
     Assignment = |parser| {

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

@@ -0,0 +1,44 @@
+use crate::{to_expr_kind, ast, parse, parse_bin_op, parseable, parser::{ast::ToExpressionKind, expr::{bin_op::BinOp, Expression, Or}}};
+
+ast!(And(Expression, Expression));
+to_expr_kind!(And);
+
+parse_bin_op! {
+    And = |parser| {
+        left = {
+            todo!();
+        }
+
+        right = {
+            todo!();
+        }
+    }
+}
+
+parseable! {
+    And = |parser| {
+        parse!(parser, lhs = Or);
+        parse!(parser, rhs = Or);
+        Ok(Some(And(lhs.as_expr_kind(), rhs.as_expr_kind())))
+    }
+}
+
+// let_expr!(mut lhs = self.expr_logic_and()?);
+
+// while let Some(token_or) = self.next_if_eq(&&LexerTokenKind::Or) {
+//     let_expr!(rhs = self.expr_logic_and()?);
+
+//     let operator: LogicalOperator = LogicalOperator::Or;
+
+//     lhs = WithCursor::create_with(
+//         lhs.start,
+//         rhs.end,
+//         ExpressionKind::Logic(Box::from((
+//             lhs,
+//             WithCursor::create_with(token_or.start, token_or.end, operator),
+//             rhs,
+//         ))),
+//     );
+// }
+
+// Ok(Some(lhs))

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

@@ -0,0 +1,32 @@
+use crate::parser::{Parser, ParserResult};
+
+use super::Expression;
+
+pub mod or_op;
+pub mod and_op;
+
+pub trait BinOp<T> {
+    fn parse_left(parser: &mut Parser) -> ParserResult<Option<Expression>>;
+    fn parse_right(parser: &mut Parser) -> ParserResult<Option<Expression>>;
+}
+
+#[macro_export]
+macro_rules! parse_bin_op {
+    ($name:ident = |$parser:ident| { left = $parse_left:block right = $parse_right:block }) => {
+        impl $crate::parser::expr::bin_op::BinOp<$name> for $name {
+            fn parse_left($parser: &mut $crate::parser::Parser) -> $crate::parser::ParserResult<Option<Expression>> {
+                #[allow(unused_imports)]
+                use $crate::{component::ComponentIter, lexer::tokens::LexerTokenKind, parser::{expr::ExpressionKind, stmt::StatementKind, ParserErrorKind}};
+                
+                $parse_left
+            }
+
+            fn parse_right($parser: &mut $crate::parser::Parser) -> $crate::parser::ParserResult<Option<Expression>> {
+                #[allow(unused_imports)]
+                use $crate::{component::ComponentIter, lexer::tokens::LexerTokenKind, parser::{expr::ExpressionKind, stmt::StatementKind, ParserErrorKind}};
+                
+                $parse_right
+            }
+        }
+    };
+}

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

@@ -0,0 +1,44 @@
+use crate::{to_expr_kind, ast, parse, parse_bin_op, parseable, parser::{ast::Parse, expr::{bin_op::{and_op::And, BinOp}, Expression}}};
+
+ast!(Or(Expression, Expression));
+to_expr_kind!(Or);
+
+parse_bin_op! {
+    Or = |parser| {
+        left = {
+            And::parse(parser)
+        }
+
+        right = {
+            parser.expr_logic_and()
+        }
+    }
+}
+
+parseable! {
+    Or = |parser| {
+        let lhs = Or::parse_left(parser);
+        parse!(parser, rhs = And);
+        Ok(Some(Or(lhs, rhs)))
+    }
+}
+
+// let_expr!(mut lhs = self.expr_logic_and()?);
+
+// while let Some(token_or) = self.next_if_eq(&&LexerTokenKind::Or) {
+//     let_expr!(rhs = self.expr_logic_and()?);
+
+//     let operator: LogicalOperator = LogicalOperator::Or;
+
+//     lhs = WithCursor::create_with(
+//         lhs.start,
+//         rhs.end,
+//         ExpressionKind::Logic(Box::from((
+//             lhs,
+//             WithCursor::create_with(token_or.start, token_or.end, operator),
+//             rhs,
+//         ))),
+//     );
+// }
+
+// Ok(Some(lhs))

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

@@ -1,7 +1,7 @@
-use crate::{as_expr, ast, parseable, parser::stmt::Statement};
+use crate::{to_expr_kind, ast, parseable, parser::stmt::Statement};
 
 ast!(Block(Vec<Statement>)); 
-as_expr!(Block);
+to_expr_kind!(Block);
 
 parseable! {
     Block = |parser| {

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

@@ -1,9 +1,9 @@
-use crate::{as_expr, ast, parseable};
+use crate::{to_expr_kind, ast, parseable};
 
 use super::{Expression, Identifier};
 
 ast!(FunctionCall(Identifier, Vec<Expression>));
-as_expr!(FunctionCall);
+to_expr_kind!(FunctionCall);
 
 parseable! {
     FunctionCall = |parser| {

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

@@ -1,9 +1,9 @@
-use crate::{as_expr, ast, parseable};
+use crate::{to_expr_kind, ast, parseable};
 
 use super::Expression;
 
 ast!(Group(Expression));
-as_expr!(Group);
+to_expr_kind!(Group);
 
 parseable! {
     Group = |parser| {

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

@@ -1,7 +1,7 @@
-use crate::{as_expr, ast, lexer::tokens::LexerToken, parser::ParserErrorKind};
+use crate::{to_expr_kind, ast, lexer::tokens::LexerToken, parser::ParserErrorKind};
 
 ast!(Identifier(String));
-as_expr!(Identifier);
+to_expr_kind!(Identifier);
 
 impl TryFrom<LexerToken> for Identifier {
     type Error = ParserErrorKind;