Update compiler

Author: playXE

src/gccjit.rs

@@ -276,7 +276,7 @@ impl<'a> Codegen<'a>
                     }
                     let ty = if struct_.union
                     {
-                        println!("UNION!");
+
                         self.ctx
                             .new_union_type(None, &str(struct_.name).to_string(), &fields)
                     }
@@ -1324,15 +1324,7 @@ impl<'a> Codegen<'a>
                     .map(|expr| self.get_id_type(expr.id).clone())
                     .collect::<Vec<_>>();
 
-                let var = if let Some(var) = self.variables.get(&name.name())
-                {
-                    var.lval
-                }
-                else if let Some(var) = self.variables.get(&name.name())
-                {
-                    var.lval
-                }
-                else if let Some(functions) = self.functions.get(&name.name())
+                let var = if let Some(functions) = self.functions.get(&name.name())
                 {
                     let functions = functions.clone();
                     let ty = if let Some(this) = this
@@ -1384,16 +1376,18 @@ impl<'a> Codegen<'a>
 
                     if this.is_some()
                     {
+
                         let expr = this.clone().unwrap().clone();
                         let ty = self.get_id_type(expr.id);
                         let val = if !ty.is_ptr()
                         {
+                            let cty = self.ty_to_ctype(&ty).make_pointer();
                             let val = self.gen_expr(&Expr {
                                 pos: expr.pos,
                                 id: expr.id,
                                 kind: ExprKind::AddressOf(expr),
                             });
-
+                            let val = self.ctx.new_cast(None,val,cty);
                             val
                         }
                         else
@@ -1467,9 +1461,15 @@ impl<'a> Codegen<'a>
                         &params,
                     );
                 }
+
+                else if let Some(var) = self.variables.get(&name.name())
+                {
+                    var.lval
+                }
+
                 else
                 {
-                    panic!()
+                    panic!();
                 };
 
                 let mut params = vec![];

src/semantic.rs

@@ -682,8 +682,8 @@ impl<'a> SemCheck<'a>
     {
         let _id = stmt.id;
         match &stmt.kind
+
         {
-            StmtKind::CompTime(stmt) => self.tc_stmt(stmt),
             StmtKind::CFor(var, cond, then, body) =>
             {
                 let prev;
@@ -830,15 +830,22 @@ impl<'a> SemCheck<'a>
                 self.vars.pop();
             }
             StmtKind::Loop(stmt) => self.tc_stmt(stmt),
+            _ => unimplemented!(),
         };
     }
 
     pub fn tc_expr(&mut self, expr: &Expr) -> Type
     {
         match &expr.kind
         {
-            ExprKind::MacroCall(_,_) => unreachable!(),
-            ExprKind::CompTime(c) => self.tc_expr(c),
+            ExprKind::CompTime(e) => {
+                let ty = self.tc_expr(e);
+                let ty = self.infer_type(&ty);
+                self.types.insert(expr.id,ty.clone());
+
+                return ty;
+
+            }
             ExprKind::New(ty) =>
             {
                 let infered = self.infer_type(ty);
@@ -1458,6 +1465,7 @@ impl<'a> SemCheck<'a>
                 result_type
             }
             ExprKind::Array(_, _) => unimplemented!(),
+            _ => unreachable!(),
         }
     }
 }