Local types are now propely resolved

Author: FractalFir

src/assembly.rs

@@ -9,6 +9,7 @@ pub(crate) struct Assembly {
     name: IString,
 }
 impl Assembly {
+    
     pub(crate) fn into_il_ir(&self) -> IString {
         let mut methods = String::new();
         for method in &self.methods{
@@ -45,7 +46,8 @@ impl Assembly {
                 None => (),
             }
         }
-        clr_method.opt();
+        // Optimization is currently broken, and may produce invalid IR. 
+        //clr_method.opt();
         clr_method.typecheck();
         println!("clr_method:{clr_method:?}");
         println!("instance:{instance:?}\n");

src/base_ir.rs

@@ -12,10 +12,22 @@ pub(crate) enum BaseIR {
     Return,
 }
 impl BaseIR{
-    pub(crate) fn get_trivial_type(&self,parrent_method:&CLRMethod)->Option<VariableType>{
+    pub(crate) fn stack_change(&self)->i8{
+        match self{
+            Self::Add | Self::Mul | Self::Shl=>-1,
+            Self::Return=>-1,
+            Self::LDLoc(_)=>1,
+            Self::LDArg(_)=>1,
+            Self::STLoc(_)=>-1,
+            Self::STArg(_)=>-1,
+            Self::LDConstI32(_)=>-1,
+        }
+    }
+    pub(crate) fn get_trivial_type(&self,parent_method:&CLRMethod)->Option<VariableType>{
         match self{
             Self::LDConstI32(_)=>Some(VariableType::I32),
-            Self::LDArg(arg_id)=>Some(parrent_method.get_arg_type(*arg_id).clone()),
+            Self::LDLoc(var_id)=>parent_method.local_type(*var_id).cloned(),
+            Self::LDArg(arg_id)=>Some(parent_method.get_arg_type(*arg_id).clone()),
             _=>None,
         }
     }
@@ -28,7 +40,7 @@ impl BaseIR{
             Self::Add=>"\tadd\n".into(),
             Self::Mul=>"\tmul\n".into(),
             Self::Shl=>"\tshl\n".into(),
-            Self::LDConstI32(i32const)=>format!("ldc.i4 {i32const}\t\n"),
+            Self::LDConstI32(i32const)=>format!("\tldc.i4 {i32const}\t\n"),
             _=>format!("\t//Comment!\n"),
         }.into()
     }

src/clr_method.rs

@@ -23,6 +23,25 @@ enum LocalPlacement {
 }
 impl CLRMethod {
     fn name(&self)->&str{&self.name}
+    fn crosses_bb_border(&self,start:usize,end:usize)->bool{
+        false
+    }
+    fn backtrace_op_type(&self,op_pos:usize)->Option<&VariableType>{
+        let mut op_pos:isize = (op_pos as isize - 1);
+        let mut depth = -1;
+        while op_pos >= 0{
+            depth += self.ops[op_pos as usize].stack_change();
+            if(depth == 0){
+                return self.op_types[op_pos as usize].as_ref();
+            }
+            op_pos -= 1;
+        }
+        None
+    }
+    // This function returns the type of a local variable if it is known
+    pub(crate) fn local_type(&self,local:u32)->Option<&VariableType>{
+        self.locals.get(local as usize)?.as_ref()
+    }
     pub(crate) fn get_arg_type(&self,arg:u32)->&VariableType{
         &self.sig.inputs()[arg as usize]
     }
@@ -33,14 +52,52 @@ impl CLRMethod {
             }
         }
     }
+    fn set_local_types(&mut self){
+        for index in 0..(self.op_types.len()){
+            if let BaseIR::STLoc(index) = self.ops[index as usize]{
+                if let Some(var_type) = &self.op_types[index as usize]{
+                    while self.locals.len() < index as usize + 1{self.locals.push(None)};
+                    self.locals[index as usize] = Some(var_type.clone());
+                }
+            }
+        }
+    }
+    fn backtrace_types(&mut self){
+        for index in 0..(self.op_types.len()){
+            if let None = self.op_types[index]{
+                self.op_types[index] = self.backtrace_op_type(index).cloned();
+            }
+        }
+    }
     pub(crate) fn typecheck(&mut self){
         while self.op_types.len() < self.ops.len(){
             self.op_types.push(None);      
         }
-        
-        self.set_trivial_types();
+        for _ in 0..0x100{
+            self.set_trivial_types();
+            self.backtrace_types();
+            self.set_local_types();
+            if self.op_types.iter().all(|t| t.is_some()){break;}
+        }
         println!("op_types:{:?}",self.op_types);
     }
+    pub(crate) fn locals_init(&self)->IString{
+        if self.locals.is_empty(){
+            return "".into();     
+        }
+        let mut locals = String::new();
+        let mut locals_iter = self.locals.iter().enumerate();
+        match locals_iter.next(){
+            Some((index,first))=>{
+                locals.push_str(&format!("\n\t\t[{index}] {loc_type}",loc_type = first.as_ref().expect("UNRESOLVED LOCAL DURING IL EMISSION!").il_name()))
+            }
+            None=>(),
+        }
+        for (index,local) in locals_iter{
+            locals.push_str(&format!(",\n\t\t[{index}] {loc_type}",loc_type = local.as_ref().expect("UNRESOLVED LOCAL DURING IL EMISSION!").il_name()))
+        }
+        format!("\t.locals init({locals}\n\t)").into()
+    }
     pub(crate) fn into_il_ir(&self)->String{
         let output = self.sig.output().il_name();
         let mut arg_list = String::new();
@@ -57,20 +114,20 @@ impl CLRMethod {
         for op in &self.ops{
             ops_ir.push_str(&op.clr_ir());
         }
-        format!(".method public static {output} {name}({arg_list}){{\n{ops_ir}}}\n",name = self.name())
+        format!(".method public static {output} {name}({arg_list}){{\n{locals_init}\n{ops_ir}}}\n",name = self.name(),locals_init = self.locals_init())
     }
     fn argc(&self) -> u32 {
         self.sig.inputs().len() as u32
     }
     fn remove_sl(&mut self) -> usize {
         let mut opt_ops: Vec<BaseIR> = Vec::with_capacity(self.ops.len());
-        let mut ops_peek = self.ops.iter().peekable();
-        while let Some(op) = ops_peek.next() {
+        let mut ops_peek = self.ops.iter().enumerate().peekable();
+        while let Some((index,op)) = ops_peek.next() {
             match op {
                 BaseIR::STLoc(local_id) => {
-                    if let Some(BaseIR::LDLoc(other_id)) = ops_peek.peek() {
+                    if let Some((next_index,BaseIR::LDLoc(other_id))) = ops_peek.peek() {
                         //Ops store and the load the same value, being effectively a NOP.
-                        if local_id == other_id {
+                        if local_id == other_id && !self.crosses_bb_border(index,*next_index) {
                             ops_peek.next();
                             continue;
                         }

test/identity.rs

@@ -3,6 +3,17 @@ pub extern fn add(a:i32)->i32{a+a}
 pub extern fn add2(a:i32,b:i32)->i32{a + b}
 pub extern fn sqr_mag(ax:i32,ay:i32)->i32{ax*ax + ay*ay}
 pub extern fn pow2(power:i32)->i32{1<<power}
+/*
+pub extern fn factorial(mut n:i32)->i32{
+    let mut factorial = 1;
+    while n > 1{
+        factorial *= n;
+        n-=1;
+    }
+    //for x in 0..100{}
+    factorial
+}*/
+//pub extern fn call_pow2(power:i32)->i32{ let val = pow2(power); val}
 struct Vector3{x:f32,y:f32,z:f32}
 /*
 impl std::ops::Add for Vector3{