Merge pull request #11 from Ph0enixKM/A7

A7 Feature: Add Variables

Cargo.toml

@@ -7,3 +7,4 @@ edition = "2021"
 
 [dependencies]
 heraclitus-compiler = "0.2.1"
+similar-string = "0.1.1"

src/main.rs

@@ -7,13 +7,15 @@ use modules::block;
 use crate::utils::metadata::ParserMetadata;
 
 fn main() {
-    let code = "let age = 12\nlet name = 'john'";
+    let code = vec![
+        "let age = 12",
+        "age = age + 12"
+    ].join("\n");
     let rules = rules::get_rules();
     let mut cc = Compiler::new("Amber", rules);
     let mut block = block::Block::new();
     cc.load(code);
     if let Ok(tokens) = cc.tokenize() {
-        println!("{tokens:?}");
         let path = Some(format!("/path/to/file"));
         let mut meta = ParserMetadata::new(tokens, path);
         if let Ok(()) = block.parse_debug(&mut meta) {

src/modules/expression/binop/add.rs

@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::utils::metadata::ParserMetadata;
-use super::{super::expr::Expr, Binop};
+use super::{super::expr::Expr, parse_left_expr};
 use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
@@ -28,7 +28,7 @@ impl SyntaxModule<ParserMetadata> for Add {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        Binop::parse_left_expr(meta, &mut *self.left, "+")?;
+        parse_left_expr(meta, &mut *self.left, "+")?;
         token(meta, "+")?;
         syntax(meta, &mut *self.right)?;
         Ok(())

src/modules/expression/binop/and.rs

@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::utils::metadata::ParserMetadata;
-use super::{super::expr::Expr, Binop};
+use super::{super::expr::Expr, parse_left_expr};
 use crate::modules::{Type, Typed};
 
 
@@ -27,7 +27,7 @@ impl SyntaxModule<ParserMetadata> for And {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        Binop::parse_left_expr(meta, &mut *self.left, "and")?;
+        parse_left_expr(meta, &mut *self.left, "and")?;
         token(meta, "and")?;
         syntax(meta, &mut *self.right)?;
         Ok(())

src/modules/expression/binop/div.rs

@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::utils::metadata::ParserMetadata;
-use super::{super::expr::Expr, Binop};
+use super::{super::expr::Expr, parse_left_expr};
 use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
@@ -28,7 +28,7 @@ impl SyntaxModule<ParserMetadata> for Div {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        Binop::parse_left_expr(meta, &mut *self.left, "/")?;
+        parse_left_expr(meta, &mut *self.left, "/")?;
         token(meta, "/")?;
         syntax(meta, &mut *self.right)?;
         Ok(())

src/modules/expression/binop/eq.rs

@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::utils::metadata::ParserMetadata;
-use super::{super::expr::Expr, Binop};
+use super::{super::expr::Expr, parse_left_expr};
 use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
@@ -26,7 +26,7 @@ impl SyntaxModule<ParserMetadata> for Eq {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        Binop::parse_left_expr(meta, &mut *self.left, "==")?;
+        parse_left_expr(meta, &mut *self.left, "==")?;
         token(meta, "==")?;
         syntax(meta, &mut *self.right)?;
         Ok(())

src/modules/expression/binop/ge.rs

@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::utils::metadata::ParserMetadata;
-use super::{super::expr::Expr, Binop};
+use super::{super::expr::Expr, parse_left_expr};
 use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
@@ -26,7 +26,7 @@ impl SyntaxModule<ParserMetadata> for Ge {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        Binop::parse_left_expr(meta, &mut *self.left, ">=")?;
+        parse_left_expr(meta, &mut *self.left, ">=")?;
         token(meta, ">=")?;
         syntax(meta, &mut *self.right)?;
         Ok(())

src/modules/expression/binop/gt.rs

@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::utils::metadata::ParserMetadata;
-use super::{super::expr::Expr, Binop};
+use super::{super::expr::Expr, parse_left_expr};
 use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
@@ -26,7 +26,7 @@ impl SyntaxModule<ParserMetadata> for Gt {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        Binop::parse_left_expr(meta, &mut *self.left, ">")?;
+        parse_left_expr(meta, &mut *self.left, ">")?;
         token(meta, ">")?;
         syntax(meta, &mut *self.right)?;
         Ok(())

src/modules/expression/binop/le.rs

@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::utils::metadata::ParserMetadata;
-use super::{super::expr::Expr, Binop};
+use super::{super::expr::Expr, parse_left_expr};
 use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
@@ -26,7 +26,7 @@ impl SyntaxModule<ParserMetadata> for Le {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        Binop::parse_left_expr(meta, &mut *self.left, "<=")?;
+        parse_left_expr(meta, &mut *self.left, "<=")?;
         token(meta, "<=")?;
         syntax(meta, &mut *self.right)?;
         Ok(())

src/modules/expression/binop/lt.rs

@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::utils::metadata::ParserMetadata;
-use super::{super::expr::Expr, Binop};
+use super::{super::expr::Expr, parse_left_expr};
 use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
@@ -26,7 +26,7 @@ impl SyntaxModule<ParserMetadata> for Lt {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        Binop::parse_left_expr(meta, &mut *self.left, "<")?;
+        parse_left_expr(meta, &mut *self.left, "<")?;
         token(meta, "<")?;
         syntax(meta, &mut *self.right)?;
         Ok(())

src/modules/expression/binop/mod.rs

@@ -15,56 +15,53 @@ pub mod le;
 pub mod eq;
 pub mod neq;
 
-struct Binop;
 
-impl Binop {
-    fn parse_left_expr(meta: &mut ParserMetadata, module: &mut Expr, op: impl AsRef<str>) -> Result<usize, ErrorDetails> {
-        // Save left border and run binop left cut border check
-        let old_border = meta.binop_border;
-        let new_border = Self::binop_left_cut(meta, op)?;
-        meta.binop_border = Some(new_border);
-        // Parse the left expression
-        syntax(meta, module)?;
-        // Revert border back to the original
-        meta.binop_border = old_border;
-        Ok(new_border)
-    }
+pub fn parse_left_expr(meta: &mut ParserMetadata, module: &mut Expr, op: impl AsRef<str>) -> Result<usize, ErrorDetails> {
+    // Save left border and run binop left cut border check
+    let old_border = meta.binop_border;
+    let new_border = binop_left_cut(meta, op)?;
+    meta.binop_border = Some(new_border);
+    // Parse the left expression
+    syntax(meta, module)?;
+    // Revert border back to the original
+    meta.binop_border = old_border;
+    Ok(new_border)
+}
 
-    // Check if this binop can actually take place and return a new boundary for the left hand expression
-    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_current_token() {
-            // If we were supposed to parse just a fraction
-            if let Some(border) = meta.binop_border {
-                if border <= meta.get_index() {
-                    break
-                }
+// Check if this binop can actually take place and return a new boundary for the left hand expression
+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_current_token() {
+        // If we were supposed to parse just a fraction
+        if let Some(border) = meta.binop_border {
+            if border <= meta.get_index() {
+                break
+            }
+        }
+        match token.word.as_str() {
+            "(" => parenthesis += 1,
+            ")" => parenthesis -= 1,
+            "\n" => break,
+            _ => {}
+        };
+        if parenthesis == 0 && op.as_ref() == token.word {
+            // Case when the operator is in the beginning of the line
+            if meta.get_index() > old_index {
+                let new_index = meta.get_index();
+                meta.set_index(old_index);
+                return Ok(new_index)
             }
-            match token.word.as_str() {
-                "(" => parenthesis += 1,
-                ")" => parenthesis -= 1,
-                "\n" => break,
-                _ => {}
-            };
-            if parenthesis == 0 && op.as_ref() == token.word {
-                // Case when the operator is in the beginning of the line
-                if meta.get_index() > old_index {
-                    let new_index = meta.get_index();
-                    meta.set_index(old_index);
-                    return Ok(new_index)
-                }
-                else {
-                    let err = ErrorDetails::from_metadata(meta);
-                    meta.set_index(old_index);
-                    return Err(err)
-                }
+            else {
+                let err = ErrorDetails::from_metadata(meta);
+                meta.set_index(old_index);
+                return Err(err)
             }
-            meta.increment_index();
         }
-        let err = ErrorDetails::from_metadata(meta);
-        meta.set_index(old_index);
-        Err(err)
+        meta.increment_index();
     }
-
+    let err = ErrorDetails::from_metadata(meta);
+    meta.set_index(old_index);
+    Err(err)
 }
+

src/modules/expression/binop/mul.rs

@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::utils::metadata::ParserMetadata;
-use super::{super::expr::Expr, Binop};
+use super::{super::expr::Expr, parse_left_expr};
 use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
@@ -28,7 +28,7 @@ impl SyntaxModule<ParserMetadata> for Mul {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        Binop::parse_left_expr(meta, &mut *self.left, "*")?;
+        parse_left_expr(meta, &mut *self.left, "*")?;
         token(meta, "*")?;
         syntax(meta, &mut *self.right)?;
         Ok(())

src/modules/expression/binop/neq.rs

@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::utils::metadata::ParserMetadata;
-use super::{super::expr::Expr, Binop};
+use super::{super::expr::Expr, parse_left_expr};
 use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
@@ -26,7 +26,7 @@ impl SyntaxModule<ParserMetadata> for Neq {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        Binop::parse_left_expr(meta, &mut *self.left, "!=")?;
+        parse_left_expr(meta, &mut *self.left, "!=")?;
         token(meta, "!=")?;
         syntax(meta, &mut *self.right)?;
         Ok(())

src/modules/expression/binop/or.rs

@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::utils::metadata::ParserMetadata;
-use super::{super::expr::Expr, Binop};
+use super::{super::expr::Expr, parse_left_expr};
 use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
@@ -26,7 +26,7 @@ impl SyntaxModule<ParserMetadata> for Or {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        Binop::parse_left_expr(meta, &mut *self.left, "or")?;
+        parse_left_expr(meta, &mut *self.left, "or")?;
         token(meta, "or")?;
         syntax(meta, &mut *self.right)?;
         Ok(())

src/modules/expression/binop/sub.rs

@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
 use crate::utils::metadata::ParserMetadata;
-use super::{super::expr::Expr, Binop};
+use super::{super::expr::Expr, parse_left_expr};
 use crate::modules::{Type, Typed};
 
 #[derive(Debug)]
@@ -28,7 +28,7 @@ impl SyntaxModule<ParserMetadata> for Sub {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
-        Binop::parse_left_expr(meta, &mut *self.left, "-")?;
+        parse_left_expr(meta, &mut *self.left, "-")?;
         token(meta, "-")?;
         syntax(meta, &mut *self.right)?;
         Ok(())

src/modules/variable/get.rs

@@ -1,6 +1,6 @@
 use heraclitus_compiler::prelude::*;
-use crate::{utils::metadata::ParserMetadata, modules::{Type, Typed}};
-use super::variable_name_extensions;
+use crate::{utils::{metadata::ParserMetadata}, modules::{Type, Typed}};
+use super::{variable_name_extensions, handle_variable_reference};
 
 #[derive(Debug)]
 pub struct VariableGet {
@@ -25,8 +25,9 @@ impl SyntaxModule<ParserMetadata> for VariableGet {
     }
 
     fn parse(&mut self, meta: &mut ParserMetadata) -> SyntaxResult {
+        let tok = meta.get_current_token();
         self.name = variable(meta, variable_name_extensions())?;
-        // TODO: Get the actual type of the variable
+        self.kind = handle_variable_reference(meta, tok, self.name.clone());
         Ok(())
     }
 }