Feat/astoir mir

Cargo.toml

@@ -1,2 +1,2 @@
 [workspace]
-members = ["compiler/ast", "compiler/ast_parser", "compiler/astoir", "compiler/astoir_hir", "compiler/astoir_hir_lowering", "compiler/astoir_typing", "compiler/compiler_errors", "compiler/compiler_main", "compiler/compiler_utils", "testing"]
+members = ["compiler/ast", "compiler/ast_parser", "compiler/astoir", "compiler/astoir_hir", "compiler/astoir_hir_lowering", "compiler/astoir_mir", "compiler/astoir_mir_lowering", "compiler/astoir_typing", "compiler/compiler_errors", "compiler/compiler_main", "compiler/compiler_utils", "testing"]

compiler/ast/src/tree.rs

@@ -25,6 +25,8 @@ pub enum ASTTreeNodeKind {
     IntegerLit { val: i128, hash: u64 },
     StringLit(String),
 
+	ThisStructParam,
+
 	OperatorBasedConditionMember { lval: Box<ASTTreeNode>, rval: Box<ASTTreeNode>, operator: ComparingOperator },
 	BooleanBasedConditionMember { val: Box<ASTTreeNode>, negate: bool },
 
@@ -51,7 +53,7 @@ pub enum ASTTreeNodeKind {
 	ForBlock { initial_state: Box<ASTTreeNode>, cond: Box<ASTTreeNode>, increment: Box<ASTTreeNode>, body: Vec<Box<ASTTreeNode>> },
 
     FunctionCall { func: HashedString, args: Vec<Box<ASTTreeNode>>  },
-    FunctionDeclaration { func_name: HashedString, args: Vec<FunctionDeclarationArgument>, body: Vec<Box<ASTTreeNode>>, return_type: Option<CompleteType> },
+    FunctionDeclaration { func_name: HashedString, args: Vec<FunctionDeclarationArgument>, body: Vec<Box<ASTTreeNode>>, return_type: Option<CompleteType>, requires_this: bool },
 
 	ShadowFunctionDeclaration { func_name: HashedString, args: Vec<FunctionDeclarationArgument>, return_type: Option<CompleteType> },
 
@@ -74,7 +76,7 @@ impl ASTTreeNodeKind {
 
 	pub fn get_tree_name(&self) -> Option<HashedString> {
 		match self {
-			ASTTreeNodeKind::FunctionDeclaration { func_name, args: _, body: _, return_type: _ } => {
+			ASTTreeNodeKind::FunctionDeclaration { func_name, args: _, body: _, return_type: _ , requires_this: _} => {
 				return Some(HashedString::new(func_name.val.to_string()));
 			},
 

compiler/ast_parser/src/functions/arguments.rs

@@ -1,25 +1,44 @@
 //! Module for parsing arguments
 
-use ast::tree::FunctionDeclarationArgument;
-use compiler_errors::errs::CompilerResult;
+use ast::{tree::FunctionDeclarationArgument, types::CompleteType};
+use compiler_errors::errs::{CompilerResult, ErrorKind, normal::CompilerError};
+use compiler_utils::hash::HashedString;
 use lexer::token::{LexerToken, LexerTokenType};
 
 use crate::types::parse_type;
 
-pub fn parse_function_arguments(tokens: &Vec<LexerToken>, ind: &mut usize) -> CompilerResult<Vec<FunctionDeclarationArgument>> {
+pub fn parse_function_arguments(tokens: &Vec<LexerToken>, ind: &mut usize, struct_type: Option<CompleteType>) -> CompilerResult<(Vec<FunctionDeclarationArgument>, bool)> {
 	*ind += 1;
 
+	let mut depends_on_this: bool = false;
 	let mut args: Vec<FunctionDeclarationArgument> = Vec::new();
 
-	while *ind < tokens.len() && tokens[*ind].is_keyword() {
-		let var_type = parse_type(tokens, ind)?;
+	while *ind < tokens.len() && (tokens[*ind].is_keyword() || tokens[*ind].tok_type == LexerTokenType::This) {
+
+		if tokens[*ind].tok_type == LexerTokenType::This {
+			if struct_type.is_none() {
+				return Err(CompilerError::from_ast(ErrorKind::Error, "This requires to be within a struct!".to_string(), &tokens[*ind].pos, &tokens[*ind].get_end_pos()))
+			}
 
-		*ind += 1;
-		let var_name = tokens[*ind].expects_keyword()?;
+			if !args.is_empty() {
+				return Err(CompilerError::from_ast(ErrorKind::Error, "this must be the first parameter of the function.".to_string(), &tokens[*ind].pos, &tokens[*ind].get_end_pos()))
+			}
 
-		args.push(FunctionDeclarationArgument::new(var_name.0, var_type));
+			depends_on_this = true;
 
-		*ind += 1;
+			*ind += 1;
+
+			args.push(FunctionDeclarationArgument { name: HashedString::new("this".to_string()), argument_type: struct_type.clone().unwrap() })
+		} else {
+			let var_type = parse_type(tokens, ind)?;
+
+			*ind += 1;
+			let var_name = tokens[*ind].expects_keyword()?;
+
+			args.push(FunctionDeclarationArgument::new(var_name.0, var_type));
+
+			*ind += 1;
+		}
 
 		if tokens[*ind].tok_type == LexerTokenType::ParenClose {
 			break;
@@ -32,5 +51,5 @@ pub fn parse_function_arguments(tokens: &Vec<LexerToken>, ind: &mut usize) -> Co
 
 	tokens[*ind].expects(LexerTokenType::ParenClose)?;
 
-	Ok(args)
+	Ok((args, depends_on_this))
 }

compiler/ast_parser/src/functions/mod.rs

@@ -1,6 +1,6 @@
 //! Parser module for functions
 
-use ast::tree::{ASTTreeNode, ASTTreeNodeKind};
+use ast::{tree::{ASTTreeNode, ASTTreeNodeKind}, types::CompleteType};
 use compiler_errors::errs::CompilerResult;
 use compiler_utils::hash::HashedString;
 use lexer::token::{LexerToken, LexerTokenType};
@@ -11,7 +11,7 @@ pub mod shadow;
 pub mod arguments;
 pub mod returns;
 
-pub fn parse_function_declaraction(tokens: &Vec<LexerToken>, ind: &mut usize) -> CompilerResult<Box<ASTTreeNode>> {
+pub fn parse_function_declaraction(tokens: &Vec<LexerToken>, ind: &mut usize, struct_type: Option<CompleteType>) -> CompilerResult<Box<ASTTreeNode>> {
 	let start = tokens[*ind].pos.clone();
 
 	*ind += 1;
@@ -20,7 +20,7 @@ pub fn parse_function_declaraction(tokens: &Vec<LexerToken>, ind: &mut usize) ->
 	*ind += 1;
 	tokens[*ind].expects(LexerTokenType::ParenOpen)?;
 
-	let args = parse_function_arguments(tokens, ind)?;
+	let args = parse_function_arguments(tokens, ind, struct_type)?;
 
 	*ind += 1;
 
@@ -37,7 +37,7 @@ pub fn parse_function_declaraction(tokens: &Vec<LexerToken>, ind: &mut usize) ->
 
 	let end = tokens[*ind - 1].get_end_pos();
 
-	return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::FunctionDeclaration { func_name: HashedString::new(function_name.0), args, body, return_type: ret_type }, start, end)));
+	return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::FunctionDeclaration { func_name: HashedString::new(function_name.0), args: args.0, body, return_type: ret_type, requires_this: args.1 }, start, end)));
 }
 
 pub fn parse_function_call(tokens: &Vec<LexerToken>, ind: &mut usize) -> CompilerResult<Box<ASTTreeNode>> {

compiler/ast_parser/src/functions/shadow.rs

@@ -16,7 +16,7 @@ pub fn parse_shadow_function_declaration(tokens: &Vec<LexerToken>, ind: &mut usi
 	*ind += 1;
 	tokens[*ind].expects(LexerTokenType::ParenOpen)?;
 
-	let args = parse_function_arguments(tokens, ind)?;
+	let args = parse_function_arguments(tokens, ind, None)?;
 
 	*ind += 1;
 
@@ -32,5 +32,5 @@ pub fn parse_shadow_function_declaration(tokens: &Vec<LexerToken>, ind: &mut usi
 		end = tokens[*ind - 1].get_end_pos().clone();
 	}
 
-	return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::ShadowFunctionDeclaration { func_name: HashedString::new(function_name.0), args, return_type: ret_type }, start, end)))
+	return Ok(Box::new(ASTTreeNode::new(ASTTreeNodeKind::ShadowFunctionDeclaration { func_name: HashedString::new(function_name.0), args: args.0, return_type: ret_type }, start, end)))
 }

compiler/ast_parser/src/parser.rs

@@ -15,7 +15,7 @@ use crate::{control::{for_loop::parse_for_loop, if_else::parse_if_statement, whi
 pub fn parse_ast_node(tokens: &Vec<LexerToken>, ind: &mut usize) -> CompilerResult<Box<ASTTreeNode>> {
 	match &tokens[*ind].tok_type {
 		LexerTokenType::Function => {
-			return parse_function_declaraction(tokens, ind);
+			return parse_function_declaraction(tokens, ind, None);
 		},
 
 		LexerTokenType::ShadowFunction => {

compiler/ast_parser/src/structs/members.rs

@@ -11,8 +11,6 @@ pub fn parse_types_field_member(tokens: &Vec<LexerToken>, ind: &mut usize) -> Co
 	let start = tokens[*ind].pos.clone();
 	let member_type = parse_type(tokens, ind)?;
 
-	*ind += 1;
-
 	let field_name = tokens[*ind].expects_keyword()?;
 
 	let end = tokens[*ind].get_end_pos().clone();

compiler/ast_parser/src/structs/mod.rs

@@ -2,9 +2,9 @@ use compiler_errors::errs::CompilerResult;
 use compiler_utils::hash::HashedString;
 use lexer::token::{LexerToken, LexerTokenType};
 
-use ast::tree::{ASTTreeNode, ASTTreeNodeKind};
+use ast::{tree::{ASTTreeNode, ASTTreeNodeKind}, types::CompleteType};
 
-use crate::structs::members::parse_types_field_member;
+use crate::{functions::parse_function_declaraction, structs::members::parse_types_field_member};
 
 pub mod members;
 
@@ -22,8 +22,14 @@ pub fn parse_type_declaration(tokens: &Vec<LexerToken>, ind: &mut usize, layout:
 
 	let mut members: Vec<Box<ASTTreeNode>> = Vec::new();	
 
+	let temp_type = CompleteType { base_type: type_name.1, sizes: vec![], types: vec![], pointer: false, pointer_array: false, array_sz: 0 };
+
 	while tokens[*ind].tok_type != LexerTokenType::BracketClose {
-		members.push(parse_types_field_member(tokens, ind)?);
+		if tokens[*ind].tok_type == LexerTokenType::Function {
+			members.push(parse_function_declaraction(tokens, ind, Some(temp_type.clone()))?);
+		} else {
+			members.push(parse_types_field_member(tokens, ind)?);
+		}
 	}
 
 	let end = tokens[*ind].get_end_pos().clone();

compiler/astoir/Cargo.toml

@@ -5,6 +5,8 @@ edition = "2024"
 
 [dependencies]
 astoir_hir = {path = "../astoir_hir"}
+astoir_mir = {path = "../astoir_mir"}
 ast = { path = "../ast" }
 compiler_errors = { path = "../compiler_errors" }
-astoir_hir_lowering = { path = "../astoir_hir_lowering" }
+astoir_hir_lowering = { path = "../astoir_hir_lowering" }
+astoir_mir_lowering = { path = "../astoir_mir_lowering" }

compiler/astoir/src/lib.rs

@@ -1,12 +1,22 @@
 use ast::ctx::ParserCtx;
 use astoir_hir::ctx::HIRContext;
 use astoir_hir_lowering::lower_ast;
-use compiler_errors::errs::{CompilerResult};
+use astoir_mir::ctx::MIRContext;
+use astoir_mir_lowering::lower_hir;
+use compiler_errors::errs::{CompilerResult, normal::CompilerError};
 
 pub enum IRLevel {
-	HIR
+	HIR,
+	MIR
 }
 
 pub fn run_astoir_hir(ctx: ParserCtx) -> CompilerResult<HIRContext> {
 	return lower_ast(ctx);
 }
+
+pub fn run_astoir_mir(ctx: ParserCtx) -> CompilerResult<MIRContext> {
+	return match lower_hir(run_astoir_hir(ctx)?) {
+		Ok(v) => Ok(v),
+		Err(e) => Err(CompilerError::from_base_posless(e))
+	}
+}