Fix consteval a bit

Author: Victorious3

src/builtins.pr

@@ -77,21 +77,37 @@ export let bool_ = bool_t.id
 export let string_ = typechecking::array(char_)
 scope::create_type(builtins, parser::make_identifier("string"), parser::ShareMarker::EXPORT, typechecking::make_type_ref(string_))
 
-export let float_   = create_float_type("float", size_of float)
-export let double_  = create_float_type("double", size_of double)
+export def get_int_of_size(size: size_t, unsig: bool) -> typechecking::TypeId {
+    if unsig {
+        switch size {
+            case 1; return uint8_
+            case 2; return uint16_
+            case 4; return uint32_
+            case 8; return uint64_
+            case 16; return uint128_
+        }
+    } else {
+        switch size {
+            case 1; return int8_
+            case 2; return int16_
+            case 4; return int32_
+            case 8; return int64_
+            case 16; return int128_
+        }
+    }
+    return 0 
+}
+
+def register(name: Str, tpe: typechecking::TypeId) -> typechecking::TypeId {
+    scope::create_type(builtins, parser::make_identifier(name), parser::ShareMarker::EXPORT, typechecking::make_type_ref(tpe))
+    return tpe
+}
+
 export let float32_ = create_float_type("float32", size_of float32)
 export let float64_ = create_float_type("float64", size_of float64)
 export let float80_ = create_float_type("float80", size_of float80)
-
-export let byte_    = create_int_type("byte", size_of byte, false)
-export let short_   = create_int_type("short", size_of short, false)
-export let int_     = create_int_type("int", size_of int, false)
-export let long_    = create_int_type("long", size_of long, false)
-
-export let ubyte_   = create_int_type("ubyte", size_of ubyte, true)
-export let ushort_  = create_int_type("ushort", size_of ushort, true)
-export let uint_    = create_int_type("uint", size_of uint, true)
-export let ulong_   = create_int_type("ulong", size_of ulong, true)
+export let float_   = register("float", float32_)
+export let double_  = register("double", float64_)
 
 export let int8_    = create_int_type("int8", size_of int8, false)
 export let int16_   = create_int_type("int16", size_of int16, false)
@@ -105,7 +121,17 @@ export let uint32_  = create_int_type("uint32", size_of uint32, true)
 export let uint64_  = create_int_type("uint64", size_of uint64, true)
 export let uint128_ = create_int_type("uint128", 16, true)
 
-export let size_t_  = create_int_type("size_t", size_of size_t, true)
+export let byte_    = register("byte", get_int_of_size(size_of byte, false))
+export let short_   = register("short", get_int_of_size(size_of short, false))
+export let int_     = register("int", get_int_of_size(size_of int, false))
+export let long_    = register("long", get_int_of_size(size_of long, false))
+
+export let ubyte_   = register("ubyte", get_int_of_size(size_of ubyte, true))
+export let ushort_  = register("ushort", get_int_of_size(size_of ushort, true))
+export let uint_    = register("uint", get_int_of_size(size_of uint, true))
+export let ulong_   = register("ulong", get_int_of_size(size_of ulong, true))
+
+export let size_t_  = register("size_t", create_int_type("size_t", size_of size_t, true))
 
 #if not defined WIN32 {
     let va_list_ident = parser::make_identifier("__va_list_tag")

src/consteval.pr

@@ -814,7 +814,7 @@ export def compile_function(value: &scope::Value, context: &scope::Scope, argume
     var node = value.node
     var module = value.module
 
-    var is_repurposed = false // When There's no node and we find a new function we don't need to typecheck anymore
+    /*var is_repurposed = false // When There's no node and we find a new function we don't need to typecheck anymore
     if not node {
         if not arguments { return value }
 
@@ -831,10 +831,10 @@ export def compile_function(value: &scope::Value, context: &scope::Scope, argume
             return value 
         }
         module = new_value.module
-    }
+    }*/
 
     var function = node.value.def_.function
-    if function.is_typechecked and not is_repurposed { return value }
+    //if function.is_typechecked and not is_repurposed { return value }
 
     let is_polymorph = typechecking::is_polymorph(function.fdef.parameter_t)
     if not is_polymorph { 

src/eval.pr

@@ -185,7 +185,8 @@ export def get(mem: *, tpe: &typechecking::Type) -> compiler::Value {
 
 export def get_address(loc: compiler::Value, state: &State) -> * {
     if loc.kind == compiler::ValueKind::LOCAL {
-        let mem = get_stack_frame(state).locals.get_or_default(loc.name, null)
+        let frame = get_stack_frame(state)
+        let mem = frame.locals.get_or_default(loc.name, null)
         if not mem {
             errors::errorv("Couldn't find memory for `", loc.name, "`")
         }
@@ -250,7 +251,6 @@ def set(mem: *, tpe: &typechecking::Type, value: compiler::Value) {
         errors::errorv("Tried to assign a null pointer")
         return
     }
-    if not tpe { return }
     if value.kind == compiler::ValueKind::UNDEF { return }
     if value.kind == compiler::ValueKind::ZEROINITIALIZER {
         cstd::memset(mem, 0, tpe.size)
@@ -538,7 +538,7 @@ def eval_Alloca(insn: &compiler::Insn, state: &State) {
     let mem = frame.mem.allocate(size) // TODO: We shouldn't have to initialize this
     ret.tpe = typechecking::pointer(ret.tpe)
     let ptr = [ kind = compiler::ValueKind::POINTER, tpe = ret.tpe, i = mem !int64 ] !compiler::Value
-    let addr = frame.mem.allocate(size)
+    let addr = frame.mem.allocate(ret.tpe.resolve().size)
     frame.locals(ret.name) = addr
     set(addr, ret.tpe, ptr)
 }
@@ -1019,6 +1019,7 @@ def eval_Call(insn: &compiler::Insn, state: &State) {
                     codegen::emit_block(std::stdout(), block)
                     block = block.next
                 }
+                print("==========================\n")
             }
 
             eval(function.block, state)
@@ -1123,9 +1124,9 @@ def eval_Inttoptr(insn: &compiler::Insn, state: &State) {
 }
 
 def eval_insn(insn: &compiler::Insn, state: &State) {
-    //if toolchain::trace_consteval {
-    //    codegen::emit(std::stdout(), insn)
-    //}
+    if toolchain::trace_consteval {
+        codegen::emit(std::stdout(), insn)
+    }
     switch insn.kind !int {
         case compiler::InsnKind::INSERTVALUE
             eval_InsertValue(insn, state)

std/arena.pr

@@ -35,6 +35,7 @@ export def allocate(arena: &Arena, type T) -> *T {
 }
 
 export def allocate(arena: &Arena, size: size_t) -> * {
+    assert size > 0, "Cannot allocate zero bytes"
     var end = arena.end
     if not end {
         arena.start = make_region(arena.region_capacity)