Some fixes

Author: Victorious3

src/debug.pr

@@ -767,8 +767,8 @@ def float_t_to_string(tpe: &typechecking::Type) -> Str {
     return "float" + tpe.size * 8
 }
 
-def type_def_t_to_string(tpe: &typechecking::Type, full_name: bool) -> Str {
-    return "Type<" + type_to_str(tpe.tpe, full_name) + '>'
+def type_t_to_string(tpe: &typechecking::Type, full_name: bool) -> Str {
+    return "type<" + type_to_str(tpe.tpe, full_name) + '>'
 }
 
 def variant_t_to_string(tpe: &typechecking::Type, full_name: bool) -> Str {
@@ -863,9 +863,7 @@ export def type_to_str(tpe: &typechecking::Type, full_name: bool = false) -> Str
             if tpe.is_anon { return "<anonymous>" }
             return tpe.type_name if full_name else tpe.name
         case typechecking::TypeKind::TYPE
-            return "type"
-        case typechecking::TypeKind::TYPE_DEF
-            return type_def_t_to_string(tpe, full_name)
+            return type_t_to_string(tpe, full_name)
         case typechecking::TypeKind::FUNCTION, typechecking::TypeKind::CLOSURE
             return function_t_to_string(tpe, full_name)
         case typechecking::TypeKind::TUPLE

src/scope.pr

@@ -1547,10 +1547,12 @@ export def get(
     }
 }
 
-export def get_const_value(scope: &Scope, id: &parser::Node) -> &Value {
+export def get_const_value(scope: &Scope, id: &parser::Node, error_on_fail: bool = true) -> &Value {
     let value = get(scope, id)
     if not value {
-        errors::errorn(id, "Unknown identifier `", parser::identifier_to_str(id), "`")
+        if error_on_fail { 
+            errors::errorn(id, "Unknown identifier `", parser::identifier_to_str(id), "`") 
+        }
         return null
     }
     if value.modifier != parser::VarDecl::CONST and value.modifier != parser::VarDecl::TYPE {
@@ -1559,16 +1561,16 @@ export def get_const_value(scope: &Scope, id: &parser::Node) -> &Value {
     return value
 }
 
-export def get_type(scope: &Scope, id: &parser::Node) -> &typechecking::TypeRef {
-    let value = get_const_value(scope, id)
+export def get_type(scope: &Scope, id: &parser::Node, error_on_fail: bool = true) -> &typechecking::TypeRef {
+    let value = get_const_value(scope, id, error_on_fail)
     if not value { return null }
     if value.modifier != parser::VarDecl::TYPE {
         return null
     }
     return value.tpe
 }
-export def get_type_id(scope: &Scope, id: &parser::Node) -> typechecking::TypeId {
-    let tpe = get_type(scope, id)
+export def get_type_id(scope: &Scope, id: &parser::Node, error_on_fail: bool = true) -> typechecking::TypeId {
+    let tpe = get_type(scope, id, error_on_fail)
     if not tpe { return 0 }
     return tpe.resolve(scope)
 }
@@ -1705,8 +1707,7 @@ export def create_function(scope: &Scope, name_node: &parser::Node, v: &Value, i
             /*if phase == Phase::COMPILED and next.node and next.state {
                 next.tpe = typechecking::lookup_parameters(next.node, next.state)
             }*/
-            let s = typechecking::overload_score(next.fdef, fdef.parameter_t, scope, true, impl = false)
-            if s == 0 {
+            if typechecking::parameter_equals(next.fdef, fdef.parameter_t, scope) {
                 //if phase == Phase::DECLARED { return next }
                 if phase == Phase::DEFINED and next.phase != Phase::DECLARED {
                     errors::errorn(name_node, "Function `", name, "` was already declared previously (same arguments)")

src/typechecking.pr

@@ -287,13 +287,13 @@ export def kind(typeref: &TypeRef) -> TypeKind {
     }
 }
 
-export def resolve(typeref: &TypeRef, scpe: &Scope) -> TypeId {
+export def resolve(typeref: &TypeRef, scpe: &Scope, error_on_fail: bool = true) -> TypeId {
     if not typeref { return 0 }
     if typeref.tpe {
         return typeref.tpe
     }
     if typeref.name {
-        let id = scope::get_type_id(scpe, parser::make_identifier(typeref.name))
+        let id = scope::get_type_id(scpe, parser::make_identifier(typeref.name), error_on_fail = error_on_fail)
         typeref.tpe = id
         return id
     }
@@ -2819,6 +2819,18 @@ export def replace_type_defs(
             rtpe = left.value.tpe
         }
 
+        if left.kw == parser::VarDecl::TYPE and rtpe and rtpe.kind == TypeKind::TYPE {
+            // We have a type parameter, create it in scope and continue
+            left.tpe = make_type_ref(rtpe)
+            scope::create_type(
+                scpe, 
+                parser::make_identifier(left.name), 
+                parser::ShareMarker::NONE, 
+                make_type_ref(rtpe.tpe)
+            )
+            continue
+        }
+
         if not rtpe { return }
         if convert_type_score(left.tpe, rtpe, scpe, impl) < 0 { return }
 
@@ -2851,28 +2863,20 @@ export def replace_type_defs(
     }
 }
 
-export def overload_score(
-    a: FunctionDef, param_b: &Vector(NamedParameterPre), scpe: &scope::Scope, 
-    positional: bool, partial: bool = false, impl: bool = true) -> int {
+export def parameter_equals(
+    a: FunctionDef, param_b: &Vector(NamedParameterPre), scpe: &scope::Scope) -> bool {
 
-    // TODO Factor this out into a function and make sure that its used everywhere
-    let param_b_converted = vector::make(NamedParameter)
+    if a.parameter_t.length != vector::length(param_b) {
+        return false
+    }
     for var i in 0..vector::length(param_b) {
-        let npb = param_b(i)
-        param_b_converted.push([
-            name = npb.name,
-            tpe = npb.tpe.resolve(scpe),
-            value = npb.value,
-            kw = npb.kw,
-            varargs = npb.varargs,
-            node = npb.node
-        ] !NamedParameter)
+        let left = param_b(i)
+        let right = a.parameter_t(i)
+        if left != right {
+            return false
+        }
     }
-
-    return overload_score(
-        a.parameter_t, a.return_t, param_b_converted, scpe, 
-        positional, partial, impl
-    )
+    return true
 }
 
 export def overload_score(
@@ -2948,11 +2952,11 @@ export def overload_score(
             lvalue = array(left.tpe, parser::VarDecl::VAR)
         }
         var score = -1
-        if lvalue and lvalue.kind() == TypeKind::TYPE {
+        if left.kw == parser::VarDecl::TYPE {
             if kind(right.tpe) == TypeKind::TYPE {
                 if left.value and right.value and equals(left.value.value_tpe, right.value.value_tpe) {
                     score = 0
-                } else if not left.value.value_tpe and right.value {
+                } else if not left.value and right.value {
                     // TODO test this
                     score = 4
                 }
@@ -3975,7 +3979,7 @@ def walk_Identifier(node: &parser::Node, state: &State) {
     scope::add_reference(value, node)
 
     if value.kind == scope::ValueKind::TYPE {
-        node.tpe = _type(value.value.value_tpe)
+        node.tpe = _type(value.tpe.resolve(state.scope))
     } else {
         node.tpe = value.get_type()
     }
@@ -4280,7 +4284,12 @@ export def walk_VarDecl(node: &parser::Node, state: &State, set_constant: bool =
             }
 
             if tpe_node {
-                ltypes.push(type_lookup(tpe_node, state).tpe)
+                let tpe = type_lookup(tpe_node, state)
+                if not tpe { 
+                    ltypes.push(0)
+                } else {
+                    ltypes.push(tpe.tpe)
+                }
             } else {
                 ltypes.push(0)
             }