[feat] Global Scope storage

.github/workflows/rust.yml

@@ -1,4 +1,4 @@
-name: Rust
+name: Compile (No bridges)
 
 on:
   pull_request:
@@ -15,4 +15,4 @@ jobs:
     steps:
     - uses: actions/checkout@v4
     - name: Build
-      run: cargo build --verbose
+      run: cargo build -p compiler_main

CONTRIBUTING.MD

@@ -14,7 +14,7 @@ git clone https://github.com/Quickfall/quickfall
 ```
 
 You will need the following installed in order to compile & use Quickfall:
-- Rust 1.91.1
-- LLVM 21.1
+- Rust 1.94.1
+- LLVM 22.1
 
 You can then build the project by using the `cargo` Rust tool.

Cargo.toml

@@ -1,2 +1,2 @@
 [workspace]
-members = ["compiler/ast", "compiler/ast_parser", "compiler/astoir", "compiler/astoir_hir", "compiler/astoir_hir_lowering", "compiler/astoir_mir", "compiler/compiler_typing", "compiler/astoir_mir_lowering", "compiler/compiler_main", "compiler/compiler_utils", "compiler/llvm_ir_bridge", "compiler/diagnostics"]
+members = ["compiler/ast", "compiler/ast_parser", "compiler/astoir", "compiler/astoir_hir", "compiler/astoir_hir_lowering", "compiler/astoir_mir", "compiler/compiler_typing", "compiler/astoir_mir_lowering", "compiler/compiler_main", "compiler/compiler_utils", "compiler/llvm_ir_bridge", "compiler/diagnostics", "compiler/prelude", "compiler/compiler_global_scope"]

README.md

@@ -5,7 +5,8 @@ Quickfall is a programming language focusing  on allowing everyone to build fast
 Quickfall aims to give the performance of extremely fast languages like C while giving the safety of Rust and also being reliable.
 
 What Quickfall focuses on:
-- **Speed**: Quickfall focuses on runtime speed which means that every single compile time safety check can be simply disabled either globally or for a single element. On recent benchmarks, Quickfall has surpassed C in terms of runtime speed by up to 25%!
+- **Speed**: Quickfall focuses on runtime speed which means that every single compile time safety check can be simply disabled either globally or for a single element.
+- **Feature filled**: Quickfall gives multiple useful features to build reliable software such as enums or arbitrary size types
 - **Strict syntax**: Quickfall enforces a strict syntax to avoid mistakes or error prone code
 - **Safety**: Quickfall enforces strict safety features on compile time and optional ones on runtime that can be easily disabled to allow for the highest safety or speed depending on the build
-- **Thread safety**: Quickfall gives tools to enforce thread safety mostly on compile time such as the *thread markers* to identify and restrict variables to only certain threads
+- **Mutlipurpose**: Quickfall can both be used to build low level and high level software with different level of tools.

compiler/ast/src/ctx.rs

@@ -1,27 +1,31 @@
-use std::{collections::HashMap};
+use std::collections::HashMap;
 
 use crate::tree::ASTTreeNode;
 
 #[derive(Debug)]
 pub struct ParserCtx {
-	pub map: HashMap<String, Box<ASTTreeNode>>, 
-	pub iter_order: Vec<String>
+    pub map: HashMap<String, Box<ASTTreeNode>>,
+    pub uses: Vec<Box<ASTTreeNode>>,
+    pub iter_order: Vec<String>,
 }
 
 impl ParserCtx {
-	pub fn new() -> Self {
-		return ParserCtx { map: HashMap::new(), iter_order: Vec::new() }
-	}
+    pub fn new() -> Self {
+        return ParserCtx {
+            map: HashMap::new(),
+            iter_order: Vec::new(),
+            uses: vec![],
+        };
+    }
 
-	pub fn insert(&mut self, name: String, node: Box<ASTTreeNode>) -> bool {
-		if !node.kind.is_tree_permissible() {
-			return false;
-		}
+    pub fn insert(&mut self, name: String, node: Box<ASTTreeNode>) -> bool {
+        if !node.kind.is_tree_permissible() {
+            return false;
+        }
 
-		self.iter_order.push(name.clone());
+        self.iter_order.push(name.clone());
 
-		self.map.insert(name, node);
-		return true;
-	}
-
-}
+        self.map.insert(name, node);
+        return true;
+    }
+}

compiler/ast/src/lib.rs

@@ -1,7 +1,8 @@
 //!
 //! The AST module of Quickfall. Contains all of the AST code required for the Quickfall language.
-//! 
+//!
 
-pub mod tree;
 pub mod ctx;
+pub mod operators;
+pub mod tree;
 pub mod types;

compiler/ast/src/operators.rs

@@ -0,0 +1,110 @@
+//! Operator related utils
+
+use compiler_utils::operators::{ComparingOperator, MathOperator, MathOperatorType};
+use diagnostics::{DiagnosticResult, builders::make_unexpected_simple_error};
+use lexer::token::{LexerToken, LexerTokenType};
+
+pub fn parse_math_operator(
+    tokens: &Vec<LexerToken>,
+    ind: &mut usize,
+) -> DiagnosticResult<MathOperator> {
+    let op = match tokens[*ind].tok_type {
+        LexerTokenType::Plus => MathOperatorType::Add,
+        LexerTokenType::PercentSign => MathOperatorType::Modulo,
+        LexerTokenType::Minus => MathOperatorType::Subtract,
+        LexerTokenType::Asterisk => {
+            if tokens[*ind + 1].tok_type == LexerTokenType::Asterisk {
+                *ind += 1;
+
+                MathOperatorType::ShiftLeft
+            } else {
+                MathOperatorType::Multiply
+            }
+        }
+        LexerTokenType::Divide => {
+            if tokens[*ind + 1].tok_type == LexerTokenType::Divide {
+                *ind += 1;
+
+                MathOperatorType::ShiftRight
+            } else {
+                MathOperatorType::Divide
+            }
+        }
+
+        _ => {
+            return Err(make_unexpected_simple_error(&tokens[*ind], &tokens[*ind].tok_type).into());
+        }
+    };
+
+    *ind += 1;
+
+    let assigns = match tokens[*ind].tok_type {
+        LexerTokenType::EqualSign => true,
+        _ => false,
+    };
+
+    if assigns {
+        *ind += 1;
+    }
+
+    let fast = match tokens[*ind].tok_type {
+        LexerTokenType::Tidle => true,
+        _ => false,
+    };
+
+    if fast {
+        *ind += 1;
+    }
+
+    return Ok(MathOperator {
+        operator: op,
+        assigns,
+        fast,
+    });
+}
+
+pub fn parse_compare_operator(
+    tokens: &Vec<LexerToken>,
+    ind: &mut usize,
+) -> DiagnosticResult<ComparingOperator> {
+    let eq = match tokens[*ind + 1].tok_type {
+        LexerTokenType::EqualSign => true,
+        _ => false,
+    };
+
+    let op = match tokens[*ind].tok_type {
+        LexerTokenType::EqualSign => {
+            tokens[*ind + 1].expects(LexerTokenType::EqualSign)?;
+
+            ComparingOperator::Equal
+        }
+
+        LexerTokenType::ExclamationMark => {
+            tokens[*ind + 1].expects(LexerTokenType::EqualSign)?;
+
+            ComparingOperator::NotEqual
+        }
+
+        LexerTokenType::AngelBracketOpen => {
+            if eq {
+                ComparingOperator::LowerEqual
+            } else {
+                ComparingOperator::Lower
+            }
+        }
+
+        LexerTokenType::AngelBracketClose => {
+            if eq {
+                ComparingOperator::HigherEqual
+            } else {
+                ComparingOperator::Higher
+            }
+        }
+
+        _ => {
+            return Err(make_unexpected_simple_error(&tokens[*ind], &tokens[*ind].tok_type).into());
+        }
+    };
+
+    return Ok(op);
+}