refactor: refactor parser ast into separate modules

Author: LynithDev

packages/cli/src/main.rs

@@ -11,7 +11,7 @@ fn main() {
 
     debug!("initialized logger");
 
-    let mut engine = Engine::default();
+    let mut engine = Engine::create();
 
 
     let args: Vec<String> = std::env::args().collect();

packages/engine/src/lexer/mod.rs

@@ -4,10 +4,7 @@ use error::LexerResult;
 use tokens::{LexerLiteral, LexerToken, LexerTokenKind, LexerTokenList};
 
 use crate::{
-    component::{ComponentErrors, ComponentIter},
-    constants::{MAX_I32_LEN, MAX_I64_LEN},
-    error::{EngineErrorKind, ErrorList},
-    cursor::Cursor,
+    component::{ComponentErrors, ComponentIter}, constants::{MAX_I32_LEN, MAX_I64_LEN}, cursor::Cursor, error::{EngineErrorKind, ErrorList}, parser::expr::ShellCommand
 };
 
 pub use error::{LexerError, LexerErrorKind};
@@ -326,7 +323,7 @@ impl<'a> Lexer<'a> {
 
         Ok((
             LexerTokenKind::ShellCommand,
-            Some(Box::from(LexerLiteral::ShellCommand(Box::from((cmd_name, cmd_args))))),
+            Some(Box::from(LexerLiteral::ShellCommand(Box::from(ShellCommand(cmd_name, cmd_args))))),
         ))
     }
 

packages/engine/src/lexer/tokens.rs

@@ -3,8 +3,7 @@ use std::fmt::Display;
 use lang_macro::EnumVariantsTrait;
 
 use crate::{
-    error::{EngineErrorKind, EngineResult},
-    cursor::Cursor,
+    cursor::Cursor, error::{EngineErrorKind, EngineResult}, parser::expr::ShellCommand
 };
 
 #[repr(u8)]
@@ -171,8 +170,6 @@ impl LexerLiteral {
     }
 }
 
-pub type ShellCommand = (String, Option<String>);
-
 #[derive(Debug, PartialEq, Clone)]
 pub struct LexerToken {
     pub kind: LexerTokenKind,

packages/engine/src/lib.rs

@@ -1,26 +1,26 @@
 #![allow(incomplete_features)]
 #![feature(try_blocks)]
 #![feature(guard_patterns)]
+#![feature(trait_alias)]
 
 #[macro_use]
 extern crate log;
 
 use std::path::PathBuf;
-
 use component::ComponentErrors;
 use error::EngineResult;
 use lexer::Lexer;
+use parser::Parser;
+use transpiler::Transpiler;
 
 pub mod component;
 pub mod constants;
 pub mod cursor;
 pub mod error;
 pub mod lexer;
 pub mod parser;
+pub mod transpiler;
 
-use parser::Parser;
-
-#[derive(Default)]
 pub struct Engine {}
 
 impl Engine {
@@ -73,12 +73,12 @@ impl Engine {
             source_file,
         );
 
-        let ast = parser.parse();
-        
-        println!("{:#?}", &ast);
-
+        parser.parse();
         parser.print_errors();
 
+        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,186 +1,7 @@
-use std::{collections::HashMap, fmt::Debug, rc::Rc};
+use super::{stmt::Statement, Parser, ParserResult};
 
-use crate::{cursor::WithCursor, lexer::tokens::{LexerToken, LexerTokenKind, ShellCommand}};
+pub type ProgramTree = Vec<Statement>;
 
-use super::ParserErrorKind;
-
-#[derive(lang_macro::EnumVariants, Debug, Clone, PartialEq, Eq)]
-pub enum Expression {
-    Literal(Box<Literal>),
-    Group(Box<Expression>),
-    Unary(Box<(WithCursor<UnaryOperator>, WithCursor<Expression>)>),
-    Arithmetic(Box<(WithCursor<Expression>, WithCursor<ArithmeticOperator>, WithCursor<Expression>)>),
-    Logical(Box<(WithCursor<Expression>, WithCursor<LogicalOperator>, WithCursor<Expression>)>),
-    Assignment(Box<(WithCursor<Expression>, WithCursor<AssignmentOperator>, WithCursor<Expression>)>),
-    Range(Box<(WithCursor<Expression>, WithCursor<Expression>, bool)>),
-    ShellCommand(Box<ShellCommand>),
-    Identifier(Box<Identifier>),
-    FunctionCall(Box<(Identifier, Vec<WithCursor<Expression>>)>),
-    If(Box<(WithCursor<Expression>, WithCursor<Block>, Option<Else>)>),
-    Match(Box<(WithCursor<Expression>, MatchCase)>),
-    Block(Box<Block>),
-}
-
-pub type Else = WithCursor<Block>;
-pub type MatchCase = HashMap<WithCursor<Literal>, Rc<WithCursor<Expression>>>;
-
-
-#[derive(lang_macro::EnumVariants, Debug, Clone, PartialEq, Eq)]
-pub enum Statement {
-    While(Box<(WithCursor<Expression>, WithCursor<Block>)>),
-    For(Box<(Variable, WithCursor<Expression>, WithCursor<Block>)>),
-    Return(Box<Option<WithCursor<Expression>>>),
-    If(Box<WithCursor<Expression>>),
-    Match(Box<WithCursor<Expression>>),
-    Expression(Box<WithCursor<Expression>>),
-    Continue,
-    Break,
-    Variable(Box<Variable>),
-    Constant(Box<Variable>),
-    Function(Box<Function>),
-    Include(Box<String>),
-}
-
-
-
-pub type ProgramTree = Block;
-pub type Identifier = String;
-pub type Block = Vec<Statement>;
-
-#[derive(lang_macro::EnumVariants, Debug, Clone, PartialEq, Eq, Hash)]
-pub enum Literal {
-    Integer(isize),
-    Boolean(bool),
-    String(Box<String>),
-}
-
-impl TryFrom<LexerToken> for Literal {
-    type Error = crate::parser::ParserErrorKind;
-    
-    fn try_from(value: LexerToken) -> Result<Self, Self::Error> {
-        Ok(match value.kind {
-            LexerTokenKind::Integer => Self::Integer(*value.as_integer()?),
-            LexerTokenKind::Boolean => Self::Boolean(*value.as_boolean()?),
-            LexerTokenKind::String => Self::String(Box::from(value.as_string()?.to_owned())),
-            _ => return Err(ParserErrorKind::ConvertError(value.kind))
-        })
-    }
-}
-
-
-
-#[derive(lang_macro::EnumVariants, Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ArithmeticOperator {
-    Add,
-    Subtract,
-    Multiply,
-    Divide,
-}
-
-impl TryFrom<LexerTokenKind> for ArithmeticOperator {
-    type Error = crate::parser::ParserErrorKind;
-    
-    fn try_from(value: LexerTokenKind) -> Result<Self, Self::Error> {
-        Ok(match value {
-            LexerTokenKind::Plus => Self::Add,
-            LexerTokenKind::Minus => Self::Subtract,
-            LexerTokenKind::Multiply => Self::Multiply,
-            LexerTokenKind::Divide => Self::Divide,
-            _ => return Err(ParserErrorKind::ConvertError(value))
-        })
-    }
-}
-
-
-
-#[derive(lang_macro::EnumVariants, Debug, Clone, Copy, PartialEq, Eq)]
-pub enum UnaryOperator {
-    Not,
-    Negative,
-}
-
-impl TryFrom<LexerTokenKind> for UnaryOperator {
-    type Error = crate::parser::ParserErrorKind;
-    
-    fn try_from(value: LexerTokenKind) -> Result<Self, Self::Error> {
-        Ok(match value {
-            LexerTokenKind::Not => Self::Not,
-            LexerTokenKind::Minus => Self::Negative,
-            _ => return Err(ParserErrorKind::ConvertError(value))
-        })
-    }
-}
-
-
-
-#[derive(lang_macro::EnumVariants, Debug, Clone, Copy, PartialEq, Eq)]
-pub enum LogicalOperator {
-    Equal,
-    NotEqual,
-    LesserThan,
-    LesserEqualThan,
-    GreaterThan,
-    GreaterEqualThan,
-    And,
-    Or
-}
-
-impl TryFrom<LexerTokenKind> for LogicalOperator {
-    type Error = crate::parser::ParserErrorKind;
-    
-    fn try_from(value: LexerTokenKind) -> Result<Self, Self::Error> {
-        Ok(match value {
-            LexerTokenKind::EqualEqual => Self::Equal,
-            LexerTokenKind::NotEqual => Self::NotEqual,
-            LexerTokenKind::LesserThan => Self::LesserThan,
-            LexerTokenKind::LesserEqualThan => Self::LesserEqualThan,
-            LexerTokenKind::GreaterThan => Self::GreaterThan,
-            LexerTokenKind::GreaterEqualThan => Self::GreaterEqualThan,
-            LexerTokenKind::And => Self::And,
-            LexerTokenKind::Or => Self::Or,
-            _ => return Err(ParserErrorKind::ConvertError(value))
-        })
-    }
-}
-
-
-#[derive(lang_macro::EnumVariants, Debug, Clone, Copy, PartialEq, Eq)]
-pub enum AssignmentOperator {
-    PlusAssign,
-    MinusAssign,
-    MultiplyAssign,
-    DivideAssign,
-    Assign
-}
-
-impl TryFrom<LexerTokenKind> for AssignmentOperator {
-    type Error = crate::parser::ParserErrorKind;
-    
-    fn try_from(value: LexerTokenKind) -> Result<Self, Self::Error> {
-        Ok(match value {
-            LexerTokenKind::PlusEqual => Self::PlusAssign,
-            LexerTokenKind::MinusEqual => Self::MinusAssign,
-            LexerTokenKind::MultiplyEqual => Self::MultiplyAssign,
-            LexerTokenKind::DivideEqual => Self::DivideAssign,
-            LexerTokenKind::Equal => Self::Assign,
-            _ => return Err(ParserErrorKind::ConvertError(value))
-        })
-    }
-}
-
-
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Function {
-    pub name: String,
-    pub parameters: Option<Vec<Variable>>,
-    pub strict_type: Option<String>,
-    pub body: WithCursor<Block>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Variable {
-    pub name: String,
-    pub strict_type: Option<String>,
-    pub value: Option<WithCursor<Expression>>,
-}
+pub trait Parse<T> {
+    fn parse(parser: &mut Parser) -> ParserResult<T>;
+}

packages/engine/src/parser/error.rs

@@ -30,11 +30,9 @@ pub struct ParserError {
     pub end: Cursor,
 
     #[cfg(feature = "cli")]
-    pub source_file: SourceFile,
+    pub source_file: crate::error::SourceFile,
 }
 
-#[cfg(feature = "cli")]
-pub(super) type SourceFile = Box<(Option<std::path::PathBuf>, String)>;
 pub(super) type ParserResult<T> = std::result::Result<T, ParserErrorKind>;
 
 #[cfg(feature = "cli")]

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

@@ -0,0 +1,28 @@
+use crate::{lexer::tokens::LexerTokenKind, parser::ParserErrorKind};
+
+use super::Expression;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Arithmetic(pub Expression, pub ArithmeticOperator, pub Expression);
+
+#[derive(lang_macro::EnumVariants, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ArithmeticOperator {
+    Add,
+    Subtract,
+    Multiply,
+    Divide,
+}
+
+impl TryFrom<LexerTokenKind> for ArithmeticOperator {
+    type Error = ParserErrorKind;
+    
+    fn try_from(value: LexerTokenKind) -> Result<Self, Self::Error> {
+        Ok(match value {
+            LexerTokenKind::Plus => Self::Add,
+            LexerTokenKind::Minus => Self::Subtract,
+            LexerTokenKind::Multiply => Self::Multiply,
+            LexerTokenKind::Divide => Self::Divide,
+            _ => return Err(ParserErrorKind::ConvertError(value))
+        })
+    }
+}

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

@@ -0,0 +1,30 @@
+use crate::{lexer::tokens::LexerTokenKind, parser::ParserErrorKind};
+
+use super::Expression;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Assignment(pub Expression, pub AssignmentOperator, pub Expression);
+
+#[derive(lang_macro::EnumVariants, Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AssignmentOperator {
+    PlusAssign,
+    MinusAssign,
+    MultiplyAssign,
+    DivideAssign,
+    Assign
+}
+
+impl TryFrom<LexerTokenKind> for AssignmentOperator {
+    type Error = ParserErrorKind;
+    
+    fn try_from(value: LexerTokenKind) -> Result<Self, Self::Error> {
+        Ok(match value {
+            LexerTokenKind::PlusEqual => Self::PlusAssign,
+            LexerTokenKind::MinusEqual => Self::MinusAssign,
+            LexerTokenKind::MultiplyEqual => Self::MultiplyAssign,
+            LexerTokenKind::DivideEqual => Self::DivideAssign,
+            LexerTokenKind::Equal => Self::Assign,
+            _ => return Err(ParserErrorKind::ConvertError(value))
+        })
+    }
+}

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

@@ -0,0 +1,4 @@
+use crate::parser::stmt::Statement;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Block(pub Vec<Statement>);

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

@@ -0,0 +1,4 @@
+use super::{Block, Expression};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ElseExpr(pub Option<Expression>, pub Block, pub Option<Box<ElseExpr>>);