Replace function types with FunctionDef

Author: Victorious3

src/compiler.pr

@@ -391,11 +391,11 @@ export def walk_Def(node: &parser::Node, state: &typechecking::State) {
         }
     }
 
-    var tpe = typechecking::function(parser::identifier_to_str(name), parameter_t, return_t, state.module, extern, test = test).resolve()
+    var fdef = typechecking::function_def(parser::identifier_to_str(name), parameter_t, return_t, state.module, extern, test = test) !&FunctionDef
     //tpe.node = node
     let current_function = errors::current_function
     let current_signature = errors::current_signature
-    errors::current_function = tpe.type_name
+    errors::current_function = fdef.name
     errors::current_signature = node.signature_hash
 
     if body {
@@ -410,9 +410,9 @@ export def walk_Def(node: &parser::Node, state: &typechecking::State) {
             node.svalue = scope::create_function(state.scope, name, function.value)
         } else {
             if body {
-                node.svalue = scope::create_function(state.scope, name, share, tpe.id, scope::Phase::DEFINED, node, local_type_defs, impl = impl)
+                node.svalue = scope::create_function(state.scope, name, share, @fdef, scope::Phase::DEFINED, node, local_type_defs, impl = impl)
             } else {
-                node.svalue = scope::create_function(state.scope, name, share, tpe.id, scope::Phase::DECLARED, node, local_type_defs)
+                node.svalue = scope::create_function(state.scope, name, share, @fdef, scope::Phase::DECLARED, node, local_type_defs)
             }
         }
         if node.svalue {
@@ -424,7 +424,7 @@ export def walk_Def(node: &parser::Node, state: &typechecking::State) {
 
     if not function {
         function = [
-            tpe = tpe.id,
+            fdef = @fdef,
             module = state.module,
             locals = map::make(typechecking::TypeId),
             unmangled = parser::identifier_to_str(name),
@@ -476,7 +476,7 @@ export def walk_Def(node: &parser::Node, state: &typechecking::State) {
 
     errors::current_function = current_function
     errors::current_signature = current_signature
-    node.tpe = tpe.id
+    node.fdef = fdef
 }
 
 export def walk_TypeDecl(node: &parser::Node, state: &typechecking::State) {
@@ -573,8 +573,8 @@ export def walk_TypeDecl(node: &parser::Node, state: &typechecking::State) {
                 return_t.push(builtins::string_)
 
                 let ident = parser::make_identifier("to_string")
-                let ftpe = typechecking::function("to_string", parameter_t, return_t)
-                let v = scope::create_function(state.scope, ident, parser::ShareMarker::EXPORT, ftpe, local_type_defs = make_local_type_defs())
+                let fdef = typechecking::function_def("to_string", parameter_t, return_t)
+                let v = scope::create_function(state.scope, ident, parser::ShareMarker::EXPORT, fdef, local_type_defs = make_local_type_defs())
                 v.identifier = ident
                 left.svalue = scope::create_type(state.scope, name, share, tpe, scope::Phase::DEFINED, null)
                 typechecking::register(tpe, enum_tpe)
@@ -831,7 +831,7 @@ export def compile_function(value: &scope::Value, context: &scope::Scope, argume
     var function = node.value.def_.function
     if function.is_typechecked and not is_repurposed { return value }
 
-    let is_polymorph = typechecking::is_polymorph(function.tpe.resolve().parameter_t)
+    let is_polymorph = typechecking::is_polymorph(function.fdef.sig.parameter_t)
     if not is_polymorph { 
         compiler::predeclare_function(function, overwrite = true)
         const_module.result.functions(function.name) = function 
@@ -868,10 +868,10 @@ export def compile_function(value: &scope::Value, context: &scope::Scope, argume
 
     //print("Creating function ", function.tpe.type_name, "\n")
 
-    // This is a big ugly but what can we do
+    // This is a bit ugly but what can we do
     let debug = toolchain::debug_sym
     toolchain::debug_sym = false
-    compiler::create_function(node, node.tpe, node.value.def_.body, node.inner_scope, null, compiler_state, params = node.value.def_.params)
+    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 {

src/consteval.pr

@@ -456,9 +456,9 @@ export type Node = struct {
     loc: SourceLoc
 
     tpe: typechecking::TypeId
-    // This is for passing on a function from typechecking to the compiler
-    // TODO There might be better ways of doing this
-    function: typechecking::TypeId
+    fdef: &typechecking::FunctionDef
+    call_type: typechecking::TypeId
+
     svalue: &scope::Value
     scope: &scope::Scope
     // For things like if statements or functions
@@ -611,7 +611,8 @@ export def construct(copy: *Node, node: *Node) {
     copy.kind = node.kind
     copy.loc = node.loc
     copy.tpe = node.tpe
-    copy.function = node.function
+    copy.fdef = node.fdef
+    copy.call_type = node.call_type
     copy.svalue = node.svalue
     copy.scope = node.scope
     copy.inner_scope = node.inner_scope

src/parser.pr

@@ -400,7 +400,7 @@ def execute(source: Str) {
                     ] !parser::NodeFuncCall
                     let svalue = scope::get(old_node.scope, print_ident)
                     print_ident.svalue = svalue
-                    node.function = svalue.tpe
+                    node.fdef = svalue.fdef !&FunctionDef
                 }
         }
     }
@@ -411,7 +411,8 @@ def execute(source: Str) {
 
     // Compile delayed functions
     for var n in consteval::const_module.delayed_compile {
-        compiler::create_function(n, n.tpe, n.value.def_.body, n.inner_scope, null, consteval::const_module.compiler_state)
+        if not n.fdef { continue }
+        compiler::create_function(n, @n.fdef, n.value.def_.body, n.inner_scope, null, consteval::const_module.compiler_state)
     }
     consteval::const_module.delayed_compile = vector::make(type &parser::Node)