[feat] Better Syntax

.gitignore

@@ -5,7 +5,7 @@ out
 out.*
 
 *.qf
-*.qfmir
 *.llvm
+*.air
 
 !examples/**.qf

compiler/ast/src/lib.rs

@@ -4,5 +4,6 @@
 
 pub mod ctx;
 pub mod operators;
+pub mod ranges;
 pub mod tree;
 pub mod types;

compiler/ast/src/operators.rs

@@ -72,15 +72,23 @@ pub fn parse_compare_operator(
         _ => false,
     };
 
+    if eq {
+        *ind += 1;
+    }
+
     let op = match tokens[*ind].tok_type {
         LexerTokenType::EqualSign => {
-            tokens[*ind + 1].expects(LexerTokenType::EqualSign)?;
+            if !eq {
+                tokens[*ind + 1].expects(LexerTokenType::EqualSign)?;
+            }
 
             ComparingOperator::Equal
         }
 
         LexerTokenType::ExclamationMark => {
-            tokens[*ind + 1].expects(LexerTokenType::EqualSign)?;
+            if !eq {
+                tokens[*ind + 1].expects(LexerTokenType::EqualSign)?;
+            }
 
             ComparingOperator::NotEqual
         }
@@ -106,5 +114,7 @@ pub fn parse_compare_operator(
         }
     };
 
+    *ind += 1;
+
     return Ok(op);
 }

compiler/ast/src/ranges.rs

@@ -0,0 +1,7 @@
+use crate::tree::ASTTreeNode;
+
+#[derive(Debug, PartialEq, Clone)]
+pub struct ASTRange {
+    pub min: Box<ASTTreeNode>,
+    pub max: Box<ASTTreeNode>,
+}

compiler/ast/src/tree.rs

@@ -15,7 +15,7 @@ use diagnostics::{
     diagnostic::{Diagnostic, Span, SpanKind, SpanPosition},
 };
 
-use crate::types::ASTType;
+use crate::{ranges::ASTRange, types::ASTType};
 
 #[derive(Debug, PartialEq, Clone)]
 pub struct FunctionDeclarationArgument {
@@ -78,7 +78,13 @@ pub enum ASTTreeNodeKind {
 
     VariableReference(HashedString),
 
-    PointerGrab(Box<ASTTreeNode>),
+    Dereference(Box<ASTTreeNode>),
+
+    DereferenceModify {
+        pointer: Box<ASTTreeNode>,
+        val: Box<ASTTreeNode>,
+    },
+
     ReferenceGrab(Box<ASTTreeNode>),
 
     StructInitializer {
@@ -166,13 +172,20 @@ pub enum ASTTreeNodeKind {
         cond: Box<ASTTreeNode>,
         body: Vec<Box<ASTTreeNode>>,
     },
+
     ForBlock {
         initial_state: Box<ASTTreeNode>,
         cond: Box<ASTTreeNode>,
         increment: Box<ASTTreeNode>,
         body: Vec<Box<ASTTreeNode>>,
     },
 
+    RangedForBlock {
+        var: Box<ASTTreeNode>,
+        range: ASTRange,
+        body: Vec<Box<ASTTreeNode>>,
+    },
+
     FunctionCall {
         func: HashedString,
         args: Vec<Box<ASTTreeNode>>,
@@ -185,7 +198,7 @@ pub enum ASTTreeNodeKind {
         requires_this: bool,
     },
 
-    ShadowFunctionDeclaration {
+    ExternFunctionDeclaration {
         func_name: HashedString,
         args: Vec<FunctionDeclarationArgument>,
         return_type: Option<ASTType>,
@@ -222,7 +235,7 @@ impl ASTTreeNodeKind {
             ASTTreeNodeKind::FunctionDeclaration { .. }
                 | ASTTreeNodeKind::EnumDeclaration { .. }
                 | ASTTreeNodeKind::StaticVariableDeclaration { .. }
-                | ASTTreeNodeKind::ShadowFunctionDeclaration { .. }
+                | ASTTreeNodeKind::ExternFunctionDeclaration { .. }
                 | ASTTreeNodeKind::StructLayoutDeclaration { .. }
         );
     }
@@ -239,7 +252,7 @@ impl ASTTreeNodeKind {
                 return Some(HashedString::new(func_name.val.to_string()));
             }
 
-            ASTTreeNodeKind::ShadowFunctionDeclaration {
+            ASTTreeNodeKind::ExternFunctionDeclaration {
                 func_name,
                 args: _,
                 return_type: _,
@@ -349,7 +362,8 @@ impl Display for ASTTreeNodeKind {
             Self::BooleanBasedConditionMember { .. } => "boolean condition",
             Self::MathResult { .. } => "math operation",
             Self::VariableReference(_) => "variable reference",
-            Self::PointerGrab(_) => "pointer grabbing",
+            Self::DereferenceModify { .. } => "modifying dereference",
+            Self::Dereference(_) => "dereference",
             Self::ReferenceGrab(_) => "reference",
             Self::StructInitializer { .. } => "struct value initializer",
             Self::ArrayVariableInitializerValue { .. }
@@ -364,10 +378,10 @@ impl Display for ASTTreeNodeKind {
             Self::ReturnStatement { .. } => "return statement",
             Self::StaticVariableDeclaration { .. } => "static variable declaration",
             Self::WhileBlock { .. } => "while block",
-            Self::ForBlock { .. } => "for block",
+            Self::ForBlock { .. } | Self::RangedForBlock { .. } => "for block",
             Self::FunctionCall { .. } => "function call",
             Self::FunctionDeclaration { .. } => "function declaration",
-            Self::ShadowFunctionDeclaration { .. } => "shadow function declaration",
+            Self::ExternFunctionDeclaration { .. } => "extern function declaration",
             Self::StructLRFunction { .. } => "struct LRU function usage",
             Self::StructLRVariable { .. } => "struct LRU variable usage",
             Self::StructLayoutDeclaration { .. } => "struct / layout declaration",

compiler/ast_parser/src/control/for_loop.rs

@@ -4,8 +4,8 @@ use lexer::token::{LexerToken, LexerTokenType};
 use ast::tree::{ASTTreeNode, ASTTreeNodeKind};
 
 use crate::{
-    functions::parse_node_body, parser::parse_ast_node_in_body, value::parse_ast_value,
-    variables::decl::parse_variable_declaration,
+    functions::parse_node_body, parser::parse_ast_node_in_body, ranges::parse_value_range,
+    value::parse_ast_value, variables::decl::parse_variable_declaration,
 };
 
 pub fn parse_for_loop(
@@ -14,11 +14,18 @@ pub fn parse_for_loop(
 ) -> DiagnosticResult<Box<ASTTreeNode>> {
     let start = tokens[*ind].pos.clone();
 
+    if tokens[*ind + 1].tok_type != LexerTokenType::ParenOpen {
+        return parse_for_ranged_loop(tokens, ind);
+    }
+
     *ind += 1;
 
     tokens[*ind].expects(LexerTokenType::ParenOpen)?;
+    *ind += 1;
+
+    tokens[*ind].expects(LexerTokenType::Var)?;
 
-    let initial = parse_variable_declaration(tokens, ind)?;
+    let initial = parse_variable_declaration(tokens, ind, true)?;
 
     tokens[*ind].expects(LexerTokenType::Comma)?;
 
@@ -50,3 +57,32 @@ pub fn parse_for_loop(
         end,
     )));
 }
+
+pub fn parse_for_ranged_loop(
+    tokens: &Vec<LexerToken>,
+    ind: &mut usize,
+) -> DiagnosticResult<Box<ASTTreeNode>> {
+    let start = tokens[*ind].pos.clone();
+
+    let var = parse_variable_declaration(tokens, ind, false)?;
+
+    tokens[*ind].expects(LexerTokenType::EqualSign)?;
+    *ind += 1;
+
+    tokens[*ind].expects(LexerTokenType::AngelBracketClose)?;
+    *ind += 1;
+
+    let range = parse_value_range(tokens, ind)?;
+
+    tokens[*ind].expects(LexerTokenType::BracketOpen)?;
+
+    let body = parse_node_body(tokens, ind)?;
+
+    let end: compiler_utils::Position = tokens[*ind - 1].get_end_pos();
+
+    Ok(Box::new(ASTTreeNode::new(
+        ASTTreeNodeKind::RangedForBlock { var, range, body },
+        start,
+        end,
+    )))
+}

compiler/ast_parser/src/functions/mod.rs

@@ -17,6 +17,24 @@ pub mod arguments;
 pub mod returns;
 pub mod shadow;
 
+pub fn parse_function_return_type(
+    tokens: &Vec<LexerToken>,
+    ind: &mut usize,
+) -> DiagnosticResult<Option<ASTType>> {
+    if tokens[*ind].tok_type == LexerTokenType::Minus {
+        *ind += 1;
+
+        tokens[*ind].expects(LexerTokenType::AngelBracketClose)?;
+        *ind += 1;
+
+        let ty = parse_type(tokens, ind)?;
+
+        return Ok(Some(ty));
+    } else {
+        return Ok(None);
+    }
+}
+
 pub fn parse_function_declaraction(
     tokens: &Vec<LexerToken>,
     ind: &mut usize,
@@ -34,12 +52,7 @@ pub fn parse_function_declaraction(
 
     *ind += 1;
 
-    let mut ret_type = None;
-
-    if tokens[*ind].is_keyword() {
-        ret_type = Some(parse_type(tokens, ind)?);
-        //*ind += 1;
-    }
+    let ret_type = parse_function_return_type(tokens, ind)?;
 
     tokens[*ind].expects(LexerTokenType::BracketOpen)?;
 
@@ -108,20 +121,13 @@ pub fn parse_node_body(
     let mut tok: &LexerToken = &tokens[*ind];
     let mut body: Vec<Box<ASTTreeNode>> = Vec::new();
 
-    let mut stock = 1;
-
     while tok.tok_type != LexerTokenType::EndOfFile && tok.tok_type != LexerTokenType::BracketClose
     {
-        if tok.tok_type == LexerTokenType::BracketClose {
-            stock -= 1;
-        }
-
-        if stock == 0 {
-            break;
-        }
+        if tok.tok_type == LexerTokenType::SemiCollon {
+            *ind += 1;
+            tok = &tokens[*ind];
 
-        if tok.tok_type == LexerTokenType::BracketOpen {
-            stock += 1;
+            continue;
         }
 
         let n = parse_ast_node_in_body(tokens, ind)?;

compiler/ast_parser/src/functions/shadow.rs

@@ -5,9 +5,9 @@ use compiler_utils::hash::HashedString;
 use diagnostics::DiagnosticResult;
 use lexer::token::{LexerToken, LexerTokenType};
 
-use crate::{functions::arguments::parse_function_arguments, types::parse_type};
+use crate::functions::{arguments::parse_function_arguments, parse_function_return_type};
 
-pub fn parse_shadow_function_declaration(
+pub fn parse_extern_function_definition(
     tokens: &Vec<LexerToken>,
     ind: &mut usize,
 ) -> DiagnosticResult<Box<ASTTreeNode>> {
@@ -23,19 +23,11 @@ pub fn parse_shadow_function_declaration(
 
     *ind += 1;
 
-    let mut ret_type = None;
-    let end;
-
-    if tokens[*ind].is_keyword() {
-        ret_type = Some(parse_type(tokens, ind)?);
-
-        end = tokens[*ind].get_end_pos().clone();
-    } else {
-        end = tokens[*ind - 1].get_end_pos().clone();
-    }
+    let ret_type = parse_function_return_type(tokens, ind)?;
+    let end = tokens[*ind].get_end_pos();
 
     return Ok(Box::new(ASTTreeNode::new(
-        ASTTreeNodeKind::ShadowFunctionDeclaration {
+        ASTTreeNodeKind::ExternFunctionDeclaration {
             func_name: HashedString::new(function_name.0),
             args: args.0,
             return_type: ret_type,

compiler/ast_parser/src/lib.rs

@@ -15,6 +15,8 @@ pub mod functions;
 pub mod literals;
 pub mod math;
 pub mod parser;
+pub mod pointers;
+pub mod ranges;
 pub mod structs;
 pub mod types;
 pub mod unwraps;

compiler/ast_parser/src/math.rs

@@ -31,8 +31,6 @@ pub fn parse_math_operation(
             .into());
     }
 
-    println!("{:#?}", tokens[*ind].tok_type);
-
     let right_member = parse_ast_value(tokens, ind)?;
 
     let start = original.start.clone();

compiler/ast_parser/src/parser.rs

@@ -15,8 +15,9 @@ use crate::{
     },
     functions::{
         parse_function_call, parse_function_declaraction, returns::parse_function_return_statement,
-        shadow::parse_shadow_function_declaration,
+        shadow::parse_extern_function_definition,
     },
+    pointers::parse_deref_modify,
     structs::{enums::parse_enum_declaration, parse_type_declaration},
     use_statements::parse_use_statement,
     value::parse_ast_value_post_l,
@@ -39,8 +40,8 @@ pub fn parse_ast_node(
             return parse_function_declaraction(tokens, ind, None);
         }
 
-        LexerTokenType::ShadowFunction => {
-            return parse_shadow_function_declaration(tokens, ind);
+        LexerTokenType::ExternFunc => {
+            return parse_extern_function_definition(tokens, ind);
         }
 
         LexerTokenType::Struct => {
@@ -76,7 +77,7 @@ pub fn parse_ast_node_in_body(
 ) -> DiagnosticResult<Box<ASTTreeNode>> {
     match &tokens[*ind].tok_type {
         LexerTokenType::Var => {
-            return parse_variable_declaration(tokens, ind);
+            return parse_variable_declaration(tokens, ind, true);
         }
 
         LexerTokenType::If => {
@@ -91,13 +92,16 @@ pub fn parse_ast_node_in_body(
             return parse_for_loop(tokens, ind);
         }
 
+        LexerTokenType::Asterisk => return parse_deref_modify(tokens, ind),
+
         LexerTokenType::Return => {
             return parse_function_return_statement(tokens, ind);
         }
 
         LexerTokenType::Keyword(str, _) => {
             if tokens[*ind + 1].tok_type == LexerTokenType::ParenOpen {
                 let call = parse_function_call(tokens, ind);
+
                 return parse_ast_value_post_l(tokens, ind, call, true);
             }