Fix some stuff, broke some other stuff

Author: Victorious3

src/compiler.pr

@@ -3100,6 +3100,10 @@ def walk_Call(node: &parser::Node, state: &State) -> Value {
         }
     }
     if not tpe { 
+        debug::trace("Error: Could not determine type of function call `" + (
+                parser::identifier_to_str(left) if left.kind == parser::NodeKind::IDENTIFIER else to_str("unknown")
+            ) + "` " + node.module.module + "@" + node.loc.line
+        )
         return NO_VALUE
     }
 
@@ -7171,6 +7175,10 @@ export def insert_function(module: &toolchain::Module, function: &Function, over
 
 export def predeclare_function(fdef: typechecking::FunctionDef, module: &toolchain::Module) -> &Function {
     let fun_name = fdef.name
+    if typechecking::is_polymorph(fdef) {
+        error("Cannot predeclare polymorphic function ", fun_name, "\n")
+        return null
+    }
     var function = module.result.functions.get_or_default(fun_name, null)
     if function {
         return function 
@@ -7179,6 +7187,7 @@ export def predeclare_function(fdef: typechecking::FunctionDef, module: &toolcha
             fdef = fdef,
             module = module
         ] !&Function
+        //print("Predeclaring function ", fun_name, " in module ", module.module, " ", function !*, "\n")
     }
     predeclare_function(function, module.scope)
     return function
@@ -7482,17 +7491,18 @@ export def create_function(
     no_cleanup: bool = false,
     is_closure: bool = false,
     params: &Vector(&Node) = null
-) {
+) -> &Function {
     let function = state.module.result.functions.get_or_default(fdef.name, null)
-    if not function { return }
+    if not function { return null }
     function.name = fdef.name
     // TODO Return multiple values via tuple
-    if function.has_yield and (not function.ret or typechecking::is_tuple(function.ret)) { return }
+    if function.has_yield and (not function.ret or typechecking::is_tuple(function.ret)) { return null }
     if not block {
         block = make_block()
     }
 
     debug::trace("Compiling function " + function.name)
+    print(function !*, "\n")
 
     function.forward_declare = false
     function.allocas = vector::make(type &Insn)
@@ -7931,6 +7941,8 @@ export def create_function(
     state.inline_start_block = previous_inline_start_block
     errors::current_function = current_fun
     errors::current_signature = current_signature
+
+    return function
 }
 
 def make_string(str: Str, state: &State) -> Value {
@@ -9195,6 +9207,7 @@ export def load_fun_load_types_function {
             var lock = fun_load_types_rec_lock
             fun_load_types_rec_lock = true
             consteval::compile_function(fun_load_types, state.scope)
+            consteval::compile_queued_functions()
             create_builtin_functions()
             fun_load_types_rec_lock = lock
         }

src/consteval.pr

@@ -67,11 +67,13 @@ def set_current_function -> &compiler::Function {
     ] !&compiler::Function
     compiler_state.function_stack.push(function)
     compiler_state.current_block = block
-
     return function
 }
 
 export def expr(node: &parser::Node, state: &typechecking::State) -> compiler::Value {
+    let prev_queue = function_queue
+    function_queue = map::make(typechecking::FunctionDef, QueueEntry)
+    
     if not node { return compiler::NO_VALUE }
     walk(node.parent, node, state)
     let previous_block = compiler_state.current_block
@@ -80,7 +82,10 @@ export def expr(node: &parser::Node, state: &typechecking::State) -> compiler::V
     walk(node.parent, node, state)
     var result = compiler::walk_expression(node, compiler_state)
     vector::insert(function.block.insn, 0, function.allocas)
-    let estate = eval::eval(compiler_state)
+    let estate = compile_and_eval()
+
+    function_queue = prev_queue
+
     result = eval::get_value(result, estate)
     compiler_state.function_stack.pop()
     compiler_state.current_block = previous_block
@@ -89,6 +94,10 @@ export def expr(node: &parser::Node, state: &typechecking::State) -> compiler::V
 
 export def boolean_expr(node: &parser::Node, state: &typechecking::State) -> compiler::Value {
     if not node { return compiler::NO_VALUE }
+    
+    let prev_queue = function_queue
+    function_queue = map::make(typechecking::FunctionDef, QueueEntry)
+
     walk(node.parent, node, state)
     let previous_block = compiler_state.current_block
     let function = set_current_function()
@@ -97,7 +106,10 @@ export def boolean_expr(node: &parser::Node, state: &typechecking::State) -> com
     var result = compiler::walk_expression(node, compiler_state)
     result = compiler::convert_to(node, result, builtins::bool_, compiler_state)
     vector::insert(function.block.insn, 0, function.allocas)
-    let estate = eval::eval(compiler_state)
+    let estate = compile_and_eval()
+
+    function_queue = prev_queue
+
     result = eval::get_value(result, estate)
     compiler_state.function_stack.pop()
     compiler_state.current_block = previous_block
@@ -205,6 +217,9 @@ export def evaluate_parameter(node: &parser::Node, param: &parser::Node, tpe: ty
         // Set up temporary scope
         let prev_scope = compiler_state.module.scope
         let temp_scope = scope::enter_scope(state.module.scope)
+        
+        let prev_queue = function_queue
+        function_queue = map::make(typechecking::FunctionDef, QueueEntry)
 
         compiler_state.scope = temp_scope
         let previous_block = compiler_state.current_block
@@ -213,11 +228,14 @@ export def evaluate_parameter(node: &parser::Node, param: &parser::Node, tpe: ty
         var result = compiler::walk_expression(param.value.param.value, compiler_state)
         vector::insert(function.block.insn, 0, function.allocas)
         let gvalue = compiler::make_global_value(result.tpe, "default_param", null, compiler_state)
-        let estate = eval::eval(compiler_state)
+        
+        let estate = compile_and_eval()
+        function_queue = prev_queue
+
         result = eval::get_value(result, estate)
 
         compiler_state.scope = prev_scope
-
+        
         if result.kind != compiler::ValueKind::NULL {
             eval::set_value(gvalue, result, estate)
 
@@ -435,6 +453,7 @@ export def walk_Def(node: &parser::Node, state: &typechecking::State) {
             test = test,
             imported = imported
         ] !&compiler::Function
+        //print("Consteval: ", fdef.name, " ", function !*, "\n")
         node.value.def_.function = function
     }
     function.has_yield = has_yield
@@ -646,13 +665,18 @@ export def walk_top_VarDecl(node: &parser::Node, state: &typechecking::State) {
             walk(node, right(i), state)
         }
 
+        let previous_queue = function_queue
+        function_queue = map::make(typechecking::FunctionDef, QueueEntry)
+
         let previous_block = compiler_state.current_block
         let function = set_current_function()
         typechecking::walk_VarDecl(node, state, true)
         let assign = compiler::walk_top_VarDecl(node, compiler_state, true)
         compiler::walk_expression(assign, compiler_state)
         vector::insert(function.block.insn, 0, function.allocas)
-        eval::eval(compiler_state)
+        compile_and_eval()
+
+        function_queue = previous_queue
 
         for var i in 0..vector::length(left) {
             let n = left(i)
@@ -720,6 +744,9 @@ def walk_VarDecl(node: &parser::Node, state: &typechecking::State) {
             walk(node, right(i), state)
         }
 
+        let previous_queue = function_queue
+        function_queue = map::make(typechecking::FunctionDef, QueueEntry)
+
         let previous_block = compiler_state.current_block
         let function = set_current_function()
         typechecking::walk_VarDecl(node, state, true)
@@ -730,7 +757,10 @@ def walk_VarDecl(node: &parser::Node, state: &typechecking::State) {
 
         compiler::walk_VarDecl(node, compiler_state, true)
         vector::insert(function.block.insn, 0, function.allocas)
-        let estate = eval::eval(compiler_state)
+        let estate = compile_and_eval()
+
+        function_queue = previous_queue
+
         let locals = eval::get_stack_frame(estate).locals
 
         for var i in 0..vector::length(left) {
@@ -820,6 +850,54 @@ export def load_function(value: &scope::Value) {
     }
 }
 
+type QueueEntry = struct {
+    node: &parser::Node
+}
+
+var function_queue: &Map(typechecking::FunctionDef, QueueEntry) 
+
+def queue_function(node: &parser::Node, fdef: typechecking::FunctionDef) {
+    if not function_queue { 
+        function_queue = map::make(typechecking::FunctionDef, QueueEntry)
+    }
+
+    let entry = [
+        node = node
+    ] !QueueEntry
+    function_queue(fdef) = entry
+}
+
+var recursion_guard = false
+export def compile_queued_functions {
+    if recursion_guard { return }
+    if not function_queue { return }
+
+    recursion_guard = true
+    let debug = toolchain::debug_sym
+    toolchain::debug_sym = false
+    
+    for var fdef in @function_queue.keys() {
+        let entry = function_queue(fdef)
+        let function = compiler::create_function(entry.node, fdef, entry.node.value.def_.body, entry.node.inner_scope, null, compiler_state, params = entry.node.value.def_.params) 
+        
+        if function and function.defer_functions {
+            for var i in 0..vector::length(function.defer_functions) {
+                let deferf = function.defer_functions(i)
+                const_module.result.functions(deferf.name) = deferf
+            }
+        }
+    }
+
+    toolchain::debug_sym = debug
+    function_queue.clear()
+    recursion_guard = false
+}
+
+def compile_and_eval -> &eval::State {
+    compile_queued_functions()
+    return eval::eval(compiler_state)
+}
+
 // This function compiles a function that is called in constant evaluation
 export def compile_function(value: &scope::Value, context: &scope::Scope, arguments: &Vector(typechecking::NamedParameter) = null) -> &scope::Value {
     load_function(value)
@@ -880,7 +958,8 @@ export def compile_function(value: &scope::Value, context: &scope::Scope, argume
     let state = typechecking::make_state(module)
     if not function.is_typechecked {
         if arguments and is_polymorph {
-            node = typechecking::walk_Def_with_type_argument(node, arguments, context, state)
+            let scope2 = scope::enter_scope(context)
+            node = typechecking::walk_Def_with_type_argument(node, arguments, scope2, state)
             function = node.value.def_.function
             compiler::predeclare_function(function, context, overwrite = true)
             const_module.result.functions(function.name) = function 
@@ -900,17 +979,7 @@ export def compile_function(value: &scope::Value, context: &scope::Scope, argume
     //print("Creating function ", function.name, "\n")
 
     // This is a bit ugly but what can we do
-    let debug = toolchain::debug_sym
-    toolchain::debug_sym = false
-    compiler::create_function(node, function.fdef, node.value.def_.body, node.inner_scope, null, compiler_state, params = node.value.def_.params)
-    toolchain::debug_sym = debug
-    
-    if function.defer_functions {
-        for var i in 0..vector::length(function.defer_functions) {
-            let deferf = function.defer_functions(i)
-            const_module.result.functions(deferf.name) = deferf
-        }
-    }
+    queue_function(node, function.fdef)
 
     compiler::create_dyn_dispatch(state.module.dyn_dispatch_consteval, state.module.compiler_state)
 
@@ -1080,6 +1149,10 @@ def walk_Error(node: &parser::Node, state: &typechecking::State) {
     is_static = true
     walk(node, expr, state)
 
+
+    let prev_queue = function_queue
+    function_queue = map::make(typechecking::FunctionDef, QueueEntry)
+
     let previous_block = compiler_state.current_block
     let function = set_current_function()
     typechecking::walk(node, expr, state)
@@ -1089,7 +1162,9 @@ def walk_Error(node: &parser::Node, state: &typechecking::State) {
 
     var result = compiler::walk_expression(expr, compiler_state)
     vector::insert(function.block.insn, 0, function.allocas)
-    let estate = eval::eval(compiler_state)
+    let estate = compile_and_eval()
+    function_queue = prev_queue
+
     result = eval::get_value(result, estate)
     if not typechecking::equals(result.tpe, builtins::string_) {
         errors::errorn(node, "Error pragma expects string, got ", debug::type_to_str(result.tpe))

src/eval.pr

@@ -538,7 +538,12 @@ def eval_Alloca(insn: &compiler::Insn, state: &State) {
     let frame = get_stack_frame(state)
     let ret = insn.value.alloca.ret
 
-    let size = ret.tpe.resolve().size
+    let tpe = ret.tpe.resolve()
+    let size = tpe.size
+    if tpe.size == 0 {
+        errors::errorv("Error: allocating zero sized type `", debug::type_to_str(ret.tpe), "`\n")
+        return
+    }
     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
@@ -1026,6 +1031,9 @@ def eval_Call(insn: &compiler::Insn, state: &State) {
                 print("==========================\n")
             }
 
+            if not function.block {
+                errors::errorv("Function `", function.name, "` has no body ")
+            }
             eval(function.block, state)
 
             if ret.tpe {

src/repl.pr

@@ -447,6 +447,8 @@ def execute(source: Str) {
     @mem = (*_args) !*
     stack_frame.locals("args.value") = mem
 
+    consteval::compile_queued_functions()
+    
     eval::push_stack_frame(stack_frame, estate)
     eval::eval(main_function.block, estate)
     eval::pop_stack_frame(estate)