feat: Quickfall IR systems

.gitignore

@@ -1 +1,5 @@
-target/
+target/
+*.ll
+
+out
+out.*

commons/src/err/mod.rs

@@ -9,6 +9,7 @@ use colored::Colorize;
 use crate::Position;
 
 pub type PositionedResult<K> = Result<K, PositionedError>;
+pub type PositionlessResult<K> = Result<K, PositionlessError>;
 
 /// An error that has a position
 #[derive(Debug)]
@@ -18,6 +19,21 @@ pub struct PositionedError {
 	pub reason: String
 }
 
+#[derive(Debug)]
+pub struct PositionlessError {
+	pub reason: String
+}
+
+impl PositionlessError {
+	pub fn new(reason: &str) -> Self {
+		let err = PositionlessError { reason: String::from(reason) };
+
+		println!("{}", err);
+
+		return err;
+	}
+}
+
 impl PositionedError {
 	pub fn new(start: Position, end: Position, reason: String) -> Self {
 
@@ -48,6 +64,16 @@ impl fmt::Display for PositionedError {
 		writeln!(f, "")?;
 		writeln!(f, "{}", self.reason.bright_red())?;
 
+		Ok(())
+	}
+}
+
+impl fmt::Display for PositionlessError {
+	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+		writeln!(f, "{} at ??:??", "ERR".bright_red().bold())?;
+
+		writeln!(f, "{}", self.reason.bright_red())?;
+
 		Ok(())
 	}
 }

commons/src/utils/map.rs

@@ -114,6 +114,21 @@ impl<V> HashedMap<V> {
         return None;
 	}
 
+	pub fn entries(&self) -> Vec<&(u64, V)> {
+		let mut vec = Vec::new();
+
+		for i in 0..self.capacity {
+			if self.meta[i] == BUCKET_EMPTY || self.meta[i] == BUCKET_TOMBSTONE {
+				continue;
+			}
+
+			unsafe { vec.push(self.buckets[i].assume_init_ref()); }
+		}
+
+		return vec;
+	}
+
+
 	pub fn erase(&mut self, key: u64) {
         let index = self.index_from_hash(key);
         let fingerprint = self.fingerprint_from_hash(key);

commons/src/utils/mod.rs

@@ -1 +1,2 @@
-pub mod map;
+pub mod map;
+pub mod num;

commons/src/utils/num.rs

@@ -0,0 +1,19 @@
+pub fn get_signed_highbound(bits: usize) -> i128 {
+	return 2_i128.pow(bits as u32 - 1) - 1;
+}
+
+pub fn get_signed_lowbound(bits: usize) -> i128 {
+	return 0 - 2_i128.pow(bits as u32 - 1) - 1;
+}
+
+pub fn get_unsigned_highbound(bits: usize) -> i128 {
+	return 2_i128.pow(bits as u32) - 1;
+}
+
+pub fn can_num_fit_inbits_signed(bits: usize, num: i128) -> bool {
+	return num >= get_signed_lowbound(bits) && num <= get_signed_highbound(bits);
+}
+
+pub fn can_num_fit_inbits_unsigned(bits: usize, num: i128) -> bool {
+	return num >= 0 && num <= get_unsigned_highbound(bits);
+}

ir/Cargo.toml

@@ -5,4 +5,6 @@ edition = "2024"
 
 [dependencies]
 inkwell = { version = "0.8.0", features = ["llvm21-1"]}
-commons = { path = "../commons" }
+commons = { path = "../commons" }
+lexer = { path = "../lexer" }
+parser = { path = "../parser" }

ir/src/conv/mod.rs

@@ -0,0 +1,3 @@
+//! Critical AST -> IR conversion code module
+
+pub mod val;

ir/src/conv/val.rs

@@ -0,0 +1,22 @@
+//! AST value -> IR value conversion
+
+use commons::err::{PositionedError, PositionedResult, PositionlessError, PositionlessResult};
+use parser::ast::tree::ASTTreeNode;
+
+use crate::{ctx::{IRContext, IRLocalContext}, irstruct::{ptr::IRPointer, staticvars::IRStaticVariable}, refs::IRValueRef};
+
+pub fn get_variable_ref<'a>(lctx: &'a IRLocalContext<'a>, ctx: &'a IRContext<'a>, hash: u64) -> PositionlessResult<IRValueRef<'a>> {
+	match ctx.get_variable(hash) {
+		Ok(v) => return Ok(IRValueRef::from_static(IRStaticVariable::clone(v))),
+		Err(_) => {}
+	};
+
+	match lctx.get_variable(hash) {
+		Ok(v) => return Ok(IRValueRef::from_pointer(IRPointer::clone(v))),
+		Err(_) => return Err(PositionlessError::new(&format!("Cannot find variable with hash {} in the current context", hash)))
+	};
+}
+
+pub fn parse_ir_chain_access<'a>(node: Box<ASTTreeNode>, lctx: &'a IRLocalContext<'a>, ctx: &'a IRContext<'a>) -> PositionlessResult<bool> {
+
+}

ir/src/ctx.rs

@@ -0,0 +1,111 @@
+//! IR context related code
+
+use core::hash;
+use std::ops::Add;
+
+use commons::{err::{PositionlessError, PositionlessResult}, utils::map::HashedMap};
+use inkwell::{AddressSpace, builder::Builder, context::Context, types::PointerType};
+
+use crate::irstruct::{funcs::IRFunction, ptr::IRPointer, staticvars::IRStaticVariable};
+
+/// The global IR context.
+/// Basically holds anything related to the current IR compilation (eg: functions, types, global vars)
+pub struct IRContext<'a> {
+	pub inkwell_ctx: &'a Context,
+	pub builder: Builder<'a>,
+	pub ptr_type: PointerType<'a>,
+
+	pub functions: HashedMap<IRFunction<'a>>,
+	pub static_vars: HashedMap<IRStaticVariable<'a>>
+}
+
+impl<'a> IRContext<'a> {
+	pub fn new(builder: Builder<'a>, ctx: &'a Context) -> Self {
+		return IRContext { inkwell_ctx: ctx, builder, ptr_type: ctx.ptr_type(AddressSpace::from(0)), functions: HashedMap::new(0), static_vars: HashedMap::new(0) }
+	}
+
+	pub fn add_variable(&'a mut self, hash: u64, var: IRStaticVariable<'a>) -> PositionlessResult<bool> {
+		if self.static_vars.get(hash).is_some() {
+			return Err(PositionlessError::new(&format!("Variable named {} is already registered in the current context.", hash)));
+		}
+
+		self.static_vars.put(hash, var);
+		return Ok(true);
+	}
+
+	pub fn get_variable(&'a self, hash: u64) -> PositionlessResult<&'a IRStaticVariable<'a>> {
+		return match self.static_vars.get(hash) {
+			Some(v) => Ok(v),
+			None => return Err(PositionlessError::new("Invalid variable name"))
+		};
+	}
+}
+
+pub struct LocalIRVariable<'a> {
+	pub ptr: IRPointer<'a>,
+	pub depth: usize // Depth is depth in body.
+}
+
+/// The local IR context.
+/// Holds anything held and created in the given body (eg: vars).
+pub struct IRLocalContext<'a> {
+	pub vars: HashedMap<LocalIRVariable<'a>>,
+	pub current_depth: usize // Starts at 0 where 0 is function body
+}
+
+impl<'a> IRLocalContext<'a> {
+	pub fn new() -> Self {
+		return IRLocalContext { vars: HashedMap::new(0), current_depth: 0 }
+	}	
+
+	/// Attempts to add a variable in the current local context. Will return an error if the operation is impossible
+	pub fn add_variable(&mut self, hash: u64, var: IRPointer<'a>) -> PositionlessResult<bool> {
+		if self.vars.get(hash).is_some() {
+			return Err(PositionlessError::new(&format!("Variable named {} is already registered in the current context.", hash)));
+		}
+
+		self.vars.put(hash, LocalIRVariable { ptr: var, depth: self.current_depth });
+		return Ok(true);
+	}
+
+	pub fn get_variable(&'a self, hash: u64) -> PositionlessResult<&'a IRPointer<'a>> {
+		return match self.vars.get(hash) {
+			Some(v) => Ok(&v.ptr),
+			None => return Err(PositionlessError::new("Invalid variable name"))
+		};
+	}
+
+	pub fn increment_body_depth(&mut self) {
+		self.current_depth += 1;
+	}
+
+	/// Ends the current nested body. Is responsible for removing non-valid variable indices
+	/// Example:
+	/// ```
+	/// func test() {
+	/// 	// body of depth 0 starts
+	/// 	if(true) {
+	/// 		// body of depth 1 starts
+	/// 		// body of depth 1 ends
+	/// 	}
+	/// 
+	/// 	// body of depth 0 ends
+	/// }
+	/// ```
+	pub fn end_nested_body_depth(&mut self) {
+		self.current_depth -= 1;
+
+		let mut hashToRemove: Vec<u64> = vec![];
+
+		for entry in self.vars.entries() {
+			if entry.1.depth > self.current_depth {
+				hashToRemove.push(entry.0);
+			}
+		}
+
+		for hash in hashToRemove {
+			self.vars.erase(hash);
+		}
+	}
+
+}

ir/src/irstruct/funcs.rs

@@ -0,0 +1,82 @@
+use commons::err::{PositionedError, PositionlessError, PositionlessResult};
+use inkwell::{basic_block::BasicBlock, builder::Builder, context::Context, module::Module, types::BasicType, values::{BasicValueEnum, FunctionValue, IntValue}};
+
+use crate::types::typing::IRType;
+
+pub struct IRFunction<'a> {
+	pub inkwell_func: FunctionValue<'a>,
+	ret_type: &'a IRType<'a>,
+	args: Vec<&'a IRType<'a>>,
+	name: String,
+
+	entry: Option<BasicBlock<'a>>
+}
+
+impl<'a> IRFunction<'a> {
+	pub fn new(ctx: &'a Context, name: String, func: FunctionValue<'a>, ret_type: &'a IRType<'a>, args: Vec<&'a IRType<'a>>) -> Self {
+
+		let block = ctx.append_basic_block(func, "entry");
+
+		return IRFunction { inkwell_func: func, ret_type, args, name, entry: Some(block) }
+	}
+
+	pub fn new_shadow(name: String, func: FunctionValue<'a>, ret_type: &'a IRType<'a>, args: Vec<&'a IRType<'a>>) -> Self {
+		return IRFunction { inkwell_func: func, ret_type, args, name, entry: None }
+	}
+
+	pub fn create_shadow(name: String, module: &Module<'a>, ret_type: &'a IRType<'a>, args: Vec<&'a IRType<'a>>) -> PositionlessResult<Self> {
+		let mut kargs = vec![];
+
+		for k in &args {
+			kargs.push(k.get_inkwell_base_metadatatype()?);
+		}
+
+		let t = ret_type.get_inkwell_basetype()?.fn_type(&kargs, false);
+
+		let func = module.add_function(&name, t, None);
+
+		return Ok(IRFunction::new_shadow(name, func, ret_type, args));
+	}
+
+	pub fn create(ctx: &'a Context, name: String, module: &Module<'a>, ret_type: &'a IRType<'a>, args: Vec<&'a IRType<'a>>) -> PositionlessResult<Self> {
+		let mut kargs = vec![];
+
+		for k in &args {
+			kargs.push(k.get_inkwell_base_metadatatype()?);
+		}
+
+		let t = ret_type.get_inkwell_basetype()?.fn_type(&kargs, false);
+
+		let func = module.add_function(&name, t, None);
+
+		return Ok(IRFunction::new(ctx, name, func, ret_type, args));
+	}
+
+	/// Prepares the addition of the function body.
+	pub fn prepare_body_filling(&self, builder: &Builder<'a>) {
+		if self.entry.is_none() {
+			return;
+		}
+
+		builder.position_at_end(self.entry.unwrap());
+	}
+
+	pub fn get_nth_arg(&self, ind: u32) -> PositionlessResult<BasicValueEnum<'a>> {
+		let res = match self.inkwell_func.get_nth_param(ind) {
+			Some(v) => v,
+			None => return Err(PositionlessError::new("Couldn't get nth param using get_nth_param"))
+		};
+
+		return Ok(res);
+	}
+
+	pub fn get_nth_arg_int(&self, ind: u32) -> PositionlessResult<IntValue<'a>> {
+		if !self.args[ind as usize].is_numeric_type() {
+			return Err(PositionlessError::new("Tried getting nth argument but given argument's type isn't numeric!"));
+		}
+
+		return Ok(self.get_nth_arg(ind)?.into_int_value());
+
+	}
+
+}

ir/src/irstruct/mod.rs

@@ -0,0 +1,6 @@
+//! Common definitions used internally to structure the IR.
+
+pub mod ptr;
+pub mod funcs;
+pub mod staticvars;
+pub mod structs;