More consteval fixes

Author: Victorious3

src/compiler.pr

@@ -9559,10 +9559,12 @@ export def predeclare_functions(module: &toolchain::Module) {
     }
 }
 
-def generate_vtable_function(function: &Function, fdef: typechecking::FunctionDef, state: &State) {
+export def generate_vtable_function(function: &Function, fdef: typechecking::FunctionDef, state: &State) {
     let ftpe = fdef.to_type().resolve()
     let first_param = ftpe.parameter_t(0).tpe
 
+    debug::trace("Generating vtable function for ", fdef.name)
+
     function.block = make_block()
     function.forward_declare = false
     let previous_block = state.current_block

src/consteval.pr

@@ -878,6 +878,16 @@ export def compile_queued_functions {
 
     for var fdef in @function_queue.keys() {
         let entry = function_queue(fdef)
+        
+        if not entry.node {
+            // Create dyn dispatch
+            let function = compiler::predeclare_function(fdef, const_module)
+            compiler::generate_vtable_function(function, fdef, compiler_state)
+            const_module.result.functions(function.name) = function
+            continue
+        }
+
+        // Compile function
         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 {
@@ -915,11 +925,9 @@ export def compile_function(value: &scope::Value, context: &scope::Scope, argume
     var node = value.node
     var module = value.module
 
-    if not node { 
-        // Sneak in a call here so that it gets triggered for functions that don't have a node (i.e generated functions)
-        compiler::create_dyn_dispatch(module.dyn_dispatch_consteval, module.compiler_state)
-
-        return value 
+    if not node {
+        queue_function(null, value.fdef)
+        return value
     }
 
     /*var is_repurposed = false // When There's no node and we find a new function we don't need to typecheck anymore
@@ -988,7 +996,6 @@ 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
     queue_function(node, function.fdef)
 
     compiler::create_dyn_dispatch(state.module.dyn_dispatch_consteval, state.module.compiler_state)

src/scope.pr

@@ -2199,6 +2199,10 @@ export def trigger_impl(scope: &Scope, tpe: &typechecking::Type) {
                     if fun.fdef.return_t.length != member.return_t.length {
                         res = false
                     } else {
+                        if consteval::is_static {
+                            consteval::compile_function(fun, scope)
+                        }
+
                         let ftpe = fun.fdef.to_type().resolve()
                         if not ftpe {
                             print_fdef(fun.fdef)
@@ -2241,7 +2245,7 @@ export def trigger_impl(scope: &Scope, tpe: &typechecking::Type) {
             }
             right.implementors(tpe.id) = functions
 
-            //print(tpe !*, " ", debug::type_to_str(tpe), " ", tpe.id, " implements ", debug::type_to_str(right), "\n")
+            debug::trace("trigger_impl: ", debug::type_to_str(tpe), " implements ", debug::type_to_str(right))
             tpe.implements.add(right.id)
         }
     }