[STYLE] moving code into their own sub files

src/IR/mod.rs

@@ -5,8 +5,11 @@ mod builder;
 mod block;
 mod var;
 mod constant;
+mod nodes;
 /// Stores all ir nodes and the ir trait
-pub mod ir;
+pub mod ir {
+    pub use super::nodes::*;
+}
 
 use std::error::Error;
 use std::fmt::Display;

src/IR/nodes/assign.rs

@@ -0,0 +1,164 @@
+use super::*;
+
+impl Ir for ConstAssign<Var, Type> {
+    fn dump(&self) -> String {
+        let meta: TypeMetadata = self.inner2.into();
+        format!("{} = {} {}", self.inner1.name, meta, self.inner2.val())
+    }
+
+    fn dumpColored(&self, profile: ColorProfile) -> String {
+        let meta: TypeMetadata = self.inner2.into();
+        format!("{} = {} {}", 
+            profile.markup(&self.inner1.name, ColorClass::Var), 
+            profile.markup(&meta.to_string(), ColorClass::Instr), 
+            profile.markup(&self.inner2.val().to_string(), ColorClass::Value),
+        )
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn verify(&self, _: FunctionType) -> Result<(), VerifyError> {
+        let op0Ty = self.inner1.ty;
+        let op1Ty = self.inner2.into();
+        if op0Ty != op1Ty {
+            Err(VerifyError::Op0Op1TyNoMatch(op0Ty, op1Ty))?
+        }
+
+        Ok(())
+    }
+
+    fn clone_box(&self) -> Box<dyn Ir> {
+        Box::new(self.clone())
+    }
+
+    fn compile(&self, registry: &mut TargetBackendDescr) -> Vec<Instr> {
+        registry.getCompileFuncForConstAssign()(self, registry)
+    }
+
+    fn uses(&self, var: &Var) -> bool {
+        if *var == self.inner1 { true }
+        else { false }
+    }
+}
+
+impl Ir for ConstAssign<Var, Var> {
+    fn dump(&self) -> String {
+        let meta: TypeMetadata = self.inner2.ty;
+        format!("{} = {} {}", self.inner1.name, meta, self.inner2.name)
+    }
+
+    fn dumpColored(&self, profile: ColorProfile) -> String {
+        let meta: TypeMetadata = self.inner2.ty;
+        format!("{} = {} {}", 
+            profile.markup(&self.inner1.name, ColorClass::Var), 
+            profile.markup(&meta.to_string(), ColorClass::Instr), 
+            profile.markup(&self.inner2.name.to_string(), ColorClass::Value),
+        )
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn verify(&self, _: FunctionType) -> Result<(), VerifyError> {
+        let op0Ty = self.inner1.ty;
+        let op1Ty = self.inner2.ty;
+        if op0Ty != op1Ty {
+            Err(VerifyError::Op0Op1TyNoMatch(op0Ty, op1Ty))?
+        }
+
+        Ok(())
+    }
+
+    fn clone_box(&self) -> Box<dyn Ir> {
+        Box::new(self.clone())
+    }
+
+    fn compile(&self, registry: &mut TargetBackendDescr) -> Vec<Instr> {
+        registry.getCompileFuncForConstAssignVar()(self, registry)
+    }
+
+    fn uses(&self, var: &Var) -> bool {
+        if *var == self.inner1 { true }
+        else if *var == self.inner2 { true }
+        else { false }
+    }
+}
+
+impl Ir for ConstAssign<Var, Const> {
+    fn dump(&self) -> String {
+        format!("{} = ptr {}", self.inner1.name, self.inner2.name)
+    }
+
+    fn dumpColored(&self, profile: ColorProfile) -> String {
+        format!("{} = {} {}", 
+            profile.markup(&self.inner1.name, ColorClass::Var), 
+            profile.markup("ptr", ColorClass::Ty), 
+            profile.markup(&self.inner2.name.to_string(), ColorClass::Value),
+        )
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn verify(&self, _: FunctionType) -> Result<(), VerifyError> {
+        Ok(())
+    }
+
+    fn clone_box(&self) -> Box<dyn Ir> {
+        Box::new(self.clone())
+    }
+
+    fn compile(&self, registry: &mut TargetBackendDescr) -> Vec<Instr> {
+        registry.getCompileFuncForConstAssignConst()(self, registry)
+    }
+
+    fn uses(&self, var: &Var) -> bool {
+        if *var == self.inner1 { true }
+        else { false }
+    }
+}
+
+/// Trait used for overloading the BuildAssign function
+pub trait BuildAssign<T> {
+    /// builds an assignment
+    fn BuildAssign(&mut self, value: T) -> Var;
+}
+impl BuildAssign<Type> for IRBuilder<'_> {
+    fn BuildAssign(&mut self, value: Type) -> Var {
+        let block = self.blocks.get_mut(self.curr).expect("the IRBuilder needs to have an current block\nConsider creating one");
+
+        let out = Var::new(block, value.into());
+
+        block.push_ir(ConstAssign::new(out.clone(), value));
+
+        out
+    }
+}
+
+impl BuildAssign<Var> for IRBuilder<'_> {
+    fn BuildAssign(&mut self, value: Var) -> Var {
+        let block = self.blocks.get_mut(self.curr).expect("the IRBuilder needs to have an current block\nConsider creating one");
+
+        let out = Var::new(block, value.ty);
+
+        block.push_ir(ConstAssign::new(out.clone(), value));
+
+        out
+    }
+}
+
+impl BuildAssign<&Const> for IRBuilder<'_> {
+    fn BuildAssign(&mut self, value: &Const) -> Var {
+        let block = self.blocks.get_mut(self.curr).expect("the IRBuilder needs to have an current block\nConsider creating one");
+
+        let out = Var::new(block, TypeMetadata::ptr);
+
+        block.push_ir(ConstAssign::new(out.clone(), value.clone()));
+
+        out
+    }
+}

src/IR/nodes/call.rs

@@ -0,0 +1,103 @@
+use super::*;
+
+impl Ir for Call<Function, Vec<Var>, Var> {
+    fn dump(&self) -> String {
+        let mut fmt = String::new();
+
+        for arg in &self.inner2 {
+            fmt.push_str(&format!("{} ", arg))
+        }
+
+        format!("{} = call {} {} {}", self.inner3.name, self.inner1.ty.ret, self.inner1.name, fmt)
+    }
+
+    fn dumpColored(&self, profile: ColorProfile) -> String {
+        let mut fmt = String::new();
+
+        for arg in &self.inner2 {
+            fmt.push_str(&arg.to_colored_string(profile));
+            fmt.push(' ');
+        }
+
+        format!("{} = {} {} {} {}", 
+            profile.markup(&self.inner3.name, ColorClass::Var),
+            profile.markup("call", ColorClass::Instr),
+            profile.markup(&self.inner1.ty.ret.to_string(), ColorClass::Ty),
+            profile.markup(&self.inner1.name, ColorClass::Name),
+            fmt
+        )
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn verify(&self, _: FunctionType) -> Result<(), VerifyError> {
+        if self.inner3.ty != self.inner1.ty.ret {
+            Err(VerifyError::Op0Op1TyNoMatch(self.inner3.ty, self.inner1.ty.ret))?
+        }
+
+        let mut index = 0;
+        let args = &self.inner1.ty.args;
+        for arg in &self.inner2 {
+            if index < args.len() {
+                if matches!(args.get(index), Some((_, argty)) if *argty != (*arg).ty.into()) {
+                    Err(VerifyError::InvalidArgumentTypeFound)?
+                }
+            } else {
+                if !self.inner1.ty.any_args {
+                    Err(VerifyError::ToManyArgumentsWereSupplyed)?
+                }
+            }
+
+            index += 1;
+        }
+
+        Ok(())
+    }
+
+    fn clone_box(&self) -> Box<dyn Ir> {
+        Box::from( self.clone() )
+    }
+
+    fn compile(&self, registry: &mut TargetBackendDescr) -> Vec<Instr> {
+        registry.getCompileFuncForCall()(self, registry)
+    }
+
+    fn uses(&self, var: &Var) -> bool {
+        let mut uses = false;
+
+        if self.inner3 == *var {
+            uses = true;
+        }
+
+
+        for arg in &self.inner2 {
+            if *arg == *var {
+                uses = true;
+            }
+        }
+
+        uses
+    }
+}
+
+
+
+/// Trait for the call instruction
+/// Used for overloading the BuildCall function
+pub trait BuildCall<T, U> {
+    /// builds a function call
+    fn BuildCall(&mut self, func: T, args: U) -> Var;
+}
+impl BuildCall<&Function, Vec<Var>> for IRBuilder<'_> {
+    fn BuildCall(&mut self, func: &Function, args: Vec<Var>) -> Var {
+        let block = self.blocks.get_mut(self.curr).expect("the IRBuilder needs to have an current block\nConsider creating one");
+
+        let out = Var::new(block, func.ty.ret);
+
+        block.push_ir(Call::new(func.clone(), args, out.clone()));
+
+        out 
+    }
+}

src/IR/nodes/cast.rs

@@ -0,0 +1,63 @@
+use super::*;
+
+impl Ir for Cast<Var, TypeMetadata, Var> {
+    fn dump(&self) -> String {
+        format!("{} = cast {} to {}", self.inner3.name, self.inner1.name, self.inner2)
+    }
+
+    fn dumpColored(&self, profile: ColorProfile) -> String {
+        format!("{} = {} {} {} {}", 
+            profile.markup(&self.inner3.name, ColorClass::Var), 
+            profile.markup(&"cast", ColorClass::Instr),
+            profile.markup(&self.inner1.name, ColorClass::Var), 
+            profile.markup(&"to", ColorClass::Instr),
+            profile.markup(&self.inner2.to_string(), ColorClass::Ty),
+        )
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn verify(&self, _: FunctionType) -> Result<(), VerifyError> {
+        if self.inner3.ty != self.inner2 {
+            Err(VerifyError::Op0Op1TyNoMatch(self.inner3.ty, self.inner2))?
+        }
+        Ok(())
+    }
+
+    fn uses(&self, var: &Var) -> bool {
+        let var = var.to_owned();
+
+        if var == self.inner1 || var == self.inner3 {
+            true
+        } else { false }
+    }
+
+    fn clone_box(&self) -> Box<dyn Ir> {
+        Box::from( self.clone() )
+    }
+
+    fn compile(&self, registry: &mut TargetBackendDescr) -> Vec<Instr> {
+        registry.getCompileFuncForCastTyVar()(self, registry)
+    }
+}
+
+/// Trait for the cast instruction
+/// Used for overloading the BuildCast function
+pub trait BuildCast<T, U> {
+    /// builds an cast to form one variable into another type
+    fn BuildCast(&mut self, var: T, ty: U) -> Var;
+}
+
+impl BuildCast<Var, TypeMetadata> for IRBuilder<'_> {
+    fn BuildCast(&mut self, var: Var, ty: TypeMetadata) -> Var {
+        let block = self.blocks.get_mut(self.curr).expect("the IRBuilder needs to have an current block\nConsider creating one");
+
+        let out = Var::new(block, ty);
+
+        block.push_ir(Cast::new(var, ty, out.clone()));
+
+        out
+    }
+}