A7 Feature: Add Variables

Cargo.toml

@@ -6,4 +6,4 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-heraclitus-compiler = "0.2.0"
+heraclitus-compiler = "0.2.1"

src/main.rs

@@ -1,13 +1,13 @@
 mod modules;
 mod rules;
-mod parser;
+mod utils;
 
 use heraclitus_compiler::prelude::*;
 use modules::block;
-use parser::ParserMetadata;
+use crate::utils::metadata::ParserMetadata;
 
 fn main() {
-    let code = "not true";
+    let code = "let age = 12\nlet name = 'john'";
     let rules = rules::get_rules();
     let mut cc = Compiler::new("Amber", rules);
     let mut block = block::Block::new();

src/modules/block.rs

@@ -1,7 +1,5 @@
-use std::process::exit;
-
 use heraclitus_compiler::prelude::*;
-use crate::parser::ParserMetadata;
+use crate::utils::{metadata::ParserMetadata, error::get_error_logger};
 use super::statement::statement::Statement;
 
 #[derive(Debug)]
@@ -10,20 +8,11 @@ pub struct Block {
 }
 
 impl Block {
-    fn error(&mut self, meta: &mut ParserMetadata, mut details: ErrorDetails) {
-        if let Some(path) = meta.path.clone() {
-            if let Ok(location) = details.get_pos_by_file(&path) {
-                Logger::new_err(path, location)
-                    .attach_message("Undefined syntax")
-                    .show()
-                    .exit();
-            } else {
-                // TODO: Refactor this part of code
-                println!("ERROR at {:?}", details.position);
-                println!("Couldn't load file '{}'", path);
-                exit(1);
-            }   
-        }
+    fn error(&mut self, meta: &mut ParserMetadata, details: ErrorDetails) {
+        get_error_logger(meta, details)
+            .attach_message("Undefined syntax")
+            .show()
+            .exit()
     }
 }
 
@@ -37,6 +26,7 @@ impl SyntaxModule<ParserMetadata> for Block {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
+        meta.var_mem.push_scope();
         loop {
             if let None = meta.get_token_at(meta.get_index()) {
                 break;
@@ -47,6 +37,7 @@ impl SyntaxModule<ParserMetadata> for Block {
             }
             self.statements.push(statemant);
         }
+        meta.var_mem.pop_scope();
         Ok(())
     }
 }

src/modules/expression/binop/add.rs

@@ -1,11 +1,19 @@
 use heraclitus_compiler::prelude::*;
-use crate::parser::ParserMetadata;
+use crate::utils::metadata::ParserMetadata;
 use super::{super::expr::Expr, Binop};
+use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
 pub struct Add {
     left: Box<Expr>,
-    right: Box<Expr>
+    right: Box<Expr>,
+    kind: Type
+}
+
+impl Typed for Add {
+    fn get_type(&self) -> Type {
+        self.kind.clone()
+    }
 }
 
 impl SyntaxModule<ParserMetadata> for Add {
@@ -14,7 +22,8 @@ impl SyntaxModule<ParserMetadata> for Add {
     fn new() -> Self {
         Add {
             left: Box::new(Expr::new()),
-            right: Box::new(Expr::new())
+            right: Box::new(Expr::new()),
+            kind: Type::Void
         }
     }
 

src/modules/expression/binop/and.rs

@@ -1,13 +1,21 @@
 use heraclitus_compiler::prelude::*;
-use crate::parser::ParserMetadata;
+use crate::utils::metadata::ParserMetadata;
 use super::{super::expr::Expr, Binop};
+use crate::modules::{Type, Typed};
+
 
 #[derive(Debug)]
 pub struct And {
     left: Box<Expr>,
     right: Box<Expr>
 }
 
+impl Typed for And {
+    fn get_type(&self) -> Type {
+        Type::Bool
+    }
+}
+
 impl SyntaxModule<ParserMetadata> for And {
     syntax_name!("And");
 

src/modules/expression/binop/div.rs

@@ -1,11 +1,19 @@
 use heraclitus_compiler::prelude::*;
-use crate::parser::ParserMetadata;
+use crate::utils::metadata::ParserMetadata;
 use super::{super::expr::Expr, Binop};
+use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
 pub struct Div {
     left: Box<Expr>,
-    right: Box<Expr>
+    right: Box<Expr>,
+    kind: Type
+}
+
+impl Typed for Div {
+    fn get_type(&self) -> Type {
+        self.kind.clone()
+    }
 }
 
 impl SyntaxModule<ParserMetadata> for Div {
@@ -14,7 +22,8 @@ impl SyntaxModule<ParserMetadata> for Div {
     fn new() -> Self {
         Div {
             left: Box::new(Expr::new()),
-            right: Box::new(Expr::new())
+            right: Box::new(Expr::new()),
+            kind: Type::Void
         }
     }
 

src/modules/expression/binop/eq.rs

@@ -1,13 +1,20 @@
 use heraclitus_compiler::prelude::*;
-use crate::parser::ParserMetadata;
+use crate::utils::metadata::ParserMetadata;
 use super::{super::expr::Expr, Binop};
+use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
 pub struct Eq {
     left: Box<Expr>,
     right: Box<Expr>
 }
 
+impl Typed for Eq {
+    fn get_type(&self) -> Type {
+        Type::Bool
+    }
+}
+
 impl SyntaxModule<ParserMetadata> for Eq {
     syntax_name!("Eq");
 

src/modules/expression/binop/ge.rs

@@ -1,13 +1,20 @@
 use heraclitus_compiler::prelude::*;
-use crate::parser::ParserMetadata;
+use crate::utils::metadata::ParserMetadata;
 use super::{super::expr::Expr, Binop};
+use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
 pub struct Ge {
     left: Box<Expr>,
     right: Box<Expr>
 }
 
+impl Typed for Ge {
+    fn get_type(&self) -> Type {
+        Type::Bool
+    }
+}
+
 impl SyntaxModule<ParserMetadata> for Ge {
     syntax_name!("Ge");
 

src/modules/expression/binop/gt.rs

@@ -1,13 +1,20 @@
 use heraclitus_compiler::prelude::*;
-use crate::parser::ParserMetadata;
+use crate::utils::metadata::ParserMetadata;
 use super::{super::expr::Expr, Binop};
+use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
 pub struct Gt {
     left: Box<Expr>,
     right: Box<Expr>
 }
 
+impl Typed for Gt {
+    fn get_type(&self) -> Type {
+        Type::Bool
+    }
+}
+
 impl SyntaxModule<ParserMetadata> for Gt {
     syntax_name!("Gt");
 

src/modules/expression/binop/le.rs

@@ -1,13 +1,20 @@
 use heraclitus_compiler::prelude::*;
-use crate::parser::ParserMetadata;
+use crate::utils::metadata::ParserMetadata;
 use super::{super::expr::Expr, Binop};
+use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
 pub struct Le {
     left: Box<Expr>,
     right: Box<Expr>
 }
 
+impl Typed for Le {
+    fn get_type(&self) -> Type {
+        Type::Bool
+    }
+}
+
 impl SyntaxModule<ParserMetadata> for Le {
     syntax_name!("Le");
 

src/modules/expression/binop/lt.rs

@@ -1,13 +1,20 @@
 use heraclitus_compiler::prelude::*;
-use crate::parser::ParserMetadata;
+use crate::utils::metadata::ParserMetadata;
 use super::{super::expr::Expr, Binop};
+use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
 pub struct Lt {
     left: Box<Expr>,
     right: Box<Expr>
 }
 
+impl Typed for Lt {
+    fn get_type(&self) -> Type {
+        Type::Bool
+    }
+}
+
 impl SyntaxModule<ParserMetadata> for Lt {
     syntax_name!("Lt");
 

src/modules/expression/binop/mod.rs

@@ -1,5 +1,5 @@
 use heraclitus_compiler::prelude::*;
-use crate::parser::ParserMetadata;
+use crate::utils::metadata::ParserMetadata;
 use super::super::expression::expr::Expr;
 
 pub mod add;
@@ -34,7 +34,7 @@ impl Binop {
     fn binop_left_cut(meta: &mut ParserMetadata, op: impl AsRef<str>) -> Result<usize, ErrorDetails> {
         let old_index = meta.get_index();
         let mut parenthesis = 0;
-        while let Some(token) = meta.get_token_at(meta.get_index()) {
+        while let Some(token) = meta.get_current_token() {
             // If we were supposed to parse just a fraction
             if let Some(border) = meta.binop_border {
                 if border <= meta.get_index() {

src/modules/expression/binop/mul.rs

@@ -1,11 +1,19 @@
 use heraclitus_compiler::prelude::*;
-use crate::parser::ParserMetadata;
+use crate::utils::metadata::ParserMetadata;
 use super::{super::expr::Expr, Binop};
+use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
 pub struct Mul {
     left: Box<Expr>,
-    right: Box<Expr>
+    right: Box<Expr>,
+    kind: Type
+}
+
+impl Typed for Mul {
+    fn get_type(&self) -> Type {
+        self.kind.clone()
+    }
 }
 
 impl SyntaxModule<ParserMetadata> for Mul {
@@ -14,7 +22,8 @@ impl SyntaxModule<ParserMetadata> for Mul {
     fn new() -> Self {
         Mul {
             left: Box::new(Expr::new()),
-            right: Box::new(Expr::new())
+            right: Box::new(Expr::new()),
+            kind: Type::Void
         }
     }
 

src/modules/expression/binop/neq.rs

@@ -1,13 +1,20 @@
 use heraclitus_compiler::prelude::*;
-use crate::parser::ParserMetadata;
+use crate::utils::metadata::ParserMetadata;
 use super::{super::expr::Expr, Binop};
+use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
 pub struct Neq {
     left: Box<Expr>,
     right: Box<Expr>
 }
 
+impl Typed for Neq {
+    fn get_type(&self) -> Type {
+        Type::Bool
+    }
+}
+
 impl SyntaxModule<ParserMetadata> for Neq {
     syntax_name!("Neq");
 

src/modules/expression/binop/or.rs

@@ -1,13 +1,20 @@
 use heraclitus_compiler::prelude::*;
-use crate::parser::ParserMetadata;
+use crate::utils::metadata::ParserMetadata;
 use super::{super::expr::Expr, Binop};
+use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
 pub struct Or {
     left: Box<Expr>,
     right: Box<Expr>
 }
 
+impl Typed for Or {
+    fn get_type(&self) -> Type {
+        Type::Bool
+    }
+}
+
 impl SyntaxModule<ParserMetadata> for Or {
     syntax_name!("Or");