Fix varargs and some other stuff

Author: Victorious3

src/compiler.pr

@@ -329,6 +329,7 @@ export type InsnCall = struct {
 }
 
 export def call(state: &State, name: Str, tpe: typechecking::TypeId, args: &[Value], loc: &Value = null) -> Value {
+    assert name
     let name_v = [ kind = ValueKind::GLOBAL, name = name ] !Value
     return call(state, name_v, tpe, args, parser::InlineSpecifier::NONE, null, loc)
 }
@@ -8759,9 +8760,8 @@ def create_destructor(tpe: &typechecking::Type, value: Value, state: &State) {
                     let destructor = typechecking::get_builtin_destructor(field.tpe)
 
                     if destructor {
-                        let dtortpe = destructor.get_type().resolve()
                         let field_value = state.gep(ptpe, structure_type.id, obj, [make_int_value(0), make_int_value(i)])
-                        state.call(dtortpe.type_name, 0, [field_value])
+                        state.call(destructor.fdef.name, 0, [field_value])
                     }
                 }
             }
@@ -8834,7 +8834,7 @@ def create_destructor(tpe: &typechecking::Type, value: Value, state: &State) {
 }
 
 def do_create_type(tpe: &typechecking::Type, svalue: &scope::Value, module: &toolchain::Module) -> &Value {
-    if toolchain::no_stdlib { return NO_VALUE }
+    //if toolchain::no_stdlib { return NO_VALUE }
 
     //let generic = typechecking::get_generic(tpe)
     //if generic and generic.tc_incomplete { return null }
@@ -8854,11 +8854,9 @@ def do_create_type(tpe: &typechecking::Type, svalue: &scope::Value, module: &too
     toolchain::types.result.globals(global2.name) = global2
     toolchain::types.imported.add(global2.name)
 
-    let name_str = debug::type_to_str(tpe, full_name = true)
-
     let type_ = builtins::type_t().resolve()
     value.values = allocate_ref(Value, 3)
-    value.values(0) = [ kind = ValueKind::INT, tpe = builtins::int64_, i = md5::high(md5::md5(name_str)) ] !Value
+    value.values(0) = [ kind = ValueKind::INT, tpe = builtins::int64_, i = tpe.id ] !Value
     value.values(1) = [ kind = ValueKind::ZEROINITIALIZER, tpe = type_.field_types(1).tpe ] !Value
     value.values(2) = [ kind = ValueKind::ZEROINITIALIZER, tpe = type_.field_types(2).tpe ] !Value
 
@@ -8992,9 +8990,7 @@ export def create_type(tpe: &typechecking::Type, module: &toolchain::Module, res
 
     let state = toolchain::types_state
     let assembly_name = scope::assembly_name(svalue, state)
-    if not state.consteval and 
-        not map::contains(module.result.globals, assembly_name) {
-            
+    if not map::contains(module.result.globals, assembly_name) {
         let global = [
             external = true,
             name = assembly_name,
@@ -9042,9 +9038,8 @@ def change_value_to_type(tpe: &typechecking::Type, loc: &Value, state: &State) -
 
     let fun = declare_reflection_type_id_fun(state)
     if not fun { return NO_VALUE }
-    let hash = md5::high(md5::md5(debug::type_to_str(tpe, full_name = true)))
     let tmp = state.alloca(builtins::type_t(), loc)
-    let res = state.call(fun.fdef.name, builtins::TypeT_, [[ tpe = builtins::uint64_, kind = ValueKind::INT, i = hash ] !Value], loc)
+    let res = state.call(fun.fdef.name, builtins::TypeT_, [[ tpe = builtins::uint64_, kind = ValueKind::INT, i = tpe.id ] !Value], loc)
     state.store(tmp, res, loc)
     create_temporary(tmp, res, loc, state)
     return res
@@ -9468,7 +9463,7 @@ def generate_vtable_function(function: &Function, fdef: typechecking::FunctionDe
         let type_entry = typechecking::type_registry(keys(i))
         if is_ref(type_entry.tpe) and typechecking::implements(type_entry, intf, state.scope) {
             // FIXME This whole branch isn't working yet because interfaces don't work right now
-            let hash = md5::high(md5::md5(debug::type_to_str(type_entry, full_name = true)))
+            let hash = type_entry.id
             if hashes.contains(hash) { continue }
             hashes.add(hash)
 

src/runtime.pr

@@ -219,6 +219,8 @@ export def reference(tpe: *Type) -> *Type {
     return ret
 }*/
 
+// FIXME Commend this in
+/*
 import cstd
 import optional
 
@@ -246,4 +248,4 @@ export def destruct(this: *Generator(type T)) {
 
 export def next(generator: &Generator(type T)) -> optional::Optional(T) {
     return generator.implementation(generator)
-}
+}*/

src/scope.pr

@@ -137,6 +137,7 @@ export type Value = struct {
 }
 
 export def get_type(value: &Value) -> typechecking::TypeId {
+    assert value.module
     return value.tpe.resolve(value.module.scope)
 }
 
@@ -396,7 +397,8 @@ export def enter_scope(parents: &Vector(weak &Scope), module: &toolchain::Module
         parents = parents,
         fields = map::make(type &Value),
         implicits = vector::make(type &Value),
-        underscore_count = 0
+        underscore_count = 0,
+        is_global = is_global
     ] !&Scope
     let function_parent = get_function_parent(s)
     if function_parent {
@@ -1047,7 +1049,7 @@ export def generate_function(scope: &Scope, node: &parser::Node, parameter_t: &V
             ] !typechecking::NamedParameterPre)
 
             let name_node = parser::make_identifier("__destruct__")
-            let fdef = typechecking::function_def("__destruct__", args, vector::make(type &typechecking::TypeRef))
+            let fdef = typechecking::function_def("__destruct__", args, vector::make(type &typechecking::TypeRef), context = scope.module)
             let fun = has_function(builtins::builtins, fdef)
             if fun { return fun }
 
@@ -1075,7 +1077,7 @@ export def generate_function(scope: &Scope, node: &parser::Node, parameter_t: &V
                 ] !typechecking::NamedParameterPre)
 
                 let name_node = parser::make_identifier("__construct__")
-                let fdef = typechecking::function_def("__construct__", args, vector::make(type &typechecking::TypeRef))
+                let fdef = typechecking::function_def("__construct__", args, vector::make(type &typechecking::TypeRef), context = scope.module)
                 let fun = has_function(builtins::builtins, fdef)
                 if fun { return fun }
 

src/toolchain.pr

@@ -653,8 +653,9 @@ def create_types_module {
         filename = null,
         modulename = "type",
         node = null,
-        scpe = scope::enter_scope(null !&scope::Scope, types, true)
+        scpe = scope::enter_scope(null !&scope::Scope, null, true)
     )
+    types.scope.module = types
     types.is_dirty = true
     modules("type") = types
 

src/typechecking.pr

@@ -319,7 +319,14 @@ def resolve_generic(generic: &Pattern, scpe: &Scope, error_on_fail: bool = true)
         case TypeKind::FUNCTION, TypeKind::CLOSURE
             var params: &Vector(NamedParameter) = vector::make(NamedParameter)
             for var param in generic.parameter_t {
-                vector::push(params, [tpe = resolve(param.tpe, scpe, error_on_fail)] !NamedParameter)
+                vector::push(params, [ 
+                    name = param.name, 
+                    tpe = resolve(param.tpe, scpe, error_on_fail), 
+                    value = param.value, 
+                    kw = param.kw, 
+                    varargs = param.varargs, 
+                    node = param.node 
+                ] !NamedParameter)
             }
             var return_ids: &Vector(TypeId) = vector::make(TypeId)
             for var ret in generic.return_t {
@@ -1283,11 +1290,12 @@ export def function_def(
     ] !FunctionDef
 }
 export def to_type(fdef: FunctionDef, scpe: &scope::Scope) -> TypeId {
-    return function(fdef.parameter_t, fdef.return_t).resolve(scpe)
+    let generic = [ kind = TypeKind::FUNCTION, parameter_t = fdef.parameter_t, return_t = fdef.return_t ] !&Pattern
+    return generic.resolve_generic(scpe)
 }
 export def to_type(fdef: FunctionDef) -> TypeId {
     assert fdef.context != null
-    return function(fdef.parameter_t, fdef.return_t).resolve(fdef.context.scope)
+    return to_type(fdef, fdef.context.scope)
 }
 
 export type Signature = struct {
@@ -3426,7 +3434,7 @@ def do_type_lookup(node: &parser::Node, state: &State, is_type: bool = false) ->
             scope::create_type(state.scope, node, parser::ShareMarker::NONE, make_type_ref(name))
             return make_type_ref([ kind = TypeKind::TYPE_DEF, name = name ] !&Pattern)
         } else /*if not lookup_default*/ {
-            let value = scope::get(state.scope, node)
+            let value = scope::get(state.scope, node, force_compile = not consteval::is_static)
             if not value {
                 //errors::errorn(node, "Unknown identifier `", name, "`")
                 scope::create_dependency(state.current_value(), scope::make_ident(name))
@@ -5697,7 +5705,7 @@ def check_for_apply_and_update(node: &parser::Node, left: &parser::Node, argumen
     let right = arguments(0).node
 
     if not left or not right { return false }
-    let tpe = (@left).tpe
+    let tpe = left.tpe
     if not tpe { return false }
     if is_function(tpe) { return false }
 
@@ -5791,9 +5799,14 @@ export def walk_Call(node: &parser::Node, dry_run: bool, state: &State) -> bool
             walk(node, left, state)
         } else {
             let value = get_value(left, state, force_compile = not consteval::is_static, dry_run = true)
-            if value and value.kind == scope::ValueKind::FUNCTION and not is_polymorph(value.fdef.parameter_t){
+            if value {
                 left.svalue = value
-                left.tpe = value.fdef.to_type()
+                if value.kind == scope::ValueKind::FUNCTION and not is_polymorph(value.fdef.parameter_t) {
+                    // TODO is this really correct?
+                    left.tpe = value.fdef.to_type()
+                } else {
+                    left.tpe = value.get_type()
+                }
             }
         }
     }